ElnuDev/renrs
1
0
Fork 0
generated from ElnuDev/rust-project
Code Issues Pull requests Projects Releases Packages Wiki Activity

Restructure assignment commands into one command

Browse source
This commit is contained in:
Elnu 2023-05-30 12:27:54 -07:00
parent 9686884c62
commit c72bd94291
3 changed files with 84 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

71
renrs/src/parser/block.rs
View file

@ -2,7 +2,7 @@ use debug_cell::RefCell;
use std::{collections::HashMap, rc::Rc};
use super::{
command::{parse_command, Command},
command::{parse_command, Command, AssignType},
control::{parse_control, Control},
event::Event,
token::Token,
@ -25,41 +25,50 @@ pub struct CommandContext {
impl CommandContext {
pub fn execute(&self) -> Option<Event> {
use Command::*;
use AssignType::*;
Some(
match &self.command {
Say { name, text } => Event::Say {
name: name.clone(),
text: text.clone(),
},
Define { .. } => panic!("define command should not be executed at runtime!"),
Assign { variable, value } => {
if let Token::Keyword(_) = value {
todo!("assignment variable interpolation isn't implemented");
}
let root = self.context.borrow().get_root(&self.context);
// Don't want to re-borrow if root is self
let root = if Rc::ptr_eq(&self.context, &root) {
&self.context
} else {
&root
};
root.borrow_mut()
.variables
.as_ref()
.borrow_mut()
.insert(variable.clone(), value.clone());
return None;
},
Let { variable, value } => {
if let Token::Keyword(_) = value {
todo!("assignment variable interpolation isn't implemented");
}
self.context
.borrow()
.variables
.borrow_mut()
.insert(variable.clone(), value.clone());
return None;
Command::Assign { assign_type, variable, value } => match assign_type {
Define => panic!("define command should not be executed at runtime!"),
GlobalAssign => {
if let Token::Keyword(_) = value {
todo!("assignment variable interpolation isn't implemented");
}
let root = self.context.borrow().get_root(&self.context);
// Don't want to re-borrow if root is self
let root = if Rc::ptr_eq(&self.context, &root) {
&self.context
} else {
&root
};
root.borrow_mut()
.variables
.as_ref()
.borrow_mut()
.insert(variable.clone(), value.clone());
return None;
},
Let => {
if let Token::Keyword(_) = value {
todo!("assignment variable interpolation isn't implemented");
}
self.context
.borrow()
.variables
.borrow_mut()
.insert(variable.clone(), value.clone());
return None;
},
Assign => {
if let Token::Keyword(_) = value {
todo!("assignment variable interpolation isn't implemented");
}
todo!("local variable assignment isn't implemented")
},
}
Eat { .. } => return None,
}
@ -178,7 +187,7 @@ pub fn parse_block(
continue;
}
Rule::Line => BlockElement::Command(match parse_command(pair) {
Command::Define { variable, value } => {
Command::Assign { variable, value, assign_type: AssignType::Define } => {
let mut value = value;
if let Token::Keyword(keyword) = value {
value = definitions

65
renrs/src/parser/command.rs
View file

@ -1,3 +1,5 @@
use std::str::FromStr;
use super::{
token::Token,
utils::{describe_line, parse_line},
@ -7,11 +9,41 @@ use super::{
#[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 },
Assign { variable: String, value: Token },
Let { variable: String, value: Token },
Say {
name: Option<String>,
text: String,
},
Eat {
food: String,
politely: bool,
},
Assign {
assign_type: AssignType,
variable: String,
value: Token,
},
}
#[derive(Debug, Clone)]
pub enum AssignType {
Define,
GlobalAssign,
Let,
Assign,
}
impl FromStr for AssignType {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
use AssignType::*;
Ok(match s {
"define" => Define,
"$" => GlobalAssign,
"let" => Let,
_ => return Err(()),
})
}
}
pub fn parse_command(pair: Pair) -> Command {
@ -32,26 +64,15 @@ pub fn parse_command(pair: Pair) -> Command {
name: Some(name.clone()),
text: text.clone(),
},
// https://github.com/rust-lang/rust/issues/51114
[Keyword(keyword), Keyword(variable), Keyword(equals), value]
if keyword.eq("define") && equals.eq("=") =>
{
Define {
variable: variable.clone(),
value: value.clone(),
}
}
[Keyword(keyword), Keyword(variable), Keyword(equals), value]
if keyword.eq("$") && equals.eq("=") =>
if equals.eq("=") =>
{
Assign {
variable: variable.clone(),
value: value.clone(),
}
}
[Keyword(keyword), Keyword(variable), Keyword(equals), value]
if keyword.eq("let") && equals.eq("=") =>
{
Let {
assign_type: match keyword.parse() {
Ok(assign_type) => assign_type,
Err(_) => unknown!(),
},
variable: variable.clone(),
value: value.clone(),
}

2
renrs/src/parser/token.rs
View file

@ -78,6 +78,6 @@ pub fn parse_token(pair: Pair) -> Token {
}),
Rule::Number => Token::Number(pair.as_str().parse().unwrap()),
Rule::Keyword => Token::Keyword(pair.as_str().to_owned()),
__ => unreachable!(),
_ => unreachable!(),
}
}