mrubyedge-cli 1.1.11

#![allow(unused_variables)]
#![allow(non_snake_case)]
#![allow(unused_imports)]
extern crate mrubyedge;

use core::mem::MaybeUninit;
use std::rc::Rc;
use std::cell::RefCell;
use std::any::Any;

use mrubyedge::yamrb::value::*;

const DATA: &'static [u8] = include_bytes!("./{{ file_basename }}.mrb");
const MEMORY_INDEX: u32 = 0;
const PAGE_SIZE: usize = 65536; // 64KB

#[cfg(target_arch = "wasm32")]
#[no_mangle]
pub unsafe fn __mrbe_grow(num_pages: usize) -> *const u8 {
    use core::arch::wasm32;
    let num_pages = wasm32::memory_grow(MEMORY_INDEX, num_pages);
    if num_pages == usize::max_value() {
        return usize::max_value() as *const u8;
    }
    let ptr = (num_pages * PAGE_SIZE) as *const u8;
    ptr
}

extern "C" {
{% for fn in ftypes_imports %}
    fn {{ fn.func_name }}({{ fn.args_decl }}) {{ fn.rettype_decl }};
{% endfor %}
}

{% for fn in ftypes_imports %}
{{ fn.import_helper_var }}
fn __imported_c_{{ fn.func_name }}(_vm: &mut mrubyedge::yamrb::vm::VM, args: &[Rc<RObject>]) -> Result<Rc<RObject>, mrubyedge::Error> {
{{ fn.imported_body }}
}
{% endfor %}

static mut MRUBY_VM: MaybeUninit<mrubyedge::yamrb::vm::VM> = MaybeUninit::uninit();
static mut MRUBY_VM_LOADED: bool = false;

#[allow(static_mut_refs)]
unsafe fn assume_initialized_VM() -> &'static mut mrubyedge::yamrb::vm::VM {
    if !MRUBY_VM_LOADED {
        initVM();
        MRUBY_VM_LOADED = true;
    }
    MRUBY_VM.assume_init_mut()
}

fn initVM() {
    let mut rite = mrubyedge::rite::load(DATA).unwrap();
    let mut vm = mrubyedge::yamrb::vm::VM::open(&mut rite);

{% for ifn in ftypes_imports %}
    let klass = vm.object_class.clone();
    let method = Box::new(__imported_c_{{ ifn.func_name }});
    mrubyedge::yamrb::helpers::mrb_define_cmethod(&mut vm, klass, "{{ ifn.func_name }}", method);
{% endfor %}

    vm.run().unwrap();

    unsafe {
        MRUBY_VM = core::mem::MaybeUninit::new(vm);
    }
}

{% for fn in ftypes %}

{{ fn.exported_helper_var }}
#[no_mangle]
pub fn {{ fn.func_name }}({{ fn.args_decl }}) {{ fn.rettype_decl }} {
    let mut vm = unsafe { assume_initialized_VM() };

    {{ fn.str_args_converter }}

    vm.run().unwrap();

    let args = {{ fn.args_let_vec }};
    let retval: Result<Rc<RObject>, mrubyedge::Error> = 
        mrubyedge::yamrb::helpers::mrb_funcall(
            &mut vm,
            None,
            "{{ fn.func_name }}",
            &args);

    match &retval {
        Ok(retval) => {
	    {{ fn.handle_retval }}
        }
        Err(ex) => {
            dbg!(ex);
            panic!("mruby error");
        }
    }
}
{% endfor %}