Add String-values and String-literals

examples/test.lua

@@ -22,3 +22,4 @@ print(add(10)(15))
 print(b)
 print(min(11, 9))
 print(10 - 15)
+print("hello there!")

src/ast.rs

@@ -421,6 +421,9 @@ impl Parse for PrimaryExpression {
             Expression::Literal(Literal::Number(
                 u64::from_str_radix(&value, 10).unwrap() as f64
             ))
+        } else if let Some(Token::StringLit(value)) = peeked {
+            stream.next(); // Consume string-literal
+            Expression::Literal(Literal::String(value))
         } else {
             Expression::ValueRef(stream.parse()?)
         };
@@ -492,7 +495,8 @@ fn parse_binop_rhs(
     Ok(lhs.0)
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub enum Literal {
     Number(LuaNumber),
+    String(String),
 }

src/compile.rs

@@ -318,6 +318,11 @@ impl Expression {
                     constants.insert(Constant::Number(value.to_bits()));
                     constants
                 }
+                Literal::String(value) => {
+                    let mut constants = HashSet::new();
+                    constants.insert(Constant::String(value.clone()));
+                    constants
+                }
             },
         }
     }
@@ -530,6 +535,7 @@ impl Expression {
                     reg,
                     state.get_constant(&match literal {
                         Literal::Number(value) => Constant::Number(value.to_bits()),
+                        Literal::String(value) => Constant::String(value.clone()),
                     }),
                 ));
                 (instructions, vec![reg])

src/main.rs

@@ -104,22 +104,22 @@ fn main() {
     let mut run = closure.run(Vec::new());
 
     while run.next().unwrap().is_none() {
-        let (instructions, state, constants) =
+        // let (instructions, state, constants) =
-            compile("print(b)", constants.clone(), state.prototypes.clone());
+        //     compile("print(b)", constants.clone(), state.prototypes.clone());
 
-        // dbg!(&instructions);
+        // // dbg!(&instructions);
 
-        let mut new_run = run.execute(instructions, state, constants);
+        // let mut new_run = run.execute(instructions, state, constants);
-        while {
+        // while {
-            match new_run.next() {
+        //     match new_run.next() {
-                Ok(Some(_)) => false,
+        //         Ok(Some(_)) => false,
-                Ok(None) => true,
+        //         Ok(None) => true,
-                Err(e) => {
+        //         Err(e) => {
-                    print!("Error: {}", e);
+        //             print!("Error: {}", e);
-                    false
+        //             false
-                }
+        //         }
-            }
+        //     }
-        } {}
+        // } {}
     }
 
     dbg!(&vm.environment.borrow().globals);

src/vm.rs

@@ -122,6 +122,7 @@ pub struct Environment {
 
 #[derive(Clone)]
 pub enum Value {
+    String(String),
     Number(VMNumber),
     RustFunction(Rc<RefCell<dyn RustFunction>>),
     Function(Closure),
@@ -236,15 +237,16 @@ impl Value {
 impl Debug for Value {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::Number(arg0) => f
+            Value::Number(arg0) => f
                 .debug_tuple("Number")
                 .field(&LuaNumber::from_bits(*arg0))
                 .finish(),
-            Self::RustFunction(arg0) => f.debug_tuple("RustFunction").field(arg0).finish(),
+            Value::String(value) => f.debug_tuple("String").field(value).finish(),
-            Self::Function(closure) => f
+            Value::RustFunction(arg0) => f.debug_tuple("RustFunction").field(arg0).finish(),
+            Value::Function(closure) => f
                 .debug_tuple(&format!("Function({})", closure.prototype))
                 .finish(),
-            Self::Nil => write!(f, "Nil"),
+            Value::Nil => write!(f, "Nil"),
         }
     }
 }
@@ -420,7 +422,7 @@ impl ClosureRunner {
                     self.set_stack(
                         *reg,
                         match constants.get(*constant as usize).unwrap() {
-                            Constant::String(_) => todo!(),
+                            Constant::String(value) => Value::String(value.clone()),
                             Constant::Number(value) => Value::Number(*value),
                         },
                     );