fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2025-03-16 16:20:49 +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
Show Stats 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)]
#[no_mangle]
#[repr(C)]
pub enum wasmer_compile_result_t {
WASMER_COMPILE_OK = 1,
WASMER_COMPILE_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,
pub enum wasmer_result_t {
WASMER_OK = 1,
WASMER_ERROR = 2,
}
#[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(
mut memory: *mut *mut wasmer_memory_t,
limits: wasmer_limits_t,
) -> wasmer_memory_result_t {
) -> wasmer_result_t {
let desc = MemoryDescriptor {
minimum: Pages(limits.min),
maximum: Some(Pages(limits.max)),
@ -142,11 +118,11 @@ pub unsafe extern "C" fn wasmer_memory_new(
Ok(memory) => memory,
Err(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 };
wasmer_memory_result_t::WASMER_MEMORY_OK
wasmer_result_t::WASMER_OK
}
#[allow(clippy::cast_ptr_alignment)]
@ -154,14 +130,14 @@ pub unsafe extern "C" fn wasmer_memory_new(
pub extern "C" fn wasmer_memory_grow(
memory: *mut wasmer_memory_t,
delta: uint32_t,
) -> wasmer_memory_result_t {
) -> wasmer_result_t {
let memory = unsafe { Box::from_raw(memory as *mut Memory) };
let maybe_delta = memory.grow(Pages(delta));
Box::into_raw(memory);
if let Some(_delta) = maybe_delta {
wasmer_memory_result_t::WASMER_MEMORY_OK
wasmer_result_t::WASMER_OK
} 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(
mut table: *mut *mut wasmer_table_t,
limits: wasmer_limits_t,
) -> wasmer_table_result_t {
) -> wasmer_result_t {
let desc = TableDescriptor {
element: ElementType::Anyfunc,
minimum: limits.min,
@ -189,11 +165,11 @@ pub unsafe extern "C" fn wasmer_table_new(
Ok(table) => table,
Err(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 };
wasmer_table_result_t::WASMER_TABLE_OK
wasmer_result_t::WASMER_OK
}
#[allow(clippy::cast_ptr_alignment)]
@ -201,14 +177,14 @@ pub unsafe extern "C" fn wasmer_table_new(
pub extern "C" fn wasmer_table_grow(
table: *mut wasmer_table_t,
delta: uint32_t,
) -> wasmer_table_result_t {
) -> wasmer_result_t {
let table = unsafe { Box::from_raw(table as *mut Table) };
let maybe_delta = table.grow(delta);
Box::into_raw(table);
if let Some(_delta) = maybe_delta {
wasmer_table_result_t::WASMER_TABLE_OK
wasmer_result_t::WASMER_OK
} 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_len: uint32_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) };
if wasm_bytes.is_null() {
return wasmer_compile_result_t::WASMER_COMPILE_ERROR;
return wasmer_result_t::WASMER_ERROR;
}
let bytes: &[u8] =
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 {
Ok(instance) => instance,
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 };
Box::into_raw(import_object);
wasmer_compile_result_t::WASMER_COMPILE_OK
wasmer_result_t::WASMER_OK
}
#[allow(clippy::cast_ptr_alignment)]
@ -333,17 +309,17 @@ pub unsafe extern "C" fn wasmer_instance_call(
params_len: c_int,
results: *mut wasmer_value_t,
results_len: c_int,
) -> wasmer_call_result_t {
) -> wasmer_result_t {
// TODO handle params and results
if instance.is_null() {
return wasmer_call_result_t::WASMER_CALL_ERROR;
return wasmer_result_t::WASMER_ERROR;
}
if name.is_null() {
return wasmer_call_result_t::WASMER_CALL_ERROR;
return wasmer_result_t::WASMER_ERROR;
}
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);
@ -382,11 +358,11 @@ pub unsafe extern "C" fn wasmer_instance_call(
};
results[0] = ret;
}
wasmer_call_result_t::WASMER_CALL_OK
wasmer_result_t::WASMER_OK
}
Err(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);
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);
assert(compile_result == WASMER_COMPILE_OK);
assert(compile_result == WASMER_OK);
wasmer_value_t params[] = {};
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);
assert(call_result == WASMER_CALL_OK);
assert(call_result == WASMER_OK);
assert(print_str_called);
assert(memory_len == 17);

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

@ -17,9 +17,9 @@ int main()
fclose(file);
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);
assert(compile_result == WASMER_COMPILE_OK);
assert(compile_result == WASMER_OK);
wasmer_value_t param_one;
param_one.tag = WASM_I32;
@ -32,16 +32,16 @@ int main()
wasmer_value_t 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("Result: %d\n", results[0].value.I32);
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);
assert(call_result2 == WASMER_CALL_ERROR);
assert(call_result2 == WASMER_ERROR);
int error_len = wasmer_last_error_length();
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;
descriptor.min = 10;
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);
assert(memory_result == WASMER_MEMORY_OK);
assert(memory_result == WASMER_OK);
uint32_t len = wasmer_memory_length(memory);
printf("Memory pages length: %d\n", len);
assert(len == 10);
wasmer_memory_result_t grow_result = wasmer_memory_grow(memory, 2);
assert(grow_result == WASMER_MEMORY_OK);
wasmer_result_t grow_result = wasmer_memory_grow(memory, 2);
assert(grow_result == WASMER_OK);
uint32_t new_len = wasmer_memory_length(memory);
printf("Memory pages length: %d\n", new_len);
@ -29,8 +29,8 @@ int main()
assert(bytes_len == 12 * 65536);
// Err, grow beyond max
wasmer_memory_result_t grow_result2 = wasmer_memory_grow(memory, 10);
assert(grow_result2 == WASMER_MEMORY_ERROR);
wasmer_result_t grow_result2 = wasmer_memory_grow(memory, 10);
assert(grow_result2 == WASMER_ERROR);
// int error_len = wasmer_last_error_length();
// char *error_str = malloc(error_len);
// wasmer_last_error_message(error_str, error_len);
@ -42,7 +42,7 @@ int main()
// wasmer_limits_t bad_descriptor;
// bad_descriptor.min = 15;
// 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);
// 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;
descriptor.min = 10;
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);
assert(table_result == WASMER_TABLE_OK);
assert(table_result == WASMER_OK);
uint32_t len = wasmer_table_length(table);
printf("Table length: %d\n", len);
assert(len == 15);
// wasmer_table_result_t grow_result1 = wasmer_table_grow(&table, 5);
// assert(grow_result1 == WASMER_TABLE_OK);
// wasmer_result_t grow_result1 = wasmer_table_grow(&table, 5);
// assert(grow_result1 == WASMER_OK);
// uint32_t len_grow1 = wasmer_table_length(table);
// printf("Table length: %d\n", len_grow1);
// assert(len_grow1 == 15);
// // Try to grow beyond max
// wasmer_table_result_t grow_result2 = wasmer_table_grow(&table, 1);
// assert(grow_result2 == WASMER_TABLE_ERROR);
// wasmer_result_t grow_result2 = wasmer_table_grow(&table, 1);
// assert(grow_result2 == WASMER_ERROR);
// uint32_t len_grow2 = wasmer_table_length(table);
// printf("Table length: %d\n", len_grow2);
// assert(len_grow2 == 15);
@ -34,9 +34,9 @@ int main()
// wasmer_limits_t bad_descriptor;
// bad_descriptor.min = 15;
// 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);
// assert(table_result == WASMER_TABLE_ERROR);
// assert(table_result == WASMER_ERROR);
printf("Destroy table\n");
wasmer_table_destroy(table);

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

