Struct Walker 

pub struct Walker {
    pub msg_stack: Vec<LunarIR>,
    pub idx_of_irep: usize,
    pub current_irep: usize,
    pub idx_of_ireps: HashMap<usize, IrepIndices>,
}

Fields

msg_stack: Vec<LunarIR>

idx_of_irep: usize

current_irep: usize

idx_of_ireps: HashMap<usize, IrepIndices>

Implementations

impl Walker

pub fn new() -> Self

Examples found in repository

examples/smoke.rs (line 15)

fn main() {
    let source = r#"
for i = 1, 5 do
   print "hello, world\n"
end
"#;
    // let source = r#"print "hello, world\n""#;

    match lunar_lang::lua::loader::load_string(source) {
        Ok(program) => {
            println!("Parsed program: {:?}", &program);
            let mut walker = lunar_lang::lua::walker::Walker::new();
            walker.walk(&program.block);
            for (i, msg) in walker.msg_stack.iter().enumerate() {
                println!("MSG: {:<04}: {:?}", i, msg);
            }

            let mruby = lunar_lang::rite::transformer::transform(&walker.msg_stack);
            for (i, rep) in mruby.iter().enumerate() {
                println!("IREP: {:<04}: rlen = {}", i, rep.borrow().rep_len);
                println!("IREP: {:<04}: syms = {:?}", i, &rep.borrow().syms);
                println!("IREP: {:<04}: pool = {:?}", i, &rep.borrow().pool);
                println!("IREP: {:<04}: nregs = {:?}", i, &rep.borrow().regs);
                println!("IREP: {:<04}: nlocals = {:?}", i, &rep.borrow().locals);
                for (j, msg) in rep.borrow().insn.iter().enumerate() {
                    println!("IREP: {:<04}:{:<04} {:?}", i, j, msg);
                }
            }

            let mut packer = lunar_lang::rite::packer::RitePacker::new();
            match packer.pack(&mruby) {
                Ok(_) => {
                    // let packed = &packer.buf;
                }
                Err(e) => eprintln!("Error packing: {}", e),
            }

            match packer.write_to_file("test.mrb") {
                Ok(_) => println!("Packed binary written to ./test.mrb"),
                Err(e) => eprintln!("Error writing to file: {}", e),
            }
        },
        Err(e) => eprintln!("Error parsing program: {}", e),
    }
}

pub fn push_msg(&mut self, msg: LunarIR)

pub fn walk(&mut self, root: &Block)

Examples found in repository

examples/smoke.rs (line 16)

fn main() {
    let source = r#"
for i = 1, 5 do
   print "hello, world\n"
end
"#;
    // let source = r#"print "hello, world\n""#;

    match lunar_lang::lua::loader::load_string(source) {
        Ok(program) => {
            println!("Parsed program: {:?}", &program);
            let mut walker = lunar_lang::lua::walker::Walker::new();
            walker.walk(&program.block);
            for (i, msg) in walker.msg_stack.iter().enumerate() {
                println!("MSG: {:<04}: {:?}", i, msg);
            }

            let mruby = lunar_lang::rite::transformer::transform(&walker.msg_stack);
            for (i, rep) in mruby.iter().enumerate() {
                println!("IREP: {:<04}: rlen = {}", i, rep.borrow().rep_len);
                println!("IREP: {:<04}: syms = {:?}", i, &rep.borrow().syms);
                println!("IREP: {:<04}: pool = {:?}", i, &rep.borrow().pool);
                println!("IREP: {:<04}: nregs = {:?}", i, &rep.borrow().regs);
                println!("IREP: {:<04}: nlocals = {:?}", i, &rep.borrow().locals);
                for (j, msg) in rep.borrow().insn.iter().enumerate() {
                    println!("IREP: {:<04}:{:<04} {:?}", i, j, msg);
                }
            }

            let mut packer = lunar_lang::rite::packer::RitePacker::new();
            match packer.pack(&mruby) {
                Ok(_) => {
                    // let packed = &packer.buf;
                }
                Err(e) => eprintln!("Error packing: {}", e),
            }

            match packer.write_to_file("test.mrb") {
                Ok(_) => println!("Packed binary written to ./test.mrb"),
                Err(e) => eprintln!("Error writing to file: {}", e),
            }
        },
        Err(e) => eprintln!("Error parsing program: {}", e),
    }
}

pub fn walk_block(&mut self, block: &Block)

pub fn walk_chunk(&mut self, chunk: &Chunk)

pub fn walk_stat(&mut self, stat: &Stat)

pub fn walk_args(&mut self, args: &Args)

pub fn ensure_expr_as_number(&mut self, expr: &Expr) -> f64

pub fn walk_prefixexpr(&mut self, prefix_expr: &PrefixExp)

pub fn walk_var(&mut self, var: &Var)

pub fn walk_laststat(&mut self, last_stat: &LastStat)

Trait Implementations

impl Debug for Walker

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

Formats the value using the given formatter.