Struct mrubyedge::vm::VM

pub struct VM<'insn> {
    pub vm_id: u32,
    pub irep_arena: HashMap<usize, Rc<VMIrep<'insn>>>,
    pub top_irep: Rc<VMIrep<'insn>>,
    pub cur_irep: Rc<VMIrep<'insn>>,
    pub pc: usize,
    pub class_arena: HashMap<usize, Rc<RefCell<RClass<'insn>>>>,
    pub const_arena: HashMap<String, Rc<RObject>>,
    pub target_class: Option<usize>,
    pub callinfo_vec: Vec<CallInfo<'insn>>,
    pub exception: Option<Box<RObject>>,
    pub regs: HashMap<usize, Rc<RObject>>,
}

Fields

vm_id: u32

irep_arena: HashMap<usize, Rc<VMIrep<'insn>>>

top_irep: Rc<VMIrep<'insn>>

cur_irep: Rc<VMIrep<'insn>>

pc: usize

class_arena: HashMap<usize, Rc<RefCell<RClass<'insn>>>>

const_arena: HashMap<String, Rc<RObject>>

target_class: Option<usize>

callinfo_vec: Vec<CallInfo<'insn>>

exception: Option<Box<RObject>>

regs: HashMap<usize, Rc<RObject>>

Implementations

impl<'insn> VM<'insn>

pub fn open(rite: Rite<'insn>) -> VM<'insn>

Examples found in repository

examples/eval1.rs (line 7)

fn main() {
    let bin = include_bytes!("./simple.mrb");
    let rite = mrubyedge::rite::load(bin).unwrap();
    // dbg!(&rite);
    let mut vm = mrubyedge::vm::VM::open(rite);
    vm.prelude().unwrap();
    // dbg!(&vm);
    vm.eval_insn().unwrap();

    eprintln!("return value:");
    let top = 0 as usize;
    dbg!(vm.regs.get(&top).unwrap());

    // mrubyedge::eval::debug_eval_insn(irep.inst_head).unwrap();
    ()
}

examples/runscript.rs (line 27)

fn main() -> Result<(), std::io::Error> {
    let args: Vec<String> = env::args().skip(1).collect();
    let path = &args[0];

    let output = Command::new("mrbc")
        .arg("-v")
        .arg("-o")
        .arg("/tmp/__tmp__.mrb")
        .arg(path)
        .output()
        .expect("failed to compile mruby script");
    eprintln!("debug: {}", String::from_utf8_lossy(&output.stdout));

    let mut file = File::open("/tmp/__tmp__.mrb")?;
    let mut bin = Vec::<u8>::new();
    file.read_to_end(&mut bin)?;

    let rite = mrubyedge::rite::load(&bin).unwrap();
    // dbg!(&rite);
    let mut vm = mrubyedge::vm::VM::open(rite);
    vm.prelude().unwrap();
    // dbg!(&vm);
    vm.eval_insn().unwrap();

    remove_file("/tmp/__tmp__.mrb")?;

    eprintln!("return value:");
    let top = 0 as usize;
    match vm.regs.get(&top) {
        Some(v) => {
            eprintln!("{:?}", v);
            // eprintln!("{:?}", TryInto::<i32>::try_into(v.as_ref()).unwrap());
        }
        None => eprintln!("None"),
    }

    // dbg!(&vm);
    Ok(())
}

pub fn prelude(&mut self) -> Result<(), Error>

Examples found in repository

examples/eval1.rs (line 8)

fn main() {
    let bin = include_bytes!("./simple.mrb");
    let rite = mrubyedge::rite::load(bin).unwrap();
    // dbg!(&rite);
    let mut vm = mrubyedge::vm::VM::open(rite);
    vm.prelude().unwrap();
    // dbg!(&vm);
    vm.eval_insn().unwrap();

    eprintln!("return value:");
    let top = 0 as usize;
    dbg!(vm.regs.get(&top).unwrap());

    // mrubyedge::eval::debug_eval_insn(irep.inst_head).unwrap();
    ()
}

examples/runscript.rs (line 28)

fn main() -> Result<(), std::io::Error> {
    let args: Vec<String> = env::args().skip(1).collect();
    let path = &args[0];

    let output = Command::new("mrbc")
        .arg("-v")
        .arg("-o")
        .arg("/tmp/__tmp__.mrb")
        .arg(path)
        .output()
        .expect("failed to compile mruby script");
    eprintln!("debug: {}", String::from_utf8_lossy(&output.stdout));

    let mut file = File::open("/tmp/__tmp__.mrb")?;
    let mut bin = Vec::<u8>::new();
    file.read_to_end(&mut bin)?;

    let rite = mrubyedge::rite::load(&bin).unwrap();
    // dbg!(&rite);
    let mut vm = mrubyedge::vm::VM::open(rite);
    vm.prelude().unwrap();
    // dbg!(&vm);
    vm.eval_insn().unwrap();

    remove_file("/tmp/__tmp__.mrb")?;

    eprintln!("return value:");
    let top = 0 as usize;
    match vm.regs.get(&top) {
        Some(v) => {
            eprintln!("{:?}", v);
            // eprintln!("{:?}", TryInto::<i32>::try_into(v.as_ref()).unwrap());
        }
        None => eprintln!("None"),
    }

    // dbg!(&vm);
    Ok(())
}

pub fn eval_insn(&mut self) -> Result<(), Error>

Examples found in repository

examples/eval1.rs (line 10)

fn main() {
    let bin = include_bytes!("./simple.mrb");
    let rite = mrubyedge::rite::load(bin).unwrap();
    // dbg!(&rite);
    let mut vm = mrubyedge::vm::VM::open(rite);
    vm.prelude().unwrap();
    // dbg!(&vm);
    vm.eval_insn().unwrap();

    eprintln!("return value:");
    let top = 0 as usize;
    dbg!(vm.regs.get(&top).unwrap());

    // mrubyedge::eval::debug_eval_insn(irep.inst_head).unwrap();
    ()
}

examples/runscript.rs (line 30)

fn main() -> Result<(), std::io::Error> {
    let args: Vec<String> = env::args().skip(1).collect();
    let path = &args[0];

    let output = Command::new("mrbc")
        .arg("-v")
        .arg("-o")
        .arg("/tmp/__tmp__.mrb")
        .arg(path)
        .output()
        .expect("failed to compile mruby script");
    eprintln!("debug: {}", String::from_utf8_lossy(&output.stdout));

    let mut file = File::open("/tmp/__tmp__.mrb")?;
    let mut bin = Vec::<u8>::new();
    file.read_to_end(&mut bin)?;

    let rite = mrubyedge::rite::load(&bin).unwrap();
    // dbg!(&rite);
    let mut vm = mrubyedge::vm::VM::open(rite);
    vm.prelude().unwrap();
    // dbg!(&vm);
    vm.eval_insn().unwrap();

    remove_file("/tmp/__tmp__.mrb")?;

    eprintln!("return value:");
    let top = 0 as usize;
    match vm.regs.get(&top) {
        Some(v) => {
            eprintln!("{:?}", v);
            // eprintln!("{:?}", TryInto::<i32>::try_into(v.as_ref()).unwrap());
        }
        None => eprintln!("None"),
    }

    // dbg!(&vm);
    Ok(())
}

Trait Implementations

impl<'insn> Debug for VM<'insn>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.