mrubyedge · udzura · Feb 13, 2026 · Feb 12, 2026 · Feb 12, 2026 · Feb 12, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/mrubyedge-cli/Cargo.toml b/mrubyedge-cli/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "mrubyedge-cli"
-version = "1.1.4"
+version = "1.1.5"
 edition = "2024"
 authors = ["Uchio Kondo <[email protected]>"]
 description = "mruby/edge cli endpoint - run, compile to wasm, etc."
@@ -14,8 +14,8 @@ path = "src/main.rs"
 [dependencies]
 clap = { version = "4.5", features = ["derive"] }
 crossterm = "0.28"
-mruby-compiler2-sys = "0.2.2"
-mrubyedge = { version = "1.1.4", features = [
+mruby-compiler2-sys = "0.3.0"
+mrubyedge = { version = "1.1.5", features = [
     "default",
     "mruby-random",
     "mruby-regexp",

diff --git a/mrubyedge-cli/src/subcommands/repl.rs b/mrubyedge-cli/src/subcommands/repl.rs
@@ -2,13 +2,19 @@ use clap::Args;
 use crossterm::{
     cursor,
     event::{self, Event, KeyCode, KeyEvent, KeyModifiers},
-    execute,
+    execute as cs_execute,
     terminal::{self, ClearType},
 };
-use std::io::{self, Write};
+use std::{
+    io::{self, Write},
+    rc::Rc,
+};
 
 use mruby_compiler2_sys as mrbc;
-use mrubyedge::yamrb::helpers::mrb_call_inspect;
+use mrubyedge::{
+    RObject,
+    yamrb::{helpers::mrb_call_inspect, value::RHashMap},
+};
 
 #[derive(Args)]
 pub struct ReplArgs {
@@ -45,6 +51,9 @@ pub fn execute(args: ReplArgs) -> Result<(), Box<dyn std::error::Error>> {
     // Print initial prompt
     print!("repl:{:03}> ", line_number);
     stdout.flush()?;
+    let mut top_level_lvars: RHashMap<String, Rc<RObject>> = RHashMap::default();
+
+    let mut ctx = unsafe { mrbc::MRubyCompiler2Context::new() };
 
     let result = (|| -> Result<(), Box<dyn std::error::Error>> {
         loop {
@@ -122,26 +131,62 @@ pub fn execute(args: ReplArgs) -> Result<(), Box<dyn std::error::Error>> {
 
                         // Execute buffered code
                         unsafe {
-                            let mut ctx = mrbc::MRubyCompiler2Context::new();
+                            if args.verbose {
+                                ctx.dump_bytecode(&buffer).unwrap();
+                            }
                             match ctx.compile(&buffer) {
                                 Ok(mrb_bin) => match mrubyedge::rite::load(&mrb_bin) {
-                                    Ok(mut new_rite) => match vm.eval_rite(&mut new_rite) {
-                                        Ok(result) => match mrb_call_inspect(&mut vm, result) {
-                                            Ok(inspect_result) => {
-                                                match TryInto::<String>::try_into(
-                                                    inspect_result.as_ref(),
-                                                ) {
-                                                    Ok(s) => println!(" => {}", s),
-                                                    Err(_) => println!(" => <unprintable>"),
+                                    Ok(mut new_rite) => {
+                                        // FIXME: sub ireps's lv not handled yet
+                                        let top_rep = &new_rite.irep[0];
+                                        for (reg, name) in top_rep.lv.iter().enumerate() {
+                                            if let Some(name) = name
+                                                && let Some(value) = top_level_lvars
+                                                    .get(&name.to_string_lossy().to_string())
+                                            {
+                                                vm.regs[reg + 1] = value.clone().into();
+                                            }
+                                        }
+                                        match vm.eval_rite(&mut new_rite) {
+                                            Ok(result) => match mrb_call_inspect(&mut vm, result) {
+                                                Ok(inspect_result) => {
+                                                    match TryInto::<String>::try_into(
+                                                        inspect_result.as_ref(),
+                                                    ) {
+                                                        Ok(s) => println!(" => {}", s),
+                                                        Err(_) => println!(" => <unprintable>"),
+                                                    }
                                                 }
+                                                Err(_) => println!(" => <inspect failed>"),
+                                            },
+                                            Err(e) => {
+                                                eprintln!("{:?}", e);
+                                                vm.exception.take();
                                             }
-                                            Err(_) => println!(" => <inspect failed>"),
-                                        },
-                                        Err(e) => {
-                                            eprintln!("{:?}", e);
-                                            vm.exception.take();
                                         }
-                                    },
+                                        // Display top-level local variables
+                                        if let Some(lv) = &vm.current_irep.lv {
+                                            for (reg, name) in lv.iter() {
+                                                let value =
+                                                    vm.regs[*reg].as_ref().cloned().unwrap_or(
+                                                        RObject::nil().to_refcount_assigned(),
+                                                    );
+                                                top_level_lvars
+                                                    .insert(name.to_string(), value.clone());
+                                            }
+                                            for (k, v) in top_level_lvars.iter() {
+                                                let inspect: String =
+                                                    mrb_call_inspect(&mut vm, v.clone())
+                                                        .unwrap()
+                                                        .as_ref()
+                                                        .try_into()
+                                                        .unwrap();
+                                                if args.verbose {
+                                                    eprintln!("  [lv] {} => {}", k, inspect);
+                                                }
+                                            }
+                                        }
+                                    }
                                     Err(e) => {
                                         eprintln!("Failed to load bytecode: {:?}", e);
                                     }
@@ -167,7 +212,7 @@ pub fn execute(args: ReplArgs) -> Result<(), Box<dyn std::error::Error>> {
                     } => {
                         if !current_line.is_empty() {
                             current_line.pop();
-                            execute!(
+                            cs_execute!(
                                 stdout,
                                 cursor::MoveLeft(1),
                                 terminal::Clear(ClearType::UntilNewLine)

diff --git a/mrubyedge/Cargo.toml b/mrubyedge/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "mrubyedge"
-version = "1.1.4"
+version = "1.1.5"
 edition = "2024"
 authors = ["Uchio Kondo <[email protected]>"]
 description = "mruby/edge is yet another mruby that is specialized for running on WASM"
@@ -23,7 +23,7 @@ criterion = "0.5.1"
 mec-mrbc-sys = "3.3.1"
 fnv = "1.0.7"
 once_cell = "1.20.2"
-mruby-compiler2-sys = "0.2.2"
+mruby-compiler2-sys = "0.3.0"
 
 [[bench]]
 name = "benchmark"

diff --git a/mrubyedge/examples/newvm-2.rs b/mrubyedge/examples/newvm-2.rs
@@ -60,6 +60,7 @@ fn main() {
         syms: Vec::new(),
         pool: Vec::new(),
         reps: Vec::new(),
+        lv: None,
         catch_target_pos: Vec::new(),
     };
 
@@ -149,6 +150,7 @@ fn main() {
         syms: vec![value::RSym::new("do_add".to_string())],
         pool: Vec::new(),
         reps: vec![Rc::new(irep1)],
+        lv: None,
         catch_target_pos: Vec::new(),
     };
     let mut vm = vm::VM::new_by_raw_irep(irep0);

diff --git a/mrubyedge/examples/newvm-3.rs b/mrubyedge/examples/newvm-3.rs
@@ -193,6 +193,7 @@ fn main() {
         syms: vec![value::RSym::new("fib".to_string())],
         pool: Vec::new(),
         reps: Vec::new(),
+        lv: None,
         catch_target_pos: Vec::new(),
     };
 
@@ -259,6 +260,7 @@ fn main() {
         syms: vec![value::RSym::new("fib".to_string())],
         pool: Vec::new(),
         reps: vec![Rc::new(irep1)],
+        lv: None,
         catch_target_pos: Vec::new(),
     };
     let mut vm = vm::VM::new_by_raw_irep(irep0);

diff --git a/mrubyedge/examples/newvm.rs b/mrubyedge/examples/newvm.rs
@@ -76,6 +76,7 @@ fn main() {
         syms: vec![RSym::new("puts".to_string())],
         pool: Vec::new(),
         reps: Vec::new(),
+        lv: None,
         catch_target_pos: Vec::new(),
     };
     let mut vm = vm::VM::new_by_raw_irep(irep);

diff --git a/mrubyedge/examples/yield.rb b/mrubyedge/examples/yield.rb
@@ -0,0 +1,12 @@
+def got_block
+  yield 1
+  #b.call
+  yield 2
+  #b.call 2
+end
+
+got_block
+
+# got_block do |x|
+#   puts "Got block with #{x}"
+# end
diff --git a/mrubyedge/src/lib.rs b/mrubyedge/src/lib.rs
@@ -36,6 +36,7 @@
 //!         syms: vec![RSym::new("puts".to_string())],
 //!         pool: Vec::new(),
 //!         reps: Vec::new(),
+//!         lv: None,
 //!         catch_target_pos: Vec::new(),
 //!     };
 //!