Commit ed8e3905 authored by Kunshan Wang's avatar Kunshan Wang

API-GEN: WIP: generating forwarders...

api_bridge.rs will convert low-level C valus to high-level Rust value,
such as CMuValue* -> [&APIMuValue].
parent 15a48ed7
// Invoke "python3 muapi2rustapi.py", and then
// invoke "rustc --test __api_gen_tester_mod.rs -o /tmp/api_gen_tester_junk"
// to test whether the generated code compiles.
mod api_c;
mod api_bridge;
mod api_impl;
use std::os::raw::*;
use super::api_c::*;
// GEN:BEGIN:Fillers
// GEN:END:Fillers
// GEN:BEGIN:Forwarders
fn _forwarder__MuVM__new_context(mvm: *mut CMuVM)-> *mut CMuCtx {
let mut _arg_mvm = from_MuVM_ptr(mvm);
panic!("not implemented")
}
fn _forwarder__MuVM__id_of(mvm: *mut CMuVM, name: CMuName)-> CMuID {
let mut _arg_mvm = from_MuVM_ptr(mvm);
let mut _arg_name = from_MuName(name);
panic!("not implemented")
}
fn _forwarder__MuVM__name_of(mvm: *mut CMuVM, id: CMuID)-> CMuName {
let mut _arg_mvm = from_MuVM_ptr(mvm);
let mut _arg_id = from_MuID(id);
panic!("not implemented")
}
fn _forwarder__MuVM__set_trap_handler(mvm: *mut CMuVM, trap_handler: CMuTrapHandler, userdata: CMuCPtr) {
let mut _arg_mvm = from_MuVM_ptr(mvm);
let mut _arg_trap_handler = from_MuTrapHandler(trap_handler);
let mut _arg_userdata = from_MuCPtr(userdata);
panic!("not implemented")
}
fn _forwarder__MuCtx__id_of(ctx: *mut CMuCtx, name: CMuName)-> CMuID {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_name = from_MuName(name);
panic!("not implemented")
}
fn _forwarder__MuCtx__name_of(ctx: *mut CMuCtx, id: CMuID)-> CMuName {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_id = from_MuID(id);
panic!("not implemented")
}
fn _forwarder__MuCtx__close_context(ctx: *mut CMuCtx) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
panic!("not implemented")
}
fn _forwarder__MuCtx__load_bundle(ctx: *mut CMuCtx, buf: *mut c_char, sz: CMuArraySize) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_buf = from_char_array(buf, sz);
panic!("not implemented")
}
fn _forwarder__MuCtx__load_hail(ctx: *mut CMuCtx, buf: *mut c_char, sz: CMuArraySize) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_buf = from_char_array(buf, sz);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_sint8(ctx: *mut CMuCtx, num: i8, len: c_int)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_int8_t(num);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_uint8(ctx: *mut CMuCtx, num: u8, len: c_int)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_uint8_t(num);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_sint16(ctx: *mut CMuCtx, num: i16, len: c_int)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_int16_t(num);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_uint16(ctx: *mut CMuCtx, num: u16, len: c_int)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_uint16_t(num);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_sint32(ctx: *mut CMuCtx, num: i32, len: c_int)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_int32_t(num);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_uint32(ctx: *mut CMuCtx, num: u32, len: c_int)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_uint32_t(num);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_sint64(ctx: *mut CMuCtx, num: i64, len: c_int)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_int64_t(num);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_uint64(ctx: *mut CMuCtx, num: u64, len: c_int)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_uint64_t(num);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_uint64s(ctx: *mut CMuCtx, nums: *mut u64, nnums: CMuArraySize, len: c_int)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_nums = from_uint64_t_array(nums, nnums);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_float(ctx: *mut CMuCtx, num: f32)-> CMuFloatValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_float(num);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_double(ctx: *mut CMuCtx, num: f64)-> CMuDoubleValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_num = from_double(num);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_ptr(ctx: *mut CMuCtx, mu_type: CMuID, ptr: CMuCPtr)-> CMuUPtrValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_mu_type = from_MuID(mu_type);
let mut _arg_ptr = from_MuCPtr(ptr);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_fp(ctx: *mut CMuCtx, mu_type: CMuID, fp: CMuCFP)-> CMuUFPValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_mu_type = from_MuID(mu_type);
let mut _arg_fp = from_MuCFP(fp);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_sint8(ctx: *mut CMuCtx, opnd: CMuIntValue)-> i8 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIntValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_uint8(ctx: *mut CMuCtx, opnd: CMuIntValue)-> u8 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIntValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_sint16(ctx: *mut CMuCtx, opnd: CMuIntValue)-> i16 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIntValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_uint16(ctx: *mut CMuCtx, opnd: CMuIntValue)-> u16 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIntValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_sint32(ctx: *mut CMuCtx, opnd: CMuIntValue)-> i32 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIntValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_uint32(ctx: *mut CMuCtx, opnd: CMuIntValue)-> u32 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIntValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_sint64(ctx: *mut CMuCtx, opnd: CMuIntValue)-> i64 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIntValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_uint64(ctx: *mut CMuCtx, opnd: CMuIntValue)-> u64 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIntValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_float(ctx: *mut CMuCtx, opnd: CMuFloatValue)-> f32 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuFloatValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_double(ctx: *mut CMuCtx, opnd: CMuDoubleValue)-> f64 {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuDoubleValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_ptr(ctx: *mut CMuCtx, opnd: CMuUPtrValue)-> CMuCPtr {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuUPtrValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_to_fp(ctx: *mut CMuCtx, opnd: CMuUFPValue)-> CMuCFP {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuUFPValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_const(ctx: *mut CMuCtx, id: CMuID)-> CMuValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_id = from_MuID(id);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_global(ctx: *mut CMuCtx, id: CMuID)-> CMuIRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_id = from_MuID(id);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_func(ctx: *mut CMuCtx, id: CMuID)-> CMuFuncRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_id = from_MuID(id);
panic!("not implemented")
}
fn _forwarder__MuCtx__handle_from_expose(ctx: *mut CMuCtx, id: CMuID)-> CMuValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_id = from_MuID(id);
panic!("not implemented")
}
fn _forwarder__MuCtx__delete_value(ctx: *mut CMuCtx, opnd: CMuValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__ref_eq(ctx: *mut CMuCtx, lhs: CMuGenRefValue, rhs: CMuGenRefValue)-> CMuBool {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_lhs = from_MuGenRefValue(lhs);
let mut _arg_rhs = from_MuGenRefValue(rhs);
panic!("not implemented")
}
fn _forwarder__MuCtx__ref_ult(ctx: *mut CMuCtx, lhs: CMuIRefValue, rhs: CMuIRefValue)-> CMuBool {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_lhs = from_MuIRefValue(lhs);
let mut _arg_rhs = from_MuIRefValue(rhs);
panic!("not implemented")
}
fn _forwarder__MuCtx__extract_value(ctx: *mut CMuCtx, str: CMuStructValue, index: c_int)-> CMuValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_str = from_MuStructValue(str);
let mut _arg_index = from_int(index);
panic!("not implemented")
}
fn _forwarder__MuCtx__insert_value(ctx: *mut CMuCtx, str: CMuStructValue, index: c_int, newval: CMuValue)-> CMuStructValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_str = from_MuStructValue(str);
let mut _arg_index = from_int(index);
let mut _arg_newval = from_MuValue(newval);
panic!("not implemented")
}
fn _forwarder__MuCtx__extract_element(ctx: *mut CMuCtx, str: CMuSeqValue, index: CMuIntValue)-> CMuValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_str = from_MuSeqValue(str);
let mut _arg_index = from_MuIntValue(index);
panic!("not implemented")
}
fn _forwarder__MuCtx__insert_element(ctx: *mut CMuCtx, str: CMuSeqValue, index: CMuIntValue, newval: CMuValue)-> CMuSeqValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_str = from_MuSeqValue(str);
let mut _arg_index = from_MuIntValue(index);
let mut _arg_newval = from_MuValue(newval);
panic!("not implemented")
}
fn _forwarder__MuCtx__new_fixed(ctx: *mut CMuCtx, mu_type: CMuID)-> CMuRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_mu_type = from_MuID(mu_type);
panic!("not implemented")
}
fn _forwarder__MuCtx__new_hybrid(ctx: *mut CMuCtx, mu_type: CMuID, length: CMuIntValue)-> CMuRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_mu_type = from_MuID(mu_type);
let mut _arg_length = from_MuIntValue(length);
panic!("not implemented")
}
fn _forwarder__MuCtx__refcast(ctx: *mut CMuCtx, opnd: CMuGenRefValue, new_type: CMuID)-> CMuGenRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuGenRefValue(opnd);
let mut _arg_new_type = from_MuID(new_type);
panic!("not implemented")
}
fn _forwarder__MuCtx__get_iref(ctx: *mut CMuCtx, opnd: CMuRefValue)-> CMuIRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuRefValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__get_field_iref(ctx: *mut CMuCtx, opnd: CMuIRefValue, field: c_int)-> CMuIRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIRefValue(opnd);
let mut _arg_field = from_int(field);
panic!("not implemented")
}
fn _forwarder__MuCtx__get_elem_iref(ctx: *mut CMuCtx, opnd: CMuIRefValue, index: CMuIntValue)-> CMuIRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIRefValue(opnd);
let mut _arg_index = from_MuIntValue(index);
panic!("not implemented")
}
fn _forwarder__MuCtx__shift_iref(ctx: *mut CMuCtx, opnd: CMuIRefValue, offset: CMuIntValue)-> CMuIRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIRefValue(opnd);
let mut _arg_offset = from_MuIntValue(offset);
panic!("not implemented")
}
fn _forwarder__MuCtx__get_var_part_iref(ctx: *mut CMuCtx, opnd: CMuIRefValue)-> CMuIRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_opnd = from_MuIRefValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__load(ctx: *mut CMuCtx, ord: CMuMemOrd, loc: CMuIRefValue)-> CMuValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_ord = from_MuMemOrd(ord);
let mut _arg_loc = from_MuIRefValue(loc);
panic!("not implemented")
}
fn _forwarder__MuCtx__store(ctx: *mut CMuCtx, ord: CMuMemOrd, loc: CMuIRefValue, newval: CMuValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_ord = from_MuMemOrd(ord);
let mut _arg_loc = from_MuIRefValue(loc);
let mut _arg_newval = from_MuValue(newval);
panic!("not implemented")
}
fn _forwarder__MuCtx__cmpxchg(ctx: *mut CMuCtx, ord_succ: CMuMemOrd, ord_fail: CMuMemOrd, weak: CMuBool, loc: CMuIRefValue, expected: CMuValue, desired: CMuValue, is_succ: *mut CMuBool)-> CMuValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_ord_succ = from_MuMemOrd(ord_succ);
let mut _arg_ord_fail = from_MuMemOrd(ord_fail);
let mut _arg_weak = from_MuBool(weak);
let mut _arg_loc = from_MuIRefValue(loc);
let mut _arg_expected = from_MuValue(expected);
let mut _arg_desired = from_MuValue(desired);
let mut _arg_is_succ = from_MuBool_ptr(is_succ);
panic!("not implemented")
}
fn _forwarder__MuCtx__atomicrmw(ctx: *mut CMuCtx, ord: CMuMemOrd, op: CMuAtomicRMWOptr, loc: CMuIRefValue, opnd: CMuValue)-> CMuValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_ord = from_MuMemOrd(ord);
let mut _arg_op = from_MuAtomicRMWOptr(op);
let mut _arg_loc = from_MuIRefValue(loc);
let mut _arg_opnd = from_MuValue(opnd);
panic!("not implemented")
}
fn _forwarder__MuCtx__fence(ctx: *mut CMuCtx, ord: CMuMemOrd) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_ord = from_MuMemOrd(ord);
panic!("not implemented")
}
fn _forwarder__MuCtx__new_stack(ctx: *mut CMuCtx, func: CMuFuncRefValue)-> CMuStackRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_func = from_MuFuncRefValue(func);
panic!("not implemented")
}
fn _forwarder__MuCtx__new_thread_nor(ctx: *mut CMuCtx, stack: CMuStackRefValue, threadlocal: CMuRefValue, vals: *mut CMuValue, nvals: CMuArraySize)-> CMuThreadRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_stack = from_MuStackRefValue(stack);
let mut _arg_threadlocal = from_ptr_optional(threadlocal);
let mut _arg_vals = from_ptr_array(vals, nvals);
panic!("not implemented")
}
fn _forwarder__MuCtx__new_thread_exc(ctx: *mut CMuCtx, stack: CMuStackRefValue, threadlocal: CMuRefValue, exc: CMuRefValue)-> CMuThreadRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_stack = from_MuStackRefValue(stack);
let mut _arg_threadlocal = from_ptr_optional(threadlocal);
let mut _arg_exc = from_MuRefValue(exc);
panic!("not implemented")
}
fn _forwarder__MuCtx__kill_stack(ctx: *mut CMuCtx, stack: CMuStackRefValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_stack = from_MuStackRefValue(stack);
panic!("not implemented")
}
fn _forwarder__MuCtx__set_threadlocal(ctx: *mut CMuCtx, thread: CMuThreadRefValue, threadlocal: CMuRefValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_thread = from_MuThreadRefValue(thread);
let mut _arg_threadlocal = from_MuRefValue(threadlocal);
panic!("not implemented")
}
fn _forwarder__MuCtx__get_threadlocal(ctx: *mut CMuCtx, thread: CMuThreadRefValue)-> CMuRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_thread = from_MuThreadRefValue(thread);
panic!("not implemented")
}
fn _forwarder__MuCtx__new_cursor(ctx: *mut CMuCtx, stack: CMuStackRefValue)-> CMuFCRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_stack = from_MuStackRefValue(stack);
panic!("not implemented")
}
fn _forwarder__MuCtx__next_frame(ctx: *mut CMuCtx, cursor: CMuFCRefValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_cursor = from_MuFCRefValue(cursor);
panic!("not implemented")
}
fn _forwarder__MuCtx__copy_cursor(ctx: *mut CMuCtx, cursor: CMuFCRefValue)-> CMuFCRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_cursor = from_MuFCRefValue(cursor);
panic!("not implemented")
}
fn _forwarder__MuCtx__close_cursor(ctx: *mut CMuCtx, cursor: CMuFCRefValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_cursor = from_MuFCRefValue(cursor);
panic!("not implemented")
}
fn _forwarder__MuCtx__cur_func(ctx: *mut CMuCtx, cursor: CMuFCRefValue)-> CMuID {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_cursor = from_MuFCRefValue(cursor);
panic!("not implemented")
}
fn _forwarder__MuCtx__cur_func_ver(ctx: *mut CMuCtx, cursor: CMuFCRefValue)-> CMuID {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_cursor = from_MuFCRefValue(cursor);
panic!("not implemented")
}
fn _forwarder__MuCtx__cur_inst(ctx: *mut CMuCtx, cursor: CMuFCRefValue)-> CMuID {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_cursor = from_MuFCRefValue(cursor);
panic!("not implemented")
}
fn _forwarder__MuCtx__dump_keepalives(ctx: *mut CMuCtx, cursor: CMuFCRefValue, results: *mut CMuValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_cursor = from_MuFCRefValue(cursor);
let mut _arg_results = from_MuValue_ptr(results);
panic!("not implemented")
}
fn _forwarder__MuCtx__pop_frames_to(ctx: *mut CMuCtx, cursor: CMuFCRefValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_cursor = from_MuFCRefValue(cursor);
panic!("not implemented")
}
fn _forwarder__MuCtx__push_frame(ctx: *mut CMuCtx, stack: CMuStackRefValue, func: CMuFuncRefValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_stack = from_MuStackRefValue(stack);
let mut _arg_func = from_MuFuncRefValue(func);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_is_fp(ctx: *mut CMuCtx, value: CMuTagRef64Value)-> CMuBool {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_value = from_MuTagRef64Value(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_is_int(ctx: *mut CMuCtx, value: CMuTagRef64Value)-> CMuBool {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_value = from_MuTagRef64Value(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_is_ref(ctx: *mut CMuCtx, value: CMuTagRef64Value)-> CMuBool {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_value = from_MuTagRef64Value(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_to_fp(ctx: *mut CMuCtx, value: CMuTagRef64Value)-> CMuDoubleValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_value = from_MuTagRef64Value(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_to_int(ctx: *mut CMuCtx, value: CMuTagRef64Value)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_value = from_MuTagRef64Value(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_to_ref(ctx: *mut CMuCtx, value: CMuTagRef64Value)-> CMuRefValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_value = from_MuTagRef64Value(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_to_tag(ctx: *mut CMuCtx, value: CMuTagRef64Value)-> CMuIntValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_value = from_MuTagRef64Value(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_from_fp(ctx: *mut CMuCtx, value: CMuDoubleValue)-> CMuTagRef64Value {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_value = from_MuDoubleValue(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_from_int(ctx: *mut CMuCtx, value: CMuIntValue)-> CMuTagRef64Value {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_value = from_MuIntValue(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__tr64_from_ref(ctx: *mut CMuCtx, reff: CMuRefValue, tag: CMuIntValue)-> CMuTagRef64Value {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_reff = from_MuRefValue(reff);
let mut _arg_tag = from_MuIntValue(tag);
panic!("not implemented")
}
fn _forwarder__MuCtx__enable_watchpoint(ctx: *mut CMuCtx, wpid: CMuWPID) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_wpid = from_MuWPID(wpid);
panic!("not implemented")
}
fn _forwarder__MuCtx__disable_watchpoint(ctx: *mut CMuCtx, wpid: CMuWPID) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_wpid = from_MuWPID(wpid);
panic!("not implemented")
}
fn _forwarder__MuCtx__pin(ctx: *mut CMuCtx, loc: CMuValue)-> CMuUPtrValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_loc = from_MuValue(loc);
panic!("not implemented")
}
fn _forwarder__MuCtx__unpin(ctx: *mut CMuCtx, loc: CMuValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_loc = from_MuValue(loc);
panic!("not implemented")
}
fn _forwarder__MuCtx__get_addr(ctx: *mut CMuCtx, loc: CMuValue)-> CMuUPtrValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_loc = from_MuValue(loc);
panic!("not implemented")
}
fn _forwarder__MuCtx__expose(ctx: *mut CMuCtx, func: CMuFuncRefValue, call_conv: CMuCallConv, cookie: CMuIntValue)-> CMuValue {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_func = from_MuFuncRefValue(func);
let mut _arg_call_conv = from_MuCallConv(call_conv);
let mut _arg_cookie = from_MuIntValue(cookie);
panic!("not implemented")
}
fn _forwarder__MuCtx__unexpose(ctx: *mut CMuCtx, call_conv: CMuCallConv, value: CMuValue) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_call_conv = from_MuCallConv(call_conv);
let mut _arg_value = from_MuValue(value);
panic!("not implemented")
}
fn _forwarder__MuCtx__new_ir_builder(ctx: *mut CMuCtx)-> *mut CMuIRBuilder {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
panic!("not implemented")
}
fn _forwarder__MuCtx__make_boot_image(ctx: *mut CMuCtx, whitelist: *mut CMuID, whitelist_sz: CMuArraySize, primordial_func: CMuFuncRefValue, primordial_stack: CMuStackRefValue, primordial_threadlocal: CMuRefValue, sym_fields: *mut CMuIRefValue, sym_strings: *mut CMuCString, nsyms: CMuArraySize, reloc_fields: *mut CMuIRefValue, reloc_strings: *mut CMuCString, nrelocs: CMuArraySize, output_file: CMuCString) {
let mut _arg_ctx = from_MuCtx_ptr(ctx);
let mut _arg_whitelist = from_MuID_array(whitelist, whitelist_sz);
let mut _arg_primordial_func = from_ptr_optional(primordial_func);
let mut _arg_primordial_stack = from_ptr_optional(primordial_stack);
let mut _arg_primordial_threadlocal = from_ptr_optional(primordial_threadlocal);
let mut _arg_sym_fields = from_ptr_array(sym_fields, nsyms);
let mut _arg_sym_strings = from_MuCString_array(sym_strings, nsyms);
let mut _arg_reloc_fields = from_ptr_array(reloc_fields, nrelocs);
let mut _arg_reloc_strings = from_MuCString_array(reloc_strings, nrelocs);
let mut _arg_output_file = from_MuCString(output_file);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__load(b: *mut CMuIRBuilder) {
let mut _arg_b = from_MuIRBuilder_ptr(b);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__abort(b: *mut CMuIRBuilder) {
let mut _arg_b = from_MuIRBuilder_ptr(b);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__gen_sym(b: *mut CMuIRBuilder, name: CMuCString)-> CMuID {
let mut _arg_b = from_MuIRBuilder_ptr(b);
let mut _arg_name = from_MuCString_optional(name);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__new_type_int(b: *mut CMuIRBuilder, id: CMuID, len: c_int) {
let mut _arg_b = from_MuIRBuilder_ptr(b);
let mut _arg_id = from_MuID(id);
let mut _arg_len = from_int(len);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__new_type_float(b: *mut CMuIRBuilder, id: CMuID) {
let mut _arg_b = from_MuIRBuilder_ptr(b);
let mut _arg_id = from_MuID(id);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__new_type_double(b: *mut CMuIRBuilder, id: CMuID) {
let mut _arg_b = from_MuIRBuilder_ptr(b);
let mut _arg_id = from_MuID(id);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__new_type_uptr(b: *mut CMuIRBuilder, id: CMuID, ty: CMuTypeNode) {
let mut _arg_b = from_MuIRBuilder_ptr(b);
let mut _arg_id = from_MuID(id);
let mut _arg_ty = from_MuTypeNode(ty);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__new_type_ufuncptr(b: *mut CMuIRBuilder, id: CMuID, sig: CMuFuncSigNode) {
let mut _arg_b = from_MuIRBuilder_ptr(b);
let mut _arg_id = from_MuID(id);
let mut _arg_sig = from_MuFuncSigNode(sig);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__new_type_struct(b: *mut CMuIRBuilder, id: CMuID, fieldtys: *mut CMuTypeNode, nfieldtys: CMuArraySize) {
let mut _arg_b = from_MuIRBuilder_ptr(b);
let mut _arg_id = from_MuID(id);
let mut _arg_fieldtys = from_MuID_array(fieldtys, nfieldtys);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__new_type_hybrid(b: *mut CMuIRBuilder, id: CMuID, fixedtys: *mut CMuTypeNode, nfixedtys: CMuArraySize, varty: CMuTypeNode) {
let mut _arg_b = from_MuIRBuilder_ptr(b);
let mut _arg_id = from_MuID(id);
let mut _arg_fixedtys = from_MuID_array(fixedtys, nfixedtys);
let mut _arg_varty = from_MuTypeNode(varty);
panic!("not implemented")
}
fn _forwarder__MuIRBuilder__new_type_array(b: *mut CMuIRBuilder, id: CMuID, elemty: