From db7eb5965d290c45c411ebfd41ee867b1e6183f4 Mon Sep 17 00:00:00 2001
From: Scott Richmond <kredati@users.noreply.github.com>
Date: Mon, 26 May 2025 09:16:47 -0400
Subject: [PATCH] return register now an 8-member array

---
 src/compiler.rs |  3 ++-
 src/main.rs     |  4 +---
 src/value.rs    |  3 +++
 src/vm.rs       | 35 +++++++++++++++++++++++++++--------
 4 files changed, 33 insertions(+), 12 deletions(-)

diff --git a/src/compiler.rs b/src/compiler.rs
index d8929d2..ea9429f 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -870,9 +870,10 @@ impl Compiler {
 
                 self.leave_loop();
             }
-            Recur(_) => {
+            Recur(args) => {
                 // algo
                 // visit each member of the arguments
+
                 // then store those in the return register
                 // then pop back to loop stack root
                 // then jump to loop start
diff --git a/src/main.rs b/src/main.rs
index 1486892..0b27be9 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -74,9 +74,7 @@ pub fn run(src: &'static str) {
 pub fn main() {
     env::set_var("RUST_BACKTRACE", "1");
     let src = "
-repeat 4.8 {
-    true
-}
+123   
     ";
     run(src);
 }
diff --git a/src/value.rs b/src/value.rs
index 6bcc1ae..5cb5512 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -25,6 +25,7 @@ impl LFn {
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Value {
+    Nothing,
     Nil,
     True,
     False,
@@ -44,6 +45,7 @@ impl std::fmt::Display for Value {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         use Value::*;
         match self {
+            Nothing => write!(f, "_"),
             Nil => write!(f, "nil"),
             True => write!(f, "true"),
             False => write!(f, "false"),
@@ -130,6 +132,7 @@ impl Value {
     pub fn type_of(&self) -> &'static str {
         use Value::*;
         match self {
+            Nothing => unreachable!(),
             Nil => "nil",
             True => "bool",
             False => "bool",
diff --git a/src/vm.rs b/src/vm.rs
index 1136ab1..ed95580 100644
--- a/src/vm.rs
+++ b/src/vm.rs
@@ -34,7 +34,7 @@ pub struct Vm<'a> {
     pub stack: Vec<Value>,
     pub chunk: &'a Chunk,
     pub ip: usize,
-    pub return_register: Value,
+    pub return_register: [Value; 8],
     pub matches: bool,
     pub match_depth: u8,
     pub result: Option<Result<Value, Panic>>,
@@ -46,7 +46,16 @@ impl<'a> Vm<'a> {
             chunk,
             stack: vec![],
             ip: 0,
-            return_register: Value::Nil,
+            return_register: [
+                Value::Nothing,
+                Value::Nothing,
+                Value::Nothing,
+                Value::Nothing,
+                Value::Nothing,
+                Value::Nothing,
+                Value::Nothing,
+                Value::Nothing,
+            ],
             matches: false,
             match_depth: 0,
             result: None,
@@ -72,7 +81,13 @@ impl<'a> Vm<'a> {
             .map(|val| val.to_string())
             .collect::<Vec<_>>()
             .join("|");
-        println!("{:04}: [{inner}] {}", self.ip, self.return_register);
+        let register = self
+            .return_register
+            .iter()
+            .map(|val| val.to_string())
+            .collect::<Vec<_>>()
+            .join(",");
+        println!("{:04}: [{inner}] ({register})", self.ip);
     }
 
     fn print_debug(&self) {
@@ -174,14 +189,18 @@ impl<'a> Vm<'a> {
                 self.ip += 2;
             }
             Store => {
-                self.return_register = self.pop();
-                self.push(Value::Nil);
+                self.return_register[0] = self.pop();
+                self.push(Value::Nothing);
                 self.ip += 1;
             }
             Load => {
-                let mut value = Value::Nil;
-                swap(&mut self.return_register, &mut value);
-                self.push(value);
+                let mut i = 0;
+                while i < 8 && self.return_register[i] != Value::Nothing {
+                    let mut value = Value::Nothing;
+                    swap(&mut self.return_register[i], &mut value);
+                    self.push(value);
+                    i += 1;
+                }
                 self.ip += 1;
             }
             ResetMatch => {