@ -7,24 +7,9 @@
#include <stdlib.h>
typedef enum {
WASMER_CALL_OK = 1,
WASMER_CALL_ERROR = 2,
} wasmer_call_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;
WASMER_OK = 1,
WASMER_ERROR = 2,
} wasmer_result_t;
enum wasmer_value_tag {
WASM_I32,
@ -97,22 +82,22 @@ void wasmer_imports_set_import_func(wasmer_import_object_t *import_object,
const wasmer_value_tag *returns,
int returns_len);
wasmer_call_result_t wasmer_instance_call(wasmer_instance_t *instance,
const char *name,
const wasmer_value_t *params,
int params_len,
wasmer_value_t *results,
int results_len);
wasmer_result_t wasmer_instance_call(wasmer_instance_t *instance,
const char *name,
const wasmer_value_t *params,
int params_len,
wasmer_value_t *results,
int results_len);
const wasmer_memory_t *wasmer_instance_context_memory(wasmer_instance_context_t *ctx,
uint32_t memory_idx);
void wasmer_instance_destroy(wasmer_instance_t *instance);
wasmer_compile_result_t wasmer_instantiate(wasmer_instance_t **instance,
uint8_t *wasm_bytes,
uint32_t wasm_bytes_len,
wasmer_import_object_t *import_object);
wasmer_result_t wasmer_instantiate(wasmer_instance_t **instance,
uint8_t *wasm_bytes,
uint32_t wasm_bytes_len,
wasmer_import_object_t *import_object);
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);
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);
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);
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);
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);

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

@ -5,24 +5,9 @@
#include <cstdint>
#include <cstdlib>
enum class wasmer_call_result_t {
WASMER_CALL_OK = 1,
WASMER_CALL_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_result_t {
WASMER_OK = 1,
WASMER_ERROR = 2,
};
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,
int returns_len);
wasmer_call_result_t wasmer_instance_call(wasmer_instance_t *instance,
const char *name,
const wasmer_value_t *params,
int params_len,
wasmer_value_t *results,
int results_len);
wasmer_result_t wasmer_instance_call(wasmer_instance_t *instance,
const char *name,
const wasmer_value_t *params,
int params_len,
wasmer_value_t *results,
int results_len);
const wasmer_memory_t *wasmer_instance_context_memory(wasmer_instance_context_t *ctx,
uint32_t memory_idx);
void wasmer_instance_destroy(wasmer_instance_t *instance);
wasmer_compile_result_t wasmer_instantiate(wasmer_instance_t **instance,
uint8_t *wasm_bytes,
uint32_t wasm_bytes_len,
wasmer_import_object_t *import_object);
wasmer_result_t wasmer_instantiate(wasmer_instance_t **instance,
uint8_t *wasm_bytes,
uint32_t wasm_bytes_len,
wasmer_import_object_t *import_object);
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);
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);
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);
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);
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);