// Define the `ARCH_X86_X64` constant.
// Compatibility with non-Clang compilers.
// Compatibility with non-Clang compilers.
// Define the `DEPRECATED` macro.
// WASMER_H_MACROS
;
typedef uint8_t Version;
/**
* List of export/import kinds.
*/
;
typedef uint32_t wasmer_import_export_kind;
/**
* The `wasmer_result_t` enum is a type that represents either a
* success, or a failure.
*/
typedef enum wasmer_result_t;
/**
* Represents all possibles WebAssembly value types.
*
* See `wasmer_value_t` to get a complete example.
*/
;
typedef uint32_t wasmer_value_tag;
typedef struct wasmer_module_t;
/**
* Opaque pointer to a `wasmer_runtime::Instance` value in Rust.
*
* A `wasmer_runtime::Instance` represents a WebAssembly instance. It
* is generally generated by the `wasmer_instantiate()` function, or by
* the `wasmer_module_instantiate()` function for the most common paths.
*/
typedef struct wasmer_instance_t;
typedef struct wasmer_byte_array;
/**
* Type used to construct an import_object_t with Emscripten imports.
*/
typedef struct wasmer_emscripten_globals_t;
typedef struct wasmer_import_object_t;
/**
* Opaque pointer to `NamedExportDescriptor`.
*/
typedef struct wasmer_export_descriptor_t;
/**
* Opaque pointer to `NamedExportDescriptors`.
*/
typedef struct wasmer_export_descriptors_t;
/**
* Opaque pointer to `wasmer_export_t`.
*/
typedef struct wasmer_export_func_t;
/**
* Represents a WebAssembly value.
*
* This is a [Rust union][rust-union], which is equivalent to the C
* union. See `wasmer_value_t` to get a complete example.
*
* [rust-union]: https://doc.rust-lang.org/reference/items/unions.html
*/
typedef union wasmer_value;
/**
* Represents a WebAssembly type and value pair,
* i.e. `wasmer_value_tag` and `wasmer_value`. Since the latter is an
* union, it's the safe way to read or write a WebAssembly value in
* C.
*
* Example:
*
* ```c
* // Create a WebAssembly value.
* wasmer_value_t wasm_value = {
* .tag = WASM_I32,
* .value.I32 = 42,
* };
*
* // Read a WebAssembly value.
* if (wasm_value.tag == WASM_I32) {
* int32_t x = wasm_value.value.I32;
* // …
* }
* ```
*/
typedef struct wasmer_value_t;
/**
* Opaque pointer to `NamedExport`.
*/
typedef struct wasmer_export_t;
/**
* Opaque pointer to a `wasmer_runtime::Memory` value in Rust.
*
* A `wasmer_runtime::Memory` represents a WebAssembly memory. It is
* possible to create one with `wasmer_memory_new()` and pass it as
* imports of an instance, or to read it from exports of an instance
* with `wasmer_export_to_memory()`.
*/
typedef struct wasmer_memory_t;
/**
* Opaque pointer to the opaque structure `crate::NamedExports`,
* which is a wrapper around a vector of the opaque structure
* `crate::NamedExport`.
*
* Check the `wasmer_instance_exports()` function to learn more.
*/
typedef struct wasmer_exports_t;
typedef struct wasmer_global_t;
typedef struct wasmer_global_descriptor_t;
typedef struct wasmer_import_descriptor_t;
typedef struct wasmer_import_descriptors_t;
typedef struct wasmer_import_func_t;
typedef struct wasmer_table_t;
/**
* Union of import/export value.
*/
typedef union wasmer_import_export_value;
typedef struct wasmer_import_t;
typedef struct wasmer_import_object_iter_t;
/**
* Opaque pointer to a `wasmer_runtime::Ctx` value in Rust.
*
* An instance context is passed to any host function (aka imported
* function) as the first argument. It is necessary to read the
* instance data or the memory, respectively with the
* `wasmer_instance_context_data_get()` function, and the
* `wasmer_instance_context_memory()` function.
*
* It is also possible to get the instance context outside a host
* function by using the `wasmer_instance_context_get()`
* function. See also `wasmer_instance_context_data_set()` to set the
* instance context data.
*
* Example:
*
* ```c
* // A host function that prints data from the WebAssembly memory to
* // the standard output.
* void print(wasmer_instance_context_t *context, int32_t pointer, int32_t length) {
* // Use `wasmer_instance_context` to get back the first instance memory.
* const wasmer_memory_t *memory = wasmer_instance_context_memory(context, 0);
*
* // Continue…
* }
* ```
*/
typedef struct wasmer_instance_context_t;
/**
* The `wasmer_limit_option_t` struct represents an optional limit
* for `wasmer_limits_t`.
*/
typedef struct wasmer_limit_option_t;
/**
* The `wasmer_limits_t` struct is a type that describes a memory
* options. See the `wasmer_memory_t` struct or the
* `wasmer_memory_new()` function to get more information.
*/
typedef struct wasmer_limits_t;
typedef struct wasmer_serialized_module_t;
typedef struct wasmer_trampoline_buffer_builder_t;
typedef struct wasmer_trampoline_callable_t;
typedef struct wasmer_trampoline_buffer_t;
/**
* Opens a directory that's visible to the WASI module as `alias` but
* is backed by the host file at `host_file_path`
*/
typedef struct wasmer_wasi_map_dir_entry_t;
/**
* Creates a new Module from the given wasm bytes.
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Convenience function for setting up arguments and calling the Emscripten
* main function.
*
* WARNING:
*
* Do not call this function on untrusted code when operating without
* additional sandboxing in place.
* Emscripten has access to many host system calls and therefore may do very
* bad things.
*/
wasmer_result_t ;
/**
* Destroy `wasmer_emscrpten_globals_t` created by
* `wasmer_emscripten_get_emscripten_globals`.
*/
void ;
/**
* Create a `wasmer_import_object_t` with Emscripten imports, use
* `wasmer_emscripten_get_emscripten_globals` to get a
* `wasmer_emscripten_globals_t` from a `wasmer_module_t`.
*
* WARNING:
*
* This `import_object_t` contains thin-wrappers around host system calls.
* Do not use this to execute untrusted code without additional sandboxing.
*/
wasmer_import_object_t *;
/**
* Create a `wasmer_emscripten_globals_t` from a Wasm module.
*/
wasmer_emscripten_globals_t *;
/**
* Execute global constructors (required if the module is compiled from C++)
* and sets up the internal environment.
*
* This function sets the data pointer in the same way that
* [`wasmer_instance_context_data_set`] does.
*/
wasmer_result_t ;
/**
* Gets export descriptor kind
*/
wasmer_import_export_kind ;
/**
* Gets name for the export descriptor
*/
wasmer_byte_array ;
/**
* Gets export descriptors for the given module
*
* The caller owns the object and should call `wasmer_export_descriptors_destroy` to free it.
*/
void ;
/**
* Frees the memory for the given export descriptors
*/
void ;
/**
* Gets export descriptor by index
*/
wasmer_export_descriptor_t *;
/**
* Gets the length of the export descriptors
*/
int ;
/**
* Calls a `func` with the provided parameters.
* Results are set using the provided `results` pointer.
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Sets the params buffer to the parameter types of the given wasmer_export_func_t
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Sets the result parameter to the arity of the params of the wasmer_export_func_t
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Sets the returns buffer to the parameter types of the given wasmer_export_func_t
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Sets the result parameter to the arity of the returns of the wasmer_export_func_t
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Gets wasmer_export kind
*/
wasmer_import_export_kind ;
/**
* Gets name from wasmer_export
*/
wasmer_byte_array ;
/**
* Gets export func from export
*/
const wasmer_export_func_t *;
/**
* Gets a memory pointer from an export pointer.
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Frees the memory for the given exports.
*
* Check the `wasmer_instance_exports()` function to get a complete
* example.
*
* If `exports` is a null pointer, this function does nothing.
*
* Example:
*
* ```c
* // Get some exports.
* wasmer_exports_t *exports = NULL;
* wasmer_instance_exports(instance, &exports);
*
* // Destroy the exports.
* wasmer_exports_destroy(exports);
* ```
*/
void ;
/**
* Gets wasmer_export by index
*/
wasmer_export_t *;
/**
* Gets the length of the exports
*/
int ;
/**
* Frees memory for the given Global
*/
void ;
/**
* Gets the value stored by the given Global
*/
wasmer_value_t ;
/**
* Returns a descriptor (type, mutability) of the given Global
*/
wasmer_global_descriptor_t ;
/**
* Creates a new Global and returns a pointer to it.
* The caller owns the object and should call `wasmer_global_destroy` to free it.
*/
wasmer_global_t *;
/**
* Sets the value stored by the given Global
*/
void ;
/**
* Gets export descriptor kind
*/
wasmer_import_export_kind ;
/**
* Gets module name for the import descriptor
*/
wasmer_byte_array ;
/**
* Gets name for the import descriptor
*/
wasmer_byte_array ;
/**
* Gets import descriptors for the given module
*
* The caller owns the object and should call `wasmer_import_descriptors_destroy` to free it.
*/
void ;
/**
* Frees the memory for the given import descriptors
*/
void ;
/**
* Gets import descriptor by index
*/
wasmer_import_descriptor_t *;
/**
* Gets the length of the import descriptors
*/
unsigned int ;
/**
* Frees memory for the given Func
*/
void ;
/**
* Creates new host function, aka imported function. `func` is a
* function pointer, where the first argument is the famous `vm::Ctx`
* (in Rust), or `wasmer_instance_context_t` (in C). All arguments
* must be typed with compatible WebAssembly native types:
*
* | WebAssembly type | C/C++ type |
* | ---------------- | ---------- |
* | `i32` | `int32_t` |
* | `i64` | `int64_t` |
* | `f32` | `float` |
* | `f64` | `double` |
*
* The function pointer must have a lifetime greater than the
* WebAssembly instance lifetime.
*
* The caller owns the object and should call
* `wasmer_import_func_destroy` to free it.
*/
wasmer_import_func_t *;
/**
* Sets the params buffer to the parameter types of the given wasmer_import_func_t
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Sets the result parameter to the arity of the params of the wasmer_import_func_t
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Sets the returns buffer to the parameter types of the given wasmer_import_func_t
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Sets the result parameter to the arity of the returns of the wasmer_import_func_t
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Frees memory of the given ImportObject
*/
void ;
/**
* Extends an existing import object with new imports
*/
wasmer_result_t ;
/**
* Gets an entry from an ImportObject at the name and namespace.
* Stores `name`, `namespace`, and `import_export_value` in `import`.
* Thus these must remain valid for the lifetime of `import`.
*
* The caller owns all data involved.
* `import_export_value` will be written to based on `tag`.
*/
wasmer_result_t ;
/**
* Frees the memory allocated in `wasmer_import_object_iter_next`
*
* This function does not free the memory in `wasmer_import_object_t`;
* it only frees memory allocated while querying a `wasmer_import_object_t`.
*/
void ;
/**
* Returns true if further calls to `wasmer_import_object_iter_next` will
* not return any new data
*/
bool ;
/**
* Frees the memory allocated by `wasmer_import_object_iterate_functions`
*/
void ;
/**
* Writes the next value to `import`. `WASMER_ERROR` is returned if there
* was an error or there's nothing left to return.
*
* To free the memory allocated here, pass the import to `wasmer_import_object_imports_destroy`.
* To check if the iterator is done, use `wasmer_import_object_iter_at_end`.
*/
wasmer_result_t ;
/**
* Create an iterator over the functions in the import object.
* Get the next import with `wasmer_import_object_iter_next`
* Free the iterator with `wasmer_import_object_iter_destroy`
*/
wasmer_import_object_iter_t *;
/**
* Creates a new empty import object.
* See also `wasmer_import_object_append`
*/
wasmer_import_object_t *;
/**
* Calls an exported function of a WebAssembly instance by `name`
* with the provided parameters. The exported function results are
* stored on the provided `results` pointer.
*
* This function returns `wasmer_result_t::WASMER_OK` upon success,
* `wasmer_result_t::WASMER_ERROR` otherwise. You can use
* `wasmer_last_error_message()` to get the generated error message.
*
* Potential errors are the following:
*
* * `instance` is a null pointer,
* * `name` is a null pointer,
* * `params` is a null pointer.
*
* Example of calling an exported function that needs two parameters, and returns one value:
*
* ```c
* // First argument.
* wasmer_value_t argument_one = {
* .tag = WASM_I32,
* .value.I32 = 3,
* };
*
* // Second argument.
* wasmer_value_t argument_two = {
* .tag = WASM_I32,
* .value.I32 = 4,
* };
*
* // First result.
* wasmer_value_t result_one;
*
* // All arguments and results.
* wasmer_value_t arguments[] = {argument_one, argument_two};
* wasmer_value_t results[] = {result_one};
*
* wasmer_result_t call_result = wasmer_instance_call(
* instance, // instance pointer
* "sum", // the exported function name
* arguments, // the arguments
* 2, // the number of arguments
* results, // the results
* 1 // the number of results
* );
*
* if (call_result == WASMER_OK) {
* printf("Result is: %d\n", results[0].value.I32);
* }
* ```
*/
wasmer_result_t ;
/**
* Gets the data that can be hold by an instance.
*
* This function is complementary of
* `wasmer_instance_context_data_set()`. Please read its
* documentation. You can also read the documentation of
* `wasmer_instance_context_t` to get other examples.
*
* This function returns nothing if `ctx` is a null pointer.
*/
void *;
/**
* Sets the data that can be hold by an instance context.
*
* An instance context (represented by the opaque
* `wasmer_instance_context_t` structure) can hold user-defined
* data. This function sets the data. This function is complementary
* of `wasmer_instance_context_data_get()`.
*
* This function does nothing if `instance` is a null pointer.
*
* Example:
*
* ```c
* // Define your own data.
* typedef struct {
* // …
* } my_data;
*
* // Allocate them and set them on the given instance.
* my_data *data = malloc(sizeof(my_data));
* data->… = …;
* wasmer_instance_context_data_set(instance, (void*) my_data);
*
* // You can read your data.
* {
* my_data *data = (my_data*) wasmer_instance_context_data_get(wasmer_instance_context_get(instance));
* // …
* }
* ```
*/
void ;
/**
* Returns the instance context. Learn more by looking at the
* `wasmer_instance_context_t` struct.
*
* This function returns `null` if `instance` is a null pointer.
*
* Example:
*
* ```c
* const wasmer_instance_context_get *context = wasmer_instance_context_get(instance);
* my_data *data = (my_data *) wasmer_instance_context_data_get(context);
* // Do something with `my_data`.
* ```
*
* It is often useful with `wasmer_instance_context_data_set()`.
*/
const wasmer_instance_context_t *;
/**
* Gets the `memory_idx`th memory of the instance.
*
* Note that the index is always `0` until multiple memories are supported.
*
* This function is mostly used inside host functions (aka imported
* functions) to read the instance memory.
*
* Example of a _host function_ that reads and prints a string based on a pointer and a length:
*
* ```c
* void print_string(const wasmer_instance_context_t *context, int32_t pointer, int32_t length) {
* // Get the 0th memory.
* const wasmer_memory_t *memory = wasmer_instance_context_memory(context, 0);
*
* // Get the memory data as a pointer.
* uint8_t *memory_bytes = wasmer_memory_data(memory);
*
* // Print what we assumed to be a string!
* printf("%.*s", length, memory_bytes + pointer);
* }
* ```
*/
const wasmer_memory_t *;
/**
* Frees memory for the given `wasmer_instance_t`.
*
* Check the `wasmer_instantiate()` function to get a complete
* example.
*
* If `instance` is a null pointer, this function does nothing.
*
* Example:
*
* ```c
* // Get an instance.
* wasmer_instance_t *instance = NULL;
* wasmer_instantiate(&instance, bytes, bytes_length, imports, 0);
*
* // Destroy the instance.
* wasmer_instance_destroy(instance);
* ```
*/
void ;
/**
* Gets all the exports of the given WebAssembly instance.
*
* This function stores a Rust vector of exports into `exports` as an
* opaque pointer of kind `wasmer_exports_t`.
*
* As is, you can do anything with `exports` except using the
* companion functions, like `wasmer_exports_len()`,
* `wasmer_exports_get()` or `wasmer_export_kind()`. See the example below.
*
* **Warning**: The caller owns the object and should call
* `wasmer_exports_destroy()` to free it.
*
* Example:
*
* ```c
* // Get the exports.
* wasmer_exports_t *exports = NULL;
* wasmer_instance_exports(instance, &exports);
*
* // Get the number of exports.
* int exports_length = wasmer_exports_len(exports);
* printf("Number of exports: %d\n", exports_length);
*
* // Read the first export.
* wasmer_export_t *export = wasmer_exports_get(exports, 0);
*
* // Get the kind of the export.
* wasmer_import_export_kind export_kind = wasmer_export_kind(export);
*
* // Assert it is a function (why not).
* assert(export_kind == WASM_FUNCTION);
*
* // Read the export name.
* wasmer_byte_array name_bytes = wasmer_export_name(export);
*
* assert(name_bytes.bytes_len == sizeof("sum") - 1);
* assert(memcmp(name_bytes.bytes, "sum", sizeof("sum") - 1) == 0);
*
* // Destroy the exports.
* wasmer_exports_destroy(exports);
* ```
*/
void ;
/**
* Creates a new WebAssembly instance from the given bytes and imports.
*
* The result is stored in the first argument `instance` if
* successful, i.e. when the function returns
* `wasmer_result_t::WASMER_OK`. Otherwise
* `wasmer_result_t::WASMER_ERROR` is returned, and
* `wasmer_last_error_length()` with `wasmer_last_error_message()` must
* be used to read the error message.
*
* The caller is responsible to free the instance with
* `wasmer_instance_destroy()`.
*
* Example:
*
* ```c
* // 1. Read a WebAssembly module from a file.
* FILE *file = fopen("sum.wasm", "r");
* fseek(file, 0, SEEK_END);
* long bytes_length = ftell(file);
* uint8_t *bytes = malloc(bytes_length);
* fseek(file, 0, SEEK_SET);
* fread(bytes, 1, bytes_length, file);
* fclose(file);
*
* // 2. Declare the imports (here, none).
* wasmer_import_t imports[] = {};
*
* // 3. Instantiate the WebAssembly module.
* wasmer_instance_t *instance = NULL;
* wasmer_result_t result = wasmer_instantiate(&instance, bytes, bytes_length, imports, 0);
*
* // 4. Check for errors.
* if (result != WASMER_OK) {
* int error_length = wasmer_last_error_length();
* char *error = malloc(error_length);
* wasmer_last_error_message(error, error_length);
* // Do something with `error`…
* }
*
* // 5. Free the memory!
* wasmer_instance_destroy(instance);
* ```
*/
wasmer_result_t ;
/**
* Gets the length in bytes of the last error if any.
*
* This can be used to dynamically allocate a buffer with the correct number of
* bytes needed to store a message.
*
* See `wasmer_last_error_message()` to get a full example.
*/
int ;
/**
* Gets the last error message if any into the provided buffer
* `buffer` up to the given `length`.
*
* The `length` parameter must be large enough to store the last
* error message. Ideally, the value should come from
* `wasmer_last_error_length()`.
*
* The function returns the length of the string in bytes, `-1` if an
* error occurs. Potential errors are:
*
* * The buffer is a null pointer,
* * The buffer is too smal to hold the error message.
*
* Note: The error message always has a trailing null character.
*
* Example:
*
* ```c
* int error_length = wasmer_last_error_length();
*
* if (error_length > 0) {
* char *error_message = malloc(error_length);
* wasmer_last_error_message(error_message, error_length);
* printf("Error message: `%s`\n", error_message);
* } else {
* printf("No error message\n");
* }
* ```
*/
int ;
/**
* Gets a pointer to the beginning of the contiguous memory data
* bytes.
*
* The function returns `NULL` if `memory` is a null pointer.
*
* Note that when the memory grows, it can be reallocated, and thus
* the returned pointer can be invalidated.
*
* Example:
*
* ```c
* uint8_t *memory_data = wasmer_memory_data(memory);
* char *str = (char*) malloc(sizeof(char) * 7);
*
* for (uint32_t nth = 0; nth < 7; ++nth) {
* str[nth] = (char) memory_data[nth];
* }
* ```
*/
uint8_t *;
/**
* Gets the size in bytes of the memory data.
*
* This function returns 0 if `memory` is a null pointer.
*
* Example:
*
* ```c
* uint32_t memory_data_length = wasmer_memory_data_length(memory);
* ```
*/
uint32_t ;
/**
* Frees memory for the given `wasmer_memory_t`.
*
* Check the `wasmer_memory_new()` function to get a complete
* example.
*
* If `memory` is a null pointer, this function does nothing.
*
* Example:
*
* ```c
* // Get a memory.
* wasmer_memory_t *memory = NULL;
* wasmer_result_t result = wasmer_memory_new(&memory, memory_descriptor);
*
* // Destroy the memory.
* wasmer_memory_destroy(memory);
* ```
*/
void ;
/**
* Grows a memory by the given number of pages (of 65Kb each).
*
* The functions return `wasmer_result_t::WASMER_OK` upon success,
* `wasmer_result_t::WASMER_ERROR` otherwise. Use
* `wasmer_last_error_length()` with `wasmer_last_error_message()` to
* read the error message.
*
* Example:
*
* ```c
* wasmer_result_t result = wasmer_memory_grow(memory, 10);
*
* if (result != WASMER_OK) {
* // …
* }
* ```
*/
wasmer_result_t ;
/**
* Reads the current length (in pages) of the given memory.
*
* The function returns zero if `memory` is a null pointer.
*
* Example:
*
* ```c
* uint32_t memory_length = wasmer_memory_length(memory);
*
* printf("Memory pages length: %d\n", memory_length);
* ```
*/
uint32_t ;
/**
* Creates a new empty WebAssembly memory for the given descriptor.
*
* The result is stored in the first argument `memory` if successful,
* i.e. when the function returns
* `wasmer_result_t::WASMER_OK`. Otherwise,
* `wasmer_result_t::WASMER_ERROR` is returned, and
* `wasmer_last_error_length()` with `wasmer_last_error_message()`
* must be used to read the error message.
*
* The caller owns the memory and is responsible to free it with
* `wasmer_memory_destroy()`.
*
* Example:
*
* ```c
* // 1. The memory object.
* wasmer_memory_t *memory = NULL;
*
* // 2. The memory descriptor.
* wasmer_limits_t memory_descriptor = {
* .min = 10,
* .max = {
* .has_some = true,
* .some = 15,
* },
* };
*
* // 3. Initialize the memory.
* wasmer_result_t result = wasmer_memory_new(&memory, memory_descriptor);
*
* if (result != WASMER_OK) {
* int error_length = wasmer_last_error_length();
* char *error = malloc(error_length);
* wasmer_last_error_message(error, error_length);
* // Do something with `error`…
* }
*
* // 4. Free the memory!
* wasmer_memory_destroy(memory);
* ```
*/
wasmer_result_t ;
/**
* Deserialize the given serialized module.
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Frees memory for the given Module
*/
void ;
/**
* Given:
* * A prepared `wasmer` import-object
* * A compiled wasmer module
*
* Instantiates a wasmer instance
*/
wasmer_result_t ;
/**
* Creates a new Instance from the given module and imports.
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Serialize the given Module.
*
* The caller owns the object and should call `wasmer_serialized_module_destroy` to free it.
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Get bytes of the serialized module.
*/
wasmer_byte_array ;
/**
* Frees memory for the given serialized Module.
*/
void ;
/**
* Transform a sequence of bytes into a serialized module.
*
* The caller owns the object and should call `wasmer_serialized_module_destroy` to free it.
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Frees memory for the given Table
*/
void ;
/**
* Grows a Table by the given number of elements.
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Returns the current length of the given Table
*/
uint32_t ;
/**
* Creates a new Table for the given descriptor and initializes the given
* pointer to pointer to a pointer to the new Table.
*
* The caller owns the object and should call `wasmer_table_destroy` to free it.
*
* Returns `wasmer_result_t::WASMER_OK` upon success.
*
* Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
* and `wasmer_last_error_message` to get an error message.
*/
wasmer_result_t ;
/**
* Adds a callinfo trampoline to the builder.
*/
uintptr_t ;
/**
* Adds a context trampoline to the builder.
*/
uintptr_t ;
/**
* Finalizes the trampoline builder into an executable buffer.
*/
wasmer_trampoline_buffer_t *;
/**
* Creates a new trampoline builder.
*/
wasmer_trampoline_buffer_builder_t *;
/**
* Destroys the trampoline buffer if not null.
*/
void ;
/**
* Returns the callable pointer for the trampoline with index `idx`.
*/
const wasmer_trampoline_callable_t *;
/**
* Returns the context added by `add_context_trampoline`, from within the callee function.
*/
void *;
/**
* Stop the execution of a host function, aka imported function. The
* function must be used _only_ inside a host function.
*
* The pointer to `wasmer_instance_context_t` is received by the host
* function as its first argument. Just passing it to `ctx` is fine.
*
* The error message must have a greater lifetime than the host
* function itself since the error is read outside the host function
* with `wasmer_last_error_message`.
*
* This function returns `wasmer_result_t::WASMER_ERROR` if `ctx` or
* `error_message` are null.
*
* This function never returns otherwise.
*/
wasmer_result_t ;
/**
* Validates a sequence of bytes hoping it represents a valid WebAssembly module.
*
* The function returns true if the bytes are valid, false otherwise.
*
* Example:
*
* ```c
* bool result = wasmer_validate(bytes, bytes_length);
*
* if (false == result) {
* // Do something…
* }
* ```
*/
bool ;
/**
* Convenience function that creates a WASI import object with no arguments,
* environment variables, preopened files, or mapped directories.
*
* This function is the same as calling [`wasmer_wasi_generate_import_object`] with all
* empty values.
*/
wasmer_import_object_t *;
/**
* Creates a WASI import object.
*
* This function treats null pointers as empty collections.
* For example, passing null for a string in `args`, will lead to a zero
* length argument in that position.
*/
wasmer_import_object_t *;
/**
* Creates a WASI import object for a specific version.
*
* This function is similar to `wasmer_wasi_generate_import_object`
* except that the first argument describes the WASI version.
*
* The version is expected to be of kind `Version`.
*/
wasmer_import_object_t *;
/**
* Find the version of WASI used by the module.
*
* In case of error, the returned version is `Version::Unknown`.
*/
Version ;
/* WASMER_H */