use std::alloc::{alloc, Layout};
#[cfg(feature = "async")]
use std::sync::atomic::{AtomicI32, Ordering};
#[allow(non_snake_case)]
#[link(wasm_import_module = "simple")]
unsafe extern "C" {
unsafe fn __call(
name_ptr: i32,
name_len: i32,
params_ptr: i32,
params_len: i32,
context_ptr: i32,
context_len: i32,
);
unsafe fn __cast(
name_ptr: i32,
name_len: i32,
params_ptr: i32,
params_len: i32,
context_ptr: i32,
context_len: i32,
);
unsafe fn __getContext(ptr: i32);
unsafe fn __getContextSize() -> i32;
}
#[cfg(not(feature = "async"))]
#[allow(non_snake_case)]
#[link(wasm_import_module = "simple")]
unsafe extern "C" {
unsafe fn __getExecutionResult(ptr: i32);
unsafe fn __getExecutionResultSize() -> i32;
}
#[cfg(feature = "async")]
#[link(wasm_import_module = "env")]
unsafe extern "C" {
unsafe fn asyncify_get_state() -> i32;
unsafe fn asyncify_stop_rewind();
}
#[cfg(feature = "async")]
const REWINDING: i32 = 2;
#[cfg(feature = "async")]
static RESPONSE_PTR: AtomicI32 = AtomicI32::new(0);
#[cfg(feature = "async")]
static RESPONSE_LEN: AtomicI32 = AtomicI32::new(0);
#[no_mangle]
pub extern "C" fn allocate_buffer(size: usize) -> *mut u8 {
if size == 0 {
return std::ptr::null_mut();
}
match Layout::from_size_align(size, 1) {
Ok(layout) => unsafe { alloc(layout) },
Err(_unrepresentable) => std::ptr::null_mut(),
}
}
#[cfg(feature = "async")]
#[no_mangle]
pub extern "C" fn set_response_buffer(ptr: i32, len: i32) {
RESPONSE_PTR.store(ptr, Ordering::Relaxed);
RESPONSE_LEN.store(len, Ordering::Relaxed);
}
pub(crate) fn context() -> Option<String> {
let size = unsafe { __getContextSize() };
if size <= 0 {
return None;
}
let mut buffer = vec![0_u8; size as usize];
unsafe { __getContext(buffer.as_mut_ptr() as i32) };
String::from_utf8(buffer).ok()
}
pub(crate) fn call(name: &str, params: &str) -> Option<String> {
#[cfg(feature = "async")]
{
if unsafe { asyncify_get_state() } == REWINDING {
unsafe { asyncify_stop_rewind() };
} else {
request(name, params, true);
}
}
#[cfg(not(feature = "async"))]
request(name, params, true);
reply()
}
pub(crate) fn cast(name: &str, params: &str) {
request(name, params, false);
}
fn request(name: &str, params: &str, expects_reply: bool) {
let name_bytes = name.as_bytes();
let params_bytes = params.as_bytes();
unsafe {
if expects_reply {
__call(
name_bytes.as_ptr() as i32,
name_bytes.len() as i32,
params_bytes.as_ptr() as i32,
params_bytes.len() as i32,
0,
0,
);
} else {
__cast(
name_bytes.as_ptr() as i32,
name_bytes.len() as i32,
params_bytes.as_ptr() as i32,
params_bytes.len() as i32,
0,
0,
);
}
}
}
#[cfg(not(feature = "async"))]
fn reply() -> Option<String> {
let size = unsafe { __getExecutionResultSize() };
if size <= 0 {
return None;
}
let mut buffer = vec![0_u8; size as usize];
unsafe { __getExecutionResult(buffer.as_mut_ptr() as i32) };
String::from_utf8(buffer).ok()
}
#[cfg(not(feature = "async"))]
pub(crate) enum Bytes {
Appended(usize),
Refused(String),
}
#[cfg(not(feature = "async"))]
pub(crate) fn call_bytes(name: &str, params: &str, into: &mut Vec<u8>) -> Bytes {
request(name, params, true);
let size = unsafe { __getExecutionResultSize() };
if size < 0 {
let mut envelope = vec![0_u8; size.unsigned_abs() as usize];
unsafe { __getExecutionResult(envelope.as_mut_ptr() as i32) };
return Bytes::Refused(String::from_utf8_lossy(&envelope).into_owned());
}
let size = size as usize;
into.reserve(size);
unsafe {
__getExecutionResult(into.as_mut_ptr().add(into.len()) as i32);
into.set_len(into.len() + size);
}
Bytes::Appended(size)
}
#[cfg(feature = "async")]
fn reply() -> Option<String> {
let ptr = RESPONSE_PTR.swap(0, Ordering::Relaxed);
let len = RESPONSE_LEN.swap(0, Ordering::Relaxed);
if ptr == 0 || len <= 0 {
return None;
}
let bytes = unsafe { std::slice::from_raw_parts(ptr as *const u8, len as usize) };
String::from_utf8(bytes.to_vec()).ok()
}