cargo fmt

Cargo.lock

@@ -1,205 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e4c1eaa2012c47becbbad2ab175484c2a84d1185b566fb2cc5b8707343dfe58"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "crypto-common",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.144"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b00cc1c228a6782d0f076e7b232802e0c5689d41bb5df366f2a6b6621cfdfe1"
-
-[[package]]
-name = "once_cell"
-version = "1.17.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
-
-[[package]]
-name = "pest"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e68e84bfb01f0507134eac1e9b410a12ba379d064eab48c50ba4ce329a527b70"
-dependencies = [
- "thiserror",
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b79d4c71c865a25a4322296122e3924d30bc8ee0834c8bfc8b95f7f054afbfb"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c435bf1076437b851ebc8edc3a18442796b30f1728ffea6262d59bbe28b077e"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "745a452f8eb71e39ffd8ee32b3c5f51d03845f99786fa9b68db6ff509c505411"
-dependencies = [
- "once_cell",
- "pest",
- "sha2",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.58"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa1fb82fc0c281dd9671101b66b771ebbe1eaf967b96ac8740dcba4b70005ca8"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "renrs"
-version = "0.1.0"
-dependencies = [
- "pest",
- "pest_derive",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978c9a314bd8dc99be594bc3c175faaa9794be04a5a5e153caba6915336cebac"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "typenum"
-version = "1.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
-
-[[package]]
-name = "version_check"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

Cargo.toml

@@ -0,0 +1,2 @@
+[workspace]
+members = ["renrs", "renrs-gui", "demo"]

renrs-gui/src/lib.rs

@@ -1,16 +1,19 @@
-use std::{path::PathBuf, sync::{Arc, Mutex}};
 use std::thread;
 use std::time::Duration;
+use std::{
+    path::PathBuf,
+    sync::{Arc, Mutex},
+};
 
 use eframe::egui;
 use renrs::State;
 
-use sfml::{
-    graphics::{Color, RenderTarget, RenderWindow, RectangleShape, Transformable},
-    system::Vector2f,
-    window::{Event, mouse, Key, Style},
-};
 use egui_sfml::SfEgui;
+use sfml::{
+    graphics::{Color, RectangleShape, RenderTarget, RenderWindow, Transformable},
+    system::Vector2f,
+    window::{mouse, Event, Key, Style},
+};
 
 const WIDTH: f32 = 800.0;
 const HEIGHT: f32 = 600.0;
@@ -41,7 +44,7 @@ impl App {
     }
 
     fn next(&mut self) {
-        if let Some(renrs::Event::Say { name, text }) = self.state.next() {
+        if let Some(renrs::parser::event::Event::Say { name, text }) = self.state.next() {
             self.text = match name {
                 Some(name) => format!("{name}: {text}"),
                 None => text,
@@ -121,8 +124,17 @@ impl App {
         while window.is_open() {
             while let Some(event) = window.poll_event() {
                 match event {
-                    Event::Closed | Event::KeyPressed { code: Key::Escape, .. } => return,
-                    Event::MouseButtonPressed { button: mouse::Button::Left, .. } | Event::KeyPressed { code: Key::Space, .. } => self.handle_interaction(),
+                    Event::Closed
+                    | Event::KeyPressed {
+                        code: Key::Escape, ..
+                    } => return,
+                    Event::MouseButtonPressed {
+                        button: mouse::Button::Left,
+                        ..
+                    }
+                    | Event::KeyPressed {
+                        code: Key::Space, ..
+                    } => self.handle_interaction(),
                     _ => {}
                 }
             }
@@ -137,15 +149,18 @@ impl App {
                                 ..Default::default()
                             })
                             .show(ctx, |ui| {
-                                if ctx.input(|i|
+                                if ctx.input(|i| {
                                     i.key_pressed(Key::Space)
-                                    || i.pointer.button_clicked(PointerButton::Primary)
-                                ) {
+                                        || i.pointer.button_clicked(PointerButton::Primary)
+                                }) {
                                     self.handle_interaction();
                                 }
-                                ui.with_layout(egui::Layout::left_to_right(Align::Max), |ui| ui.heading(&self.text[0..*self.chars.lock().unwrap()]));
+                                ui.with_layout(egui::Layout::left_to_right(Align::Max), |ui| {
+                                    ui.heading(&self.text[0..*self.chars.lock().unwrap()])
+                                });
                             });
-                    }).unwrap();
+                    })
+                    .unwrap();
             }
 
             let Vector2f { x, y } = shape.position();

renrs/src/lib.rs

@@ -1,424 +1,10 @@
-use core::panic;
-use std::{fs, path::PathBuf, collections::HashMap, rc::Rc, cell::RefCell, hash::Hash};
+use std::{cell::RefCell, path::PathBuf, rc::Rc};
 
-use pest::Parser;
-use pest_derive::Parser;
-use regex::Regex;
-
-#[derive(Parser)]
-#[grammar = "rpy.pest"]
-struct RpyParser;
-
-// Raw script tokens
-#[derive(Debug, Clone)]
-enum Token {
-    Keyword(String),
-    Str(String),
-    Array(Vec<Token>),
-    Boolean(bool),
-    Number(f64),
-}
-
-impl Token {
-    fn print(&self) -> &str {
-        use Token::*;
-        match &self {
-            Keyword(keyword) => keyword,
-            Str(_) => "String",
-            Array(_) => "Array",
-            Boolean(_) => "Boolean",
-            Number(_) => "Number",
-        }
-    }
-}
-
-impl ToString for Token {
-    fn to_string(&self) -> String {
-        use Token::*;
-        match self {
-            Keyword(_) => panic!("keywords should not be used as values"),
-            Str(string) => string.to_owned(),
-            Array(array) => format!(
-                "[{}]",
-                array
-                    .iter()
-                    .map(|token| token.to_string())
-                    .collect::<Vec<String>>()
-                    .join(", ")
-            ),
-            Boolean(boolean) => match boolean {
-                true => "True",
-                false => "False",
-            }.to_owned(),
-            Number(number) => number.to_string(),
-        }
-    }
-}
-
-// Indented command block
-#[derive(Debug)]
-struct CommandBlock {
-    parent: Option<Rc<RefCell<CommandBlock>>>,
-    control: Option<Control>,
-    elements: Vec<BlockElement>,
-    next: Option<usize>,
-    variables: Option<Rc<RefCell<HashMap<String, Token>>>>,
-}
-
-impl CommandBlock {
-    fn next(&mut self) -> Option<Command> {
-        let mut next = match self.next {
-            Some(next) => next,
-            None => return None,
-        };
-        if !self.evaluate_control() {
-            return None;
-        }
-        let mut result = None;
-        let count = self.elements.len();
-        for element in &mut self.elements[next..] {
-            match element {
-                BlockElement::Command(command) => {
-                    result = Some(command.clone());
-                    next += 1;
-                    break;
-                },
-                BlockElement::Block(block) => {
-                    match block.borrow_mut().next() {
-                        Some(command) => {
-                            result = Some(command.clone());
-                            break;
-                        },
-                        None => {
-                            next += 1;
-                        }
-                    }
-                }
-            };
-        }
-        self.next = if count >= next {
-            Some(next)
-        } else {
-            None
-        };
-        result
-    }
-    
-    fn evaluate_control(&self) -> bool {
-        use Control::*;
-        self.control.as_ref().map_or(true, |control| match control {
-            If { condition } => *condition,
-        })
-    }
-
-    fn get_variables(&self) -> HashMap<String, Token> {
-        match &self.variables {
-            Some(variables) => {
-                let variables = variables.borrow().clone();
-                if let Some(parent) = &self.parent {
-                    let mut parent_variables = parent.borrow().get_variables();
-                    parent_variables.extend(variables.into_iter());
-                    parent_variables
-                } else {
-                    variables
-                }
-            },
-            None => HashMap::new(),
-        }
-    }
-}
-
-impl Default for CommandBlock {
-    fn default() -> Self {
-        Self {
-            parent: None,
-            control: None,
-            elements: Vec::new(),
-            next: Some(0),
-            variables: None,
-        }
-    }
-}
-
-#[derive(Debug)]
-enum BlockElement {
-    Command(Command),
-    Block(Rc<RefCell<CommandBlock>>),
-}
-
-#[derive(Debug)]
-#[allow(dead_code)]
-enum Control {
-    If { condition: bool },
-}
-
-impl Control {
-    fn has_variable_scope(&self) -> bool {
-        match self {
-            _ => false,
-        }
-    }
-}
-
-// Parsed script commands
-#[derive(Debug, Clone)]
-#[allow(dead_code)]
-enum Command {
-    Say { name: Option<String>, text: String },
-    Eat { food: String, politely: bool },
-    Define { variable: String, value: Token },
-}
-
-impl Command {
-    fn execute(&self, context: &Rc<RefCell<CommandBlock>>) -> Option<Event> {
-        use Command::*;
-        Some(match self {
-            Say { name, text } => Event::Say {
-                name: name.clone(),
-                text: text.clone(),
-            },
-            Define { .. } => panic!("define command should not be executed at runtime!"),
-            Eat { .. } => return None,
-        }.process(context))
-    }
-}
-
-#[derive(Debug)]
-pub enum Event {
-    Say { name: Option<String>, text: String },
-}
-
-impl Event {
-    fn is_blocking(&self) -> bool {
-        use Event::*;
-        match self {
-            Say { .. } => true,
-        }
-    }
-
-    fn process(mut self, context: &Rc<RefCell<CommandBlock>>) -> Self {
-        use Event::*;
-        match &mut self {
-            Say { name, text } => {
-                let context = context.borrow();
-                let variables = context.get_variables();
-                *name = name.as_deref().map(|name| interpolate_string(&name, &variables));
-                *text = interpolate_string(&text, &variables);
-            }
-        }
-        self
-    }
-}
-
-fn interpolate_string(input: &str, variables: &HashMap<String, Token>) -> String {
-    let re = Regex::new(r"\[(\w+)\]").unwrap();
-    let interpolated_string = re.replace_all(input, |caps: &regex::Captures| {
-        let var_name = &caps[1];
-        if let Some(value) = variables.get(var_name) {
-            value.to_string()
-        } else {
-            format!("[{}]", var_name)
-        }
-    });
-
-    interpolated_string.into_owned()
-}
-
-// ======
-// Parser
-// ======
-
-type Pair<'a> = pest::iterators::Pair<'a, Rule>;
-
-// Read file into commands
-fn parse_file(file_path: &PathBuf) -> Rc<RefCell<CommandBlock>> {
-    let unparsed_file = fs::read_to_string(file_path).expect("cannot find file");
-    parse(&unparsed_file)
-}
-
-fn parse(script: &str) -> Rc<RefCell<CommandBlock>> {
-    let file = RpyParser::parse(Rule::File, script)
-        .expect("unsuccessful parse")
-        .next()
-        .unwrap();
-    parse_block(file, None)
-}
-
-fn parse_block(pair: Pair, definitions: Option<Rc<RefCell<HashMap<String, Token>>>>) -> Rc<RefCell<CommandBlock>> {
-    //let variables: HashMap<String, Token> = HashMap::new();
-    let is_root = definitions.is_none();
-    let definitions = definitions.unwrap_or(Rc::new(RefCell::new(HashMap::new())));
-    let block_rc = Rc::new(RefCell::new(CommandBlock {
-        variables: if is_root { Some(definitions.clone()) } else { None },
-        ..Default::default()
-    }));
-    {
-        let mut block = block_rc.borrow_mut();
-        block.elements = {
-            let mut control = None;
-            let mut elements = Vec::new();
-            for pair in pair.into_inner() {
-                elements.push(match pair.as_rule() {
-                    Rule::Control => {
-                        if control.is_some() {
-                            panic!("control statement should not be empty");
-                        }
-                        control = Some(parse_control(pair));
-                        continue;
-                    },
-                    Rule::Line => BlockElement::Command(match parse_command(pair) {
-                        Command::Define { variable, value } => {
-                            let mut value = value;
-                            if let Token::Keyword(keyword) = value {
-                                value = definitions
-                                    .borrow()
-                                    .get(&keyword)
-                                    .unwrap_or_else(|| panic!("undefined variable `{keyword}`"))
-                                    .clone();
-                            }
-                            definitions.borrow_mut().insert(variable, value);
-                            continue;
-                        }
-                        command => command,
-                    }),
-                    Rule::Block => BlockElement::Block({
-                        let subblock_rc = parse_block(pair, Some(definitions.clone()));
-                        {
-                            let mut subblock = subblock_rc.borrow_mut();
-                            if let Some(control) = control.as_ref() {
-                                if control.has_variable_scope() {
-                                    subblock.variables = Some(Rc::new(RefCell::new(HashMap::new())));
-                                }
-                            } else {
-                                panic!("block should have control");
-                            }
-                            subblock.parent = Some(block_rc.clone());
-                            subblock.control = control;
-                            control = None;
-                        }
-                        subblock_rc
-                    }),
-                    Rule::EOI => break, // end
-                    _ => unreachable!(),
-                });
-            }
-            elements
-        };
-        if is_root {
-            block.variables = Some(definitions);
-        }
-    }
-    block_rc
-}
-
-fn parse_line(pair: Pair) -> Vec<Token> {
-    pair
-        .into_inner()
-        .map(|pair| parse_token(pair))
-        .collect()
-}
-
-fn parse_control(pair: Pair) -> Control {
-    use Control::*;
-    use Token::*;
-    let line = parse_line(pair);
-    macro_rules! unknown {
-        () => {
-            panic!("Unknown control {}", describe_line(&line))
-        };
-    }
-    match line.as_slice() {
-        [Keyword(control), Boolean(condition)] if control.eq("if") => If {
-            condition: *condition,
-        },
-        _ => unknown!(),
-    }
-}
-
-fn parse_command(pair: Pair) -> Command {
-    use Command::*;
-    use Token::*;
-    let line = parse_line(pair);
-    macro_rules! unknown {
-        () => {
-            panic!("Unknown command {}", describe_line(&line))
-        };
-    }
-    match line.as_slice() {
-        [Str(text)] => Say {
-            name: None,
-            text: text.to_owned(),
-        },
-        [Str(name), Str(text)] => Say {
-            name: Some(name.to_owned()),
-            text: text.to_owned(),
-        },
-        [Keyword(keyword), Keyword(variable), Keyword(equals), value] if keyword.eq("define") && equals.eq("=") => Define {
-            variable: variable.to_owned(),
-            value: value.clone(),
-        },
-        [Keyword(keyword), Str(food), tail @ ..] if keyword.eq("eat") => Eat {
-            food: food.to_owned(),
-            politely: match tail {
-                [Boolean(politely)] => *politely,
-                _ => unknown!(),
-            },
-        },
-        _ => unknown!(),
-    }
-}
-
-// Line description e.g. [String, Keyword, Array]
-// Used in parse_command as feedback for invalid commands
-fn describe_line(line: &[Token]) -> String {
-    let mut description = "[".to_owned();
-    let mut iter = line.iter();
-    description.push_str(&format!("{}", iter.next().unwrap().print()));
-    for token in iter {
-        description.push_str(&format!(", {}", token.print()));
-    }
-    description.push_str("]");
-    description
-}
-
-fn parse_token(pair: Pair) -> Token {
-    let token = pair.as_rule();
-    macro_rules! contents {
-        () => {
-            pair.into_inner().next().unwrap()
-        };
-    }
-    match token {
-        Rule::String => {
-            let contents = contents!();
-            Token::Str(match contents.as_rule() {
-                Rule::SingleQuoteStringData => contents.as_str().replace("\\'", "'"),
-                Rule::DoubleQuoteStringData => contents.as_str().replace("\\\"", "\""),
-                _ => unreachable!(),
-            })
-        }
-        Rule::Array => {
-            let contents = contents!();
-            let mut array = Vec::new();
-            for token in contents.into_inner() {
-                array.push(parse_token(token));
-            }
-            Token::Array(array)
-        }
-        Rule::Boolean => Token::Boolean(match pair.as_str() {
-            "True" => true,
-            "False" => false,
-            _ => unreachable!(),
-        }),
-        Rule::Number => Token::Number(pair.as_str().parse().unwrap()),
-        Rule::Keyword => Token::Keyword(pair.as_str().to_owned()),
-        __ => unreachable!(),
-    }
-}
-
-// =====
-// State
-// =====
+pub mod parser;
+use parser::block::CommandBlock;
+use parser::command::Command;
+use parser::event::Event;
+use parser::parse_file;
 
 pub struct State {
     script: Rc<RefCell<CommandBlock>>,

renrs/src/parser/block.rs

@@ -0,0 +1,168 @@
+use std::{cell::RefCell, collections::HashMap, rc::Rc};
+
+use super::{
+    command::{parse_command, Command},
+    control::{parse_control, Control},
+    token::Token,
+    Pair, Rule,
+};
+
+#[derive(Debug)]
+pub struct CommandBlock {
+    parent: Option<Rc<RefCell<CommandBlock>>>,
+    control: Option<Control>,
+    elements: Vec<BlockElement>,
+    next: Option<usize>,
+    variables: Option<Rc<RefCell<HashMap<String, Token>>>>,
+}
+
+impl CommandBlock {
+    pub fn next(&mut self) -> Option<Command> {
+        let mut next = match self.next {
+            Some(next) => next,
+            None => return None,
+        };
+        if !self.evaluate_control() {
+            return None;
+        }
+        let mut result = None;
+        let count = self.elements.len();
+        for element in &mut self.elements[next..] {
+            match element {
+                BlockElement::Command(command) => {
+                    result = Some(command.clone());
+                    next += 1;
+                    break;
+                }
+                BlockElement::Block(block) => match block.borrow_mut().next() {
+                    Some(command) => {
+                        result = Some(command.clone());
+                        break;
+                    }
+                    None => {
+                        next += 1;
+                    }
+                },
+            };
+        }
+        self.next = if count >= next { Some(next) } else { None };
+        result
+    }
+
+    fn evaluate_control(&self) -> bool {
+        use Control::*;
+        self.control.as_ref().map_or(true, |control| match control {
+            If { condition } => *condition,
+        })
+    }
+
+    pub fn get_variables(&self) -> HashMap<String, Token> {
+        match &self.variables {
+            Some(variables) => {
+                let variables = variables.borrow().clone();
+                if let Some(parent) = &self.parent {
+                    let mut parent_variables = parent.borrow().get_variables();
+                    parent_variables.extend(variables.into_iter());
+                    parent_variables
+                } else {
+                    variables
+                }
+            }
+            None => HashMap::new(),
+        }
+    }
+}
+
+impl Default for CommandBlock {
+    fn default() -> Self {
+        Self {
+            parent: None,
+            control: None,
+            elements: Vec::new(),
+            next: Some(0),
+            variables: None,
+        }
+    }
+}
+
+#[derive(Debug)]
+enum BlockElement {
+    Command(Command),
+    Block(Rc<RefCell<CommandBlock>>),
+}
+
+pub fn parse_block(
+    pair: Pair,
+    definitions: Option<Rc<RefCell<HashMap<String, Token>>>>,
+) -> Rc<RefCell<CommandBlock>> {
+    //let variables: HashMap<String, Token> = HashMap::new();
+    let is_root = definitions.is_none();
+    let definitions = definitions.unwrap_or(Rc::new(RefCell::new(HashMap::new())));
+    let block_rc = Rc::new(RefCell::new(CommandBlock {
+        variables: if is_root {
+            Some(definitions.clone())
+        } else {
+            None
+        },
+        ..Default::default()
+    }));
+    {
+        let mut block = block_rc.borrow_mut();
+        block.elements = {
+            let mut control = None;
+            let mut elements = Vec::new();
+            for pair in pair.into_inner() {
+                elements.push(match pair.as_rule() {
+                    Rule::Control => {
+                        if control.is_some() {
+                            panic!("control statement should not be empty");
+                        }
+                        control = Some(parse_control(pair));
+                        continue;
+                    }
+                    Rule::Line => BlockElement::Command(match parse_command(pair) {
+                        Command::Define { variable, value } => {
+                            let mut value = value;
+                            if let Token::Keyword(keyword) = value {
+                                value = definitions
+                                    .borrow()
+                                    .get(&keyword)
+                                    .unwrap_or_else(|| panic!("undefined variable `{keyword}`"))
+                                    .clone();
+                            }
+                            definitions.borrow_mut().insert(variable, value);
+                            continue;
+                        }
+                        command => command,
+                    }),
+                    Rule::Block => BlockElement::Block({
+                        let subblock_rc = parse_block(pair, Some(definitions.clone()));
+                        {
+                            let mut subblock = subblock_rc.borrow_mut();
+                            if let Some(control) = control.as_ref() {
+                                if control.has_variable_scope() {
+                                    // TODO: Sublock-scoped variables
+                                    subblock.variables =
+                                        Some(Rc::new(RefCell::new(HashMap::new())));
+                                }
+                            } else {
+                                panic!("block should have control");
+                            }
+                            subblock.parent = Some(block_rc.clone());
+                            subblock.control = control;
+                            control = None;
+                        }
+                        subblock_rc
+                    }),
+                    Rule::EOI => break, // end
+                    _ => unreachable!(),
+                });
+            }
+            elements
+        };
+        if is_root {
+            block.variables = Some(definitions);
+        }
+    }
+    block_rc
+}

renrs/src/parser/command.rs

@@ -0,0 +1,71 @@
+use std::{cell::RefCell, rc::Rc};
+
+use super::{
+    block::CommandBlock,
+    event::Event,
+    token::Token,
+    utils::{describe_line, parse_line},
+    Pair,
+};
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub enum Command {
+    Say { name: Option<String>, text: String },
+    Eat { food: String, politely: bool },
+    Define { variable: String, value: Token },
+}
+
+impl Command {
+    pub fn execute(&self, context: &Rc<RefCell<CommandBlock>>) -> Option<Event> {
+        use Command::*;
+        Some(
+            match self {
+                Say { name, text } => Event::Say {
+                    name: name.clone(),
+                    text: text.clone(),
+                },
+                Define { .. } => panic!("define command should not be executed at runtime!"),
+                Eat { .. } => return None,
+            }
+            .process(context),
+        )
+    }
+}
+
+pub fn parse_command(pair: Pair) -> Command {
+    use Command::*;
+    use Token::*;
+    let line = parse_line(pair);
+    macro_rules! unknown {
+        () => {
+            panic!("Unknown command {}", describe_line(&line))
+        };
+    }
+    match line.as_slice() {
+        [Str(text)] => Say {
+            name: None,
+            text: text.to_owned(),
+        },
+        [Str(name), Str(text)] => Say {
+            name: Some(name.to_owned()),
+            text: text.to_owned(),
+        },
+        [Keyword(keyword), Keyword(variable), Keyword(equals), value]
+            if keyword.eq("define") && equals.eq("=") =>
+        {
+            Define {
+                variable: variable.to_owned(),
+                value: value.clone(),
+            }
+        }
+        [Keyword(keyword), Str(food), tail @ ..] if keyword.eq("eat") => Eat {
+            food: food.to_owned(),
+            politely: match tail {
+                [Boolean(politely)] => *politely,
+                _ => unknown!(),
+            },
+        },
+        _ => unknown!(),
+    }
+}

renrs/src/parser/control.rs

@@ -0,0 +1,36 @@
+use super::{
+    token::Token,
+    utils::{describe_line, parse_line},
+    Pair,
+};
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub enum Control {
+    If { condition: bool },
+}
+
+impl Control {
+    pub fn has_variable_scope(&self) -> bool {
+        match self {
+            _ => false,
+        }
+    }
+}
+
+pub fn parse_control(pair: Pair) -> Control {
+    use Control::*;
+    use Token::*;
+    let line = parse_line(pair);
+    macro_rules! unknown {
+        () => {
+            panic!("Unknown control {}", describe_line(&line))
+        };
+    }
+    match line.as_slice() {
+        [Keyword(control), Boolean(condition)] if control.eq("if") => If {
+            condition: *condition,
+        },
+        _ => unknown!(),
+    }
+}

renrs/src/parser/event.rs

@@ -0,0 +1,48 @@
+use std::{cell::RefCell, collections::HashMap, rc::Rc};
+
+use regex::Regex;
+
+use super::{block::CommandBlock, token::Token};
+
+#[derive(Debug)]
+pub enum Event {
+    Say { name: Option<String>, text: String },
+}
+
+impl Event {
+    pub fn is_blocking(&self) -> bool {
+        use Event::*;
+        match self {
+            Say { .. } => true,
+        }
+    }
+
+    pub fn process(mut self, context: &Rc<RefCell<CommandBlock>>) -> Self {
+        use Event::*;
+        match &mut self {
+            Say { name, text } => {
+                let context = context.borrow();
+                let variables = context.get_variables();
+                *name = name
+                    .as_deref()
+                    .map(|name| interpolate_string(&name, &variables));
+                *text = interpolate_string(&text, &variables);
+            }
+        }
+        self
+    }
+}
+
+fn interpolate_string(input: &str, variables: &HashMap<String, Token>) -> String {
+    let re = Regex::new(r"\[(\w+)\]").unwrap();
+    let interpolated_string = re.replace_all(input, |caps: &regex::Captures| {
+        let var_name = &caps[1];
+        if let Some(value) = variables.get(var_name) {
+            value.to_string()
+        } else {
+            format!("[{}]", var_name)
+        }
+    });
+
+    interpolated_string.into_owned()
+}

renrs/src/parser/mod.rs

@@ -0,0 +1,33 @@
+pub mod block;
+pub mod command;
+pub mod control;
+pub mod event;
+pub mod token;
+mod utils;
+
+pub type Pair<'a> = pest::iterators::Pair<'a, Rule>;
+
+use std::{cell::RefCell, fs, path::PathBuf, rc::Rc};
+
+pub use pest::Parser;
+use pest_derive::Parser;
+
+use block::{parse_block, CommandBlock};
+
+#[derive(Parser)]
+#[grammar = "rpy.pest"]
+pub struct RpyParser;
+
+// Read file into commands
+pub fn parse_file(file_path: &PathBuf) -> Rc<RefCell<CommandBlock>> {
+    let unparsed_file = fs::read_to_string(file_path).expect("cannot find file");
+    parse(&unparsed_file)
+}
+
+pub fn parse(script: &str) -> Rc<RefCell<CommandBlock>> {
+    let file = RpyParser::parse(Rule::File, script)
+        .expect("unsuccessful parse")
+        .next()
+        .unwrap();
+    parse_block(file, None)
+}

renrs/src/parser/token.rs

@@ -0,0 +1,83 @@
+use super::{Pair, Rule};
+
+// Raw script tokens
+#[derive(Debug, Clone)]
+pub enum Token {
+    Keyword(String),
+    Str(String),
+    Array(Vec<Token>),
+    Boolean(bool),
+    Number(f64),
+}
+
+impl Token {
+    pub fn print(&self) -> &str {
+        use Token::*;
+        match &self {
+            Keyword(keyword) => keyword,
+            Str(_) => "String",
+            Array(_) => "Array",
+            Boolean(_) => "Boolean",
+            Number(_) => "Number",
+        }
+    }
+}
+
+impl ToString for Token {
+    fn to_string(&self) -> String {
+        use Token::*;
+        match self {
+            Keyword(_) => panic!("keywords should not be used as values"),
+            Str(string) => string.to_owned(),
+            Array(array) => format!(
+                "[{}]",
+                array
+                    .iter()
+                    .map(|token| token.to_string())
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
+            Boolean(boolean) => match boolean {
+                true => "True",
+                false => "False",
+            }
+            .to_owned(),
+            Number(number) => number.to_string(),
+        }
+    }
+}
+
+pub fn parse_token(pair: Pair) -> Token {
+    let token = pair.as_rule();
+    macro_rules! contents {
+        () => {
+            pair.into_inner().next().unwrap()
+        };
+    }
+    match token {
+        Rule::String => {
+            let contents = contents!();
+            Token::Str(match contents.as_rule() {
+                Rule::SingleQuoteStringData => contents.as_str().replace("\\'", "'"),
+                Rule::DoubleQuoteStringData => contents.as_str().replace("\\\"", "\""),
+                _ => unreachable!(),
+            })
+        }
+        Rule::Array => {
+            let contents = contents!();
+            let mut array = Vec::new();
+            for token in contents.into_inner() {
+                array.push(parse_token(token));
+            }
+            Token::Array(array)
+        }
+        Rule::Boolean => Token::Boolean(match pair.as_str() {
+            "True" => true,
+            "False" => false,
+            _ => unreachable!(),
+        }),
+        Rule::Number => Token::Number(pair.as_str().parse().unwrap()),
+        Rule::Keyword => Token::Keyword(pair.as_str().to_owned()),
+        __ => unreachable!(),
+    }
+}

renrs/src/parser/utils.rs

@@ -0,0 +1,21 @@
+use super::{
+    token::{parse_token, Token},
+    Pair,
+};
+
+pub fn parse_line(pair: Pair) -> Vec<Token> {
+    pair.into_inner().map(|pair| parse_token(pair)).collect()
+}
+
+// Line description e.g. [String, Keyword, Array]
+// Used in parse_command as feedback for invalid commands
+pub fn describe_line(line: &[Token]) -> String {
+    let mut description = "[".to_owned();
+    let mut iter = line.iter();
+    description.push_str(&format!("{}", iter.next().unwrap().print()));
+    for token in iter {
+        description.push_str(&format!(", {}", token.print()));
+    }
+    description.push_str("]");
+    description
+}