2019-02-10 00:07:05 +00:00
|
|
|
#ifndef WASMER_H
|
|
|
|
#define WASMER_H
|
|
|
|
|
2019-02-05 01:54:12 +00:00
|
|
|
#include <cstdarg>
|
|
|
|
#include <cstdint>
|
|
|
|
#include <cstdlib>
|
|
|
|
|
2019-02-14 02:02:11 +00:00
|
|
|
enum class wasmer_import_export_kind : uint32_t {
|
|
|
|
WASM_FUNCTION,
|
|
|
|
WASM_GLOBAL,
|
|
|
|
WASM_MEMORY,
|
|
|
|
WASM_TABLE,
|
|
|
|
};
|
|
|
|
|
2019-02-12 01:07:28 +00:00
|
|
|
enum class wasmer_result_t {
|
|
|
|
WASMER_OK = 1,
|
|
|
|
WASMER_ERROR = 2,
|
2019-02-09 19:37:07 +00:00
|
|
|
};
|
|
|
|
|
2019-02-05 01:54:12 +00:00
|
|
|
enum class wasmer_value_tag : uint32_t {
|
|
|
|
WASM_I32,
|
|
|
|
WASM_I64,
|
|
|
|
WASM_F32,
|
|
|
|
WASM_F64,
|
|
|
|
};
|
|
|
|
|
2019-03-04 15:54:47 +00:00
|
|
|
struct wasmer_module_t {
|
2019-02-05 01:54:12 +00:00
|
|
|
|
2019-03-04 15:54:47 +00:00
|
|
|
};
|
2019-02-16 01:47:00 +00:00
|
|
|
|
2019-02-23 21:41:38 +00:00
|
|
|
struct wasmer_export_descriptor_t {
|
2019-02-14 02:02:11 +00:00
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-02-14 06:00:39 +00:00
|
|
|
struct wasmer_byte_array {
|
|
|
|
const uint8_t *bytes;
|
|
|
|
uint32_t bytes_len;
|
|
|
|
};
|
|
|
|
|
2019-02-23 21:41:38 +00:00
|
|
|
struct wasmer_export_descriptors_t {
|
2019-02-14 02:02:11 +00:00
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-02-24 18:22:24 +00:00
|
|
|
struct wasmer_export_func_t {
|
2019-02-09 23:39:15 +00:00
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-02-05 01:54:12 +00:00
|
|
|
union wasmer_value {
|
|
|
|
int32_t I32;
|
|
|
|
int64_t I64;
|
|
|
|
float F32;
|
|
|
|
double F64;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wasmer_value_t {
|
|
|
|
wasmer_value_tag tag;
|
|
|
|
wasmer_value value;
|
|
|
|
};
|
|
|
|
|
2019-02-24 18:22:24 +00:00
|
|
|
struct wasmer_export_t {
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wasmer_exports_t {
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-02-14 06:00:39 +00:00
|
|
|
struct wasmer_global_t {
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-02-09 23:39:15 +00:00
|
|
|
struct wasmer_global_descriptor_t {
|
|
|
|
bool mutable_;
|
|
|
|
wasmer_value_tag kind;
|
|
|
|
};
|
|
|
|
|
2019-02-24 00:25:51 +00:00
|
|
|
struct wasmer_import_descriptor_t {
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wasmer_import_descriptors_t {
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-02-24 18:22:24 +00:00
|
|
|
struct wasmer_import_func_t {
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-03-04 15:54:47 +00:00
|
|
|
struct wasmer_instance_t {
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-02-05 03:46:47 +00:00
|
|
|
struct wasmer_memory_t {
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-03-04 15:54:47 +00:00
|
|
|
struct wasmer_instance_context_t {
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2019-02-15 15:40:28 +00:00
|
|
|
struct wasmer_table_t {
|
|
|
|
|
2019-02-05 03:46:47 +00:00
|
|
|
};
|
|
|
|
|
2019-02-15 15:40:28 +00:00
|
|
|
union wasmer_import_export_value {
|
2019-02-24 18:22:24 +00:00
|
|
|
const wasmer_import_func_t *func;
|
2019-02-15 15:40:28 +00:00
|
|
|
const wasmer_table_t *table;
|
|
|
|
const wasmer_memory_t *memory;
|
|
|
|
const wasmer_global_t *global;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wasmer_import_t {
|
|
|
|
wasmer_byte_array module_name;
|
|
|
|
wasmer_byte_array import_name;
|
|
|
|
wasmer_import_export_kind tag;
|
|
|
|
wasmer_import_export_value value;
|
|
|
|
};
|
2019-02-09 19:37:07 +00:00
|
|
|
|
2019-02-19 06:05:08 +00:00
|
|
|
struct wasmer_limit_option_t {
|
|
|
|
bool has_some;
|
|
|
|
uint32_t some;
|
|
|
|
};
|
|
|
|
|
2019-02-15 15:40:28 +00:00
|
|
|
struct wasmer_limits_t {
|
|
|
|
uint32_t min;
|
2019-02-19 06:05:08 +00:00
|
|
|
wasmer_limit_option_t max;
|
2019-02-09 19:37:07 +00:00
|
|
|
};
|
|
|
|
|
2019-02-05 01:54:12 +00:00
|
|
|
extern "C" {
|
|
|
|
|
2019-02-16 01:47:00 +00:00
|
|
|
/// 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 wasmer_compile(wasmer_module_t **module,
|
|
|
|
uint8_t *wasm_bytes,
|
|
|
|
uint32_t wasm_bytes_len);
|
|
|
|
|
2019-02-23 21:41:38 +00:00
|
|
|
/// Gets export descriptor kind
|
|
|
|
wasmer_import_export_kind wasmer_export_descriptor_kind(wasmer_export_descriptor_t *export_);
|
2019-02-14 02:02:11 +00:00
|
|
|
|
2019-02-23 21:41:38 +00:00
|
|
|
/// Gets name for the export descriptor
|
|
|
|
wasmer_byte_array wasmer_export_descriptor_name(wasmer_export_descriptor_t *export_descriptor);
|
2019-02-14 06:00:39 +00:00
|
|
|
|
2019-02-23 21:41:38 +00:00
|
|
|
/// Gets export descriptors for the given module
|
|
|
|
/// The caller owns the object and should call `wasmer_export_descriptors_destroy` to free it.
|
2019-03-04 15:54:47 +00:00
|
|
|
void wasmer_export_descriptors(const wasmer_module_t *module,
|
2019-02-23 21:41:38 +00:00
|
|
|
wasmer_export_descriptors_t **export_descriptors);
|
2019-02-14 06:00:39 +00:00
|
|
|
|
2019-02-23 21:41:38 +00:00
|
|
|
/// Frees the memory for the given export descriptors
|
|
|
|
void wasmer_export_descriptors_destroy(wasmer_export_descriptors_t *export_descriptors);
|
2019-02-14 02:02:11 +00:00
|
|
|
|
2019-02-23 21:41:38 +00:00
|
|
|
/// Gets export descriptor by index
|
|
|
|
wasmer_export_descriptor_t *wasmer_export_descriptors_get(wasmer_export_descriptors_t *export_descriptors,
|
|
|
|
int idx);
|
2019-02-14 02:02:11 +00:00
|
|
|
|
2019-02-23 21:41:38 +00:00
|
|
|
/// Gets the length of the export descriptors
|
|
|
|
int wasmer_export_descriptors_len(wasmer_export_descriptors_t *exports);
|
2019-02-14 02:02:11 +00:00
|
|
|
|
2019-02-14 06:00:39 +00:00
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_export_func_call(const wasmer_export_func_t *func,
|
2019-02-24 18:22:24 +00:00
|
|
|
const wasmer_value_t *params,
|
|
|
|
int params_len,
|
|
|
|
wasmer_value_t *results,
|
|
|
|
int results_len);
|
2019-02-14 06:00:39 +00:00
|
|
|
|
2019-02-24 18:22:24 +00:00
|
|
|
/// Sets the params buffer to the parameter types of the given wasmer_export_func_t
|
2019-02-17 20:12:05 +00:00
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_export_func_params(const wasmer_export_func_t *func,
|
2019-02-24 18:22:24 +00:00
|
|
|
wasmer_value_tag *params,
|
|
|
|
int params_len);
|
2019-02-17 20:12:05 +00:00
|
|
|
|
2019-02-24 18:22:24 +00:00
|
|
|
/// Sets the result parameter to the arity of the params of the wasmer_export_func_t
|
2019-02-17 20:12:05 +00:00
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_export_func_params_arity(const wasmer_export_func_t *func, uint32_t *result);
|
2019-02-17 20:12:05 +00:00
|
|
|
|
2019-02-24 18:22:24 +00:00
|
|
|
/// Sets the returns buffer to the parameter types of the given wasmer_export_func_t
|
2019-02-17 20:12:05 +00:00
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_export_func_returns(const wasmer_export_func_t *func,
|
2019-02-24 18:22:24 +00:00
|
|
|
wasmer_value_tag *returns,
|
|
|
|
int returns_len);
|
2019-02-17 20:12:05 +00:00
|
|
|
|
2019-02-24 18:22:24 +00:00
|
|
|
/// Sets the result parameter to the arity of the returns of the wasmer_export_func_t
|
2019-02-17 20:12:05 +00:00
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_export_func_returns_arity(const wasmer_export_func_t *func,
|
|
|
|
uint32_t *result);
|
2019-02-24 18:22:24 +00:00
|
|
|
|
|
|
|
/// Gets wasmer_export kind
|
|
|
|
wasmer_import_export_kind wasmer_export_kind(wasmer_export_t *export_);
|
|
|
|
|
|
|
|
/// Gets name from wasmer_export
|
|
|
|
wasmer_byte_array wasmer_export_name(wasmer_export_t *export_);
|
|
|
|
|
|
|
|
/// Gets export func from export
|
2019-03-04 15:54:47 +00:00
|
|
|
const wasmer_export_func_t *wasmer_export_to_func(const wasmer_export_t *export_);
|
2019-02-24 18:22:24 +00:00
|
|
|
|
|
|
|
/// Frees the memory for the given exports
|
|
|
|
void wasmer_exports_destroy(wasmer_exports_t *exports);
|
|
|
|
|
|
|
|
/// Gets wasmer_export by index
|
|
|
|
wasmer_export_t *wasmer_exports_get(wasmer_exports_t *exports, int idx);
|
|
|
|
|
|
|
|
/// Gets the length of the exports
|
|
|
|
int wasmer_exports_len(wasmer_exports_t *exports);
|
2019-02-17 20:12:05 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Frees memory for the given Global
|
2019-02-09 23:39:15 +00:00
|
|
|
void wasmer_global_destroy(wasmer_global_t *global);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Gets the value stored by the given Global
|
2019-02-09 23:39:15 +00:00
|
|
|
wasmer_value_t wasmer_global_get(wasmer_global_t *global);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Returns a descriptor (type, mutability) of the given Global
|
2019-02-09 23:39:15 +00:00
|
|
|
wasmer_global_descriptor_t wasmer_global_get_descriptor(wasmer_global_t *global);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Creates a new Global and returns a pointer to it.
|
|
|
|
/// The caller owns the object and should call `wasmer_global_destroy` to free it.
|
2019-02-09 23:39:15 +00:00
|
|
|
wasmer_global_t *wasmer_global_new(wasmer_value_t value, bool mutable_);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Sets the value stored by the given Global
|
2019-02-09 23:39:15 +00:00
|
|
|
void wasmer_global_set(wasmer_global_t *global, wasmer_value_t value);
|
|
|
|
|
2019-02-24 00:25:51 +00:00
|
|
|
/// Gets export descriptor kind
|
|
|
|
wasmer_import_export_kind wasmer_import_descriptor_kind(wasmer_import_descriptor_t *export_);
|
|
|
|
|
|
|
|
/// Gets module name for the import descriptor
|
|
|
|
wasmer_byte_array wasmer_import_descriptor_module_name(wasmer_import_descriptor_t *import_descriptor);
|
|
|
|
|
|
|
|
/// Gets name for the import descriptor
|
|
|
|
wasmer_byte_array wasmer_import_descriptor_name(wasmer_import_descriptor_t *import_descriptor);
|
|
|
|
|
|
|
|
/// Gets import descriptors for the given module
|
|
|
|
/// The caller owns the object and should call `wasmer_import_descriptors_destroy` to free it.
|
2019-03-04 15:54:47 +00:00
|
|
|
void wasmer_import_descriptors(const wasmer_module_t *module,
|
2019-02-24 00:25:51 +00:00
|
|
|
wasmer_import_descriptors_t **import_descriptors);
|
|
|
|
|
|
|
|
/// Frees the memory for the given import descriptors
|
|
|
|
void wasmer_import_descriptors_destroy(wasmer_import_descriptors_t *import_descriptors);
|
|
|
|
|
|
|
|
/// Gets import descriptor by index
|
|
|
|
wasmer_import_descriptor_t *wasmer_import_descriptors_get(wasmer_import_descriptors_t *import_descriptors,
|
|
|
|
int idx);
|
|
|
|
|
|
|
|
/// Gets the length of the import descriptors
|
|
|
|
int wasmer_import_descriptors_len(wasmer_import_descriptors_t *exports);
|
|
|
|
|
2019-02-24 18:22:24 +00:00
|
|
|
/// Frees memory for the given Func
|
2019-03-06 11:21:50 +00:00
|
|
|
void wasmer_import_func_destroy(const wasmer_import_func_t *func);
|
2019-02-24 18:22:24 +00:00
|
|
|
|
|
|
|
/// Creates new func
|
|
|
|
/// The caller owns the object and should call `wasmer_import_func_destroy` to free it.
|
|
|
|
const wasmer_import_func_t *wasmer_import_func_new(void (*func)(void *data),
|
|
|
|
const wasmer_value_tag *params,
|
|
|
|
int params_len,
|
|
|
|
const wasmer_value_tag *returns,
|
|
|
|
int returns_len);
|
|
|
|
|
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_import_func_params(const wasmer_import_func_t *func,
|
2019-02-24 18:22:24 +00:00
|
|
|
wasmer_value_tag *params,
|
|
|
|
int params_len);
|
|
|
|
|
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_import_func_params_arity(const wasmer_import_func_t *func, uint32_t *result);
|
2019-02-24 18:22:24 +00:00
|
|
|
|
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_import_func_returns(const wasmer_import_func_t *func,
|
2019-02-24 18:22:24 +00:00
|
|
|
wasmer_value_tag *returns,
|
|
|
|
int returns_len);
|
|
|
|
|
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_import_func_returns_arity(const wasmer_import_func_t *func,
|
|
|
|
uint32_t *result);
|
2019-02-24 18:22:24 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Calls an instances exported function by `name` 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.
|
2019-02-12 01:07:28 +00:00
|
|
|
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);
|
2019-02-05 01:54:12 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Gets the memory within the context at the index `memory_idx`.
|
|
|
|
/// The index is always 0 until multiple memories are supported.
|
2019-03-06 11:21:50 +00:00
|
|
|
const wasmer_memory_t *wasmer_instance_context_memory(const wasmer_instance_context_t *ctx,
|
2019-03-04 15:54:47 +00:00
|
|
|
uint32_t _memory_idx);
|
2019-02-05 01:54:12 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Frees memory for the given Instance
|
2019-02-05 01:54:12 +00:00
|
|
|
void wasmer_instance_destroy(wasmer_instance_t *instance);
|
|
|
|
|
2019-02-14 02:02:11 +00:00
|
|
|
/// Gets Exports for the given instance
|
|
|
|
/// The caller owns the object and should call `wasmer_exports_destroy` to free it.
|
|
|
|
void wasmer_instance_exports(wasmer_instance_t *instance, wasmer_exports_t **exports);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Creates a new Instance from the given wasm bytes 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.
|
2019-02-12 01:07:28 +00:00
|
|
|
wasmer_result_t wasmer_instantiate(wasmer_instance_t **instance,
|
|
|
|
uint8_t *wasm_bytes,
|
|
|
|
uint32_t wasm_bytes_len,
|
2019-02-15 15:40:28 +00:00
|
|
|
wasmer_import_t *imports,
|
|
|
|
int imports_len);
|
2019-02-05 01:54:12 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Gets the length in bytes of the last error.
|
|
|
|
/// This can be used to dynamically allocate a buffer with the correct number of
|
|
|
|
/// bytes needed to store a message.
|
|
|
|
/// # Example
|
2019-03-06 11:02:20 +00:00
|
|
|
/// ```c
|
2019-02-12 05:14:32 +00:00
|
|
|
/// int error_len = wasmer_last_error_length();
|
|
|
|
/// char *error_str = malloc(error_len);
|
|
|
|
/// ```
|
2019-02-10 23:57:23 +00:00
|
|
|
int wasmer_last_error_length();
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Stores the last error message into the provided buffer up to the given `length`.
|
|
|
|
/// The `length` parameter must be large enough to store the last error message.
|
|
|
|
/// Returns the length of the string in bytes.
|
|
|
|
/// Returns `-1` if an error occurs.
|
|
|
|
/// # Example
|
2019-03-06 11:02:20 +00:00
|
|
|
/// ```c
|
2019-02-12 05:14:32 +00:00
|
|
|
/// int error_len = wasmer_last_error_length();
|
|
|
|
/// char *error_str = malloc(error_len);
|
|
|
|
/// wasmer_last_error_message(error_str, error_len);
|
|
|
|
/// printf("Error str: `%s`\n", error_str);
|
|
|
|
/// ```
|
2019-02-10 23:57:23 +00:00
|
|
|
int wasmer_last_error_message(char *buffer, int length);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Gets the start pointer to the bytes within a Memory
|
2019-03-06 11:21:50 +00:00
|
|
|
uint8_t *wasmer_memory_data(const wasmer_memory_t *mem);
|
2019-02-10 21:20:35 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Gets the size in bytes of a Memory
|
2019-02-10 20:14:42 +00:00
|
|
|
uint32_t wasmer_memory_data_length(wasmer_memory_t *mem);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Frees memory for the given Memory
|
2019-02-05 03:46:47 +00:00
|
|
|
void wasmer_memory_destroy(wasmer_memory_t *memory);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Grows a Memory by the given number of pages.
|
|
|
|
/// 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.
|
2019-02-12 01:07:28 +00:00
|
|
|
wasmer_result_t wasmer_memory_grow(wasmer_memory_t *memory, uint32_t delta);
|
2019-02-09 23:53:03 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Returns the current length in pages of the given memory
|
2019-03-06 11:21:50 +00:00
|
|
|
uint32_t wasmer_memory_length(const wasmer_memory_t *memory);
|
2019-02-05 03:46:47 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Creates a new Memory for the given descriptor and initializes the given
|
|
|
|
/// pointer to pointer to a pointer to the new memory.
|
|
|
|
/// The caller owns the object and should call `wasmer_memory_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.
|
2019-02-12 01:07:28 +00:00
|
|
|
wasmer_result_t wasmer_memory_new(wasmer_memory_t **memory, wasmer_limits_t limits);
|
2019-02-05 03:46:47 +00:00
|
|
|
|
2019-02-16 01:47:00 +00:00
|
|
|
/// Frees memory for the given Module
|
|
|
|
void wasmer_module_destroy(wasmer_module_t *module);
|
|
|
|
|
2019-02-21 05:08:23 +00:00
|
|
|
/// 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.
|
2019-03-04 15:54:47 +00:00
|
|
|
wasmer_result_t wasmer_module_instantiate(const wasmer_module_t *module,
|
2019-02-21 05:08:23 +00:00
|
|
|
wasmer_instance_t **instance,
|
|
|
|
wasmer_import_t *imports,
|
|
|
|
int imports_len);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Frees memory for the given Table
|
2019-02-09 19:37:07 +00:00
|
|
|
void wasmer_table_destroy(wasmer_table_t *table);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// 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.
|
2019-02-12 01:07:28 +00:00
|
|
|
wasmer_result_t wasmer_table_grow(wasmer_table_t *table, uint32_t delta);
|
2019-02-09 19:58:50 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Returns the current length of the given Table
|
2019-02-09 19:37:07 +00:00
|
|
|
uint32_t wasmer_table_length(wasmer_table_t *table);
|
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// 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.
|
2019-02-12 01:07:28 +00:00
|
|
|
wasmer_result_t wasmer_table_new(wasmer_table_t **table, wasmer_limits_t limits);
|
2019-02-09 19:37:07 +00:00
|
|
|
|
2019-02-12 05:14:32 +00:00
|
|
|
/// Returns true for valid wasm bytes and false for invalid bytes
|
2019-02-05 06:01:01 +00:00
|
|
|
bool wasmer_validate(uint8_t *wasm_bytes, uint32_t wasm_bytes_len);
|
|
|
|
|
2019-02-05 01:54:12 +00:00
|
|
|
} // extern "C"
|
2019-02-10 00:07:05 +00:00
|
|
|
|
|
|
|
#endif // WASMER_H
|