diff --git a/lib/runtime-c-api/src/lib.rs b/lib/runtime-c-api/src/lib.rs index d1ccf69e4..97267866d 100644 --- a/lib/runtime-c-api/src/lib.rs +++ b/lib/runtime-c-api/src/lib.rs @@ -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 } } } diff --git a/lib/runtime-c-api/tests/test-import-function.c b/lib/runtime-c-api/tests/test-import-function.c index 13ce81cab..f0ca17504 100644 --- a/lib/runtime-c-api/tests/test-import-function.c +++ b/lib/runtime-c-api/tests/test-import-function.c @@ -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); diff --git a/lib/runtime-c-api/tests/test-instantiate.c b/lib/runtime-c-api/tests/test-instantiate.c index 604f9544d..db24544f4 100644 --- a/lib/runtime-c-api/tests/test-instantiate.c +++ b/lib/runtime-c-api/tests/test-instantiate.c @@ -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); diff --git a/lib/runtime-c-api/tests/test-memory.c b/lib/runtime-c-api/tests/test-memory.c index d9379c78a..68ff27712 100644 --- a/lib/runtime-c-api/tests/test-memory.c +++ b/lib/runtime-c-api/tests/test-memory.c @@ -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); // diff --git a/lib/runtime-c-api/tests/test-tables.c b/lib/runtime-c-api/tests/test-tables.c index f50a5af5f..3f8c29805 100644 --- a/lib/runtime-c-api/tests/test-tables.c +++ b/lib/runtime-c-api/tests/test-tables.c @@ -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); diff --git a/lib/runtime-c-api/wasmer.h b/lib/runtime-c-api/wasmer.h index 3f4a34a94..1b53f3123 100644 --- a/lib/runtime-c-api/wasmer.h +++ b/lib/runtime-c-api/wasmer.h @@ -7,24 +7,9 @@ #include 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); diff --git a/lib/runtime-c-api/wasmer.hh b/lib/runtime-c-api/wasmer.hh index c7ddb5bdd..68b935202 100644 --- a/lib/runtime-c-api/wasmer.hh +++ b/lib/runtime-c-api/wasmer.hh @@ -5,24 +5,9 @@ #include #include -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);