Adding support for strings

src/compiler/parser/mod.rs

@@ -6,7 +6,7 @@ use crate::vm::{Block, Value};
 use rules::{ParseRule, Precedence};
 use std::str::FromStr;
 
-use crate::number;
+use crate::{number, string};
 #[cfg(feature = "disassemble")]
 use tracing_attributes::instrument;
 
@@ -68,6 +68,12 @@ impl Parser {
         self.emit_constant(number!(value));
     }
 
+    #[cfg_attr(feature = "disassemble", instrument(skip(self)))]
+    fn string(&mut self) {
+        let value = &*self.previous_token.token;
+        self.emit_string(string!(value.to_string()));
+    }
+
     #[cfg_attr(feature = "disassemble", instrument(skip(self)))]
     fn grouping(&mut self) {
         self.expression();
@@ -184,6 +190,11 @@ impl Parser {
         self.current_block().write_constant(value, line)
     }
 
+    fn emit_string(&mut self, value: Value) {
+        let line = self.previous_token.line;
+        self.current_block().write_string(value, line)
+    }
+
     fn emit_op_code(&mut self, op_code: OpCode) {
         let line = self.previous_token.line;
         self.current_block().write_op_code(op_code, line);

src/compiler/parser/rules.rs

@@ -67,7 +67,7 @@ lazy_static! {
         (TokenType::Less, ParseRule::new(None, Some(Parser::binary), Precedence::Comparison)),
         (TokenType::LessEqual, ParseRule::new(None, Some(Parser::binary), Precedence::Comparison)),
         (TokenType::Identifier, ParseRule::new(None, None, Precedence::None)),
-        (TokenType::String, ParseRule::new(None, None, Precedence::None)),
+        (TokenType::String, ParseRule::new(Some(Parser::string), None, Precedence::None)),
         (TokenType::InterpolatedString, ParseRule::new(None, None, Precedence::None)),
         (TokenType::Number, ParseRule::new(Some(Parser::number), None, Precedence::None)),
         (TokenType::And, ParseRule::new(None, None, Precedence::None)),

src/vm/block/block.rs

@@ -6,6 +6,7 @@ impl Block {
         Block {
             name: String::from(name),
             constants: Constants::new(),
+            strings: Constants::new(),
             instructions: Vec::new(),
             lines: Vec::new(),
         }
@@ -32,6 +33,12 @@ impl Block {
         }
     }
 
+    pub(crate) fn write_string(&mut self, value: Value, line: u32) {
+        let string_index = self.strings.write_value(value) as u8;
+        self.write_op_code(OpCode::String, line);
+        self.write_u8(string_index)
+    }
+
     pub(crate) fn write_u8(&mut self, value: u8) {
         self.instructions.push(value)
     }
@@ -51,6 +58,11 @@ impl Block {
         self.constants.read_value(index)
     }
 
+    #[inline(always)]
+    pub(in crate::vm) fn read_string(&self, index: usize) -> Value {
+        self.strings.read_value(index)
+    }
+
     #[inline(always)]
     pub(in crate::vm) fn read_u8(&self, offset: usize) -> u8 {
         self.instructions[offset]

src/vm/mod.rs

@@ -34,6 +34,7 @@ pub struct VirtualMachine {
 pub(crate) struct Block {
     name: String,
     constants: Constants,
+    strings: Constants,
     instructions: Vec<u8>,
     lines: Vec<Line>,
 }

src/vm/opcodes.rs

@@ -19,6 +19,7 @@ pub(crate) enum OpCode {
     Greater = 0x0D,
     Less = 0x0E,
     Not = 0x0F,
+    String = 0x10,
 }
 
 impl OpCode {

src/vm/virtual_machine.rs

@@ -122,6 +122,12 @@ impl VirtualMachine {
                     let value = self.pop();
                     self.push(boolean!(is_falsey!(value)));
                 }
+                OpCode::String => {
+                    let string_index = block.read_u8(self.ip + 1) as usize;
+                    let string = block.read_string(string_index);
+                    self.push(string);
+                    self.ip += 1;
+                }
             }
             self.ip += 1;
         }