Removed ident type, fixed tests

This commit is contained in:
Erin 2022-04-02 01:34:25 +02:00 committed by ondra05
parent db7fc4d592
commit 38fe23d2b5
4 changed files with 246 additions and 264 deletions

View file

@ -50,62 +50,38 @@ impl<T: Hash> Hash for Spanned<T> {
}
}
#[derive(Debug, Clone)]
pub struct Ident {
pub ident: String,
pub span: Span,
}
impl Ident {
pub fn new(ident: String, span: Span) -> Self {
Self { ident, span }
}
}
impl PartialEq for Ident {
fn eq(&self, other: &Self) -> bool {
self.ident == other.ident
}
}
impl Hash for Ident {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.ident.hash(state)
}
}
#[derive(Debug, PartialEq, Clone, Hash)]
pub struct Assignable {
pub ident: Ident,
pub ident: Spanned<String>,
pub kind: AssignableKind,
}
#[derive(Debug, PartialEq, Clone, Hash)]
pub enum AssignableKind {
Variable,
Index { indices: Vec<Spanned<ExprKind>> },
Index { indices: Vec<Spanned<Expr>> },
}
pub struct InvalidAssignable;
impl Assignable {
pub fn from_expr(expr: Spanned<ExprKind>) -> Result<Assignable, InvalidAssignable> {
pub fn from_expr(expr: Spanned<Expr>) -> Result<Assignable, InvalidAssignable> {
match expr.item {
ExprKind::Variable(ident) => Ok(Assignable {
ident: Ident::new(ident, expr.span),
Expr::Variable(ident) => Ok(Assignable {
ident: Spanned::new(ident, expr.span),
kind: AssignableKind::Variable,
}),
ExprKind::Index { expr, index } => Self::from_index(*expr, *index),
Expr::Index { expr, index } => Self::from_index(*expr, *index),
_ => Err(InvalidAssignable),
}
}
fn from_index(mut buf: Spanned<ExprKind>, index: Spanned<ExprKind>) -> Result<Assignable, InvalidAssignable> {
fn from_index(mut buf: Spanned<Expr>, index: Spanned<Expr>) -> Result<Assignable, InvalidAssignable> {
let mut indices = vec![index];
let ident = loop {
match buf.item {
ExprKind::Variable(ident) => break ident,
ExprKind::Index { expr, index } => {
Expr::Variable(ident) => break ident,
Expr::Index { expr, index } => {
indices.push(*index);
buf = *expr;
}
@ -115,23 +91,20 @@ impl Assignable {
indices.reverse();
Ok(Assignable {
ident: Ident::new(ident, buf.span),
ident: Spanned::new(ident, buf.span),
kind: AssignableKind::Index { indices },
})
}
}
#[derive(Debug, PartialEq, Clone, Hash)]
pub struct Block {
pub block: Vec<Spanned<StmtKind>>,
}
pub type Block = Vec<Spanned<Stmt>>;
/// A syntactic unit expressing an effect.
#[derive(Debug, PartialEq, Clone, Hash)]
pub enum StmtKind {
pub enum Stmt {
// Control flow
If {
cond: Spanned<ExprKind>,
cond: Spanned<Expr>,
body: Block,
},
Loop {
@ -141,31 +114,31 @@ pub enum StmtKind {
HopBack,
Var {
ident: Ident,
init: Option<Spanned<ExprKind>>,
ident: Spanned<String>,
init: Option<Spanned<Expr>>,
},
Assign {
assignable: Assignable,
value: Spanned<ExprKind>,
value: Spanned<Expr>,
},
Functio {
ident: Ident,
params: Vec<Ident>,
ident: Spanned<String>,
params: Vec<Spanned<String>>,
body: Block,
},
BfFunctio {
ident: Ident,
tape_len: Option<Spanned<ExprKind>>,
ident: Spanned<String>,
tape_len: Option<Spanned<Expr>>,
code: Vec<u8>,
},
Call {
expr: Spanned<ExprKind>,
args: Vec<Spanned<ExprKind>>,
expr: Spanned<Expr>,
args: Vec<Spanned<Expr>>,
},
Print(Spanned<ExprKind>),
Print(Spanned<Expr>),
Read(Assignable),
Melo(Ident),
Melo(Spanned<String>),
Rlyeh,
Rickroll,
}
@ -173,20 +146,20 @@ pub enum StmtKind {
/// Expression is parse unit which do not cause any effect,
/// like math and logical operations or values.
#[derive(Debug, PartialEq, Clone, Hash)]
pub enum ExprKind {
pub enum Expr {
BinOp {
lhs: Box<Spanned<ExprKind>>,
rhs: Box<Spanned<ExprKind>>,
lhs: Box<Spanned<Expr>>,
rhs: Box<Spanned<Expr>>,
kind: BinOpKind,
},
Not(Box<Spanned<ExprKind>>),
Not(Box<Spanned<Expr>>),
Literal(Value),
Cart(Vec<(Spanned<ExprKind>, Spanned<ExprKind>)>),
Cart(Vec<(Spanned<Expr>, Spanned<Expr>)>),
Index {
expr: Box<Spanned<ExprKind>>,
index: Box<Spanned<ExprKind>>,
expr: Box<Spanned<Expr>>,
index: Box<Spanned<Expr>>,
},
Len(Box<Spanned<ExprKind>>),
Len(Box<Spanned<Expr>>),
Variable(String),
}

View file

@ -19,7 +19,7 @@ use std::{
use rand::random;
use crate::{
ast::{Assignable, AssignableKind, ExprKind, Ident, Spanned, StmtKind},
ast::{Assignable, AssignableKind, Expr, Spanned, Stmt},
base_55,
consts::ablescript_consts,
error::{Error, ErrorKind},
@ -108,7 +108,7 @@ impl ExecEnv {
/// Execute a set of Statements in the root stack frame. Return an
/// error if one or more of the Stmts failed to evaluate, or if a
/// `break` or `hopback` statement occurred at the top level.
pub fn eval_stmts(&mut self, stmts: &[Spanned<StmtKind>]) -> Result<(), Error> {
pub fn eval_stmts(&mut self, stmts: &[Spanned<Stmt>]) -> Result<(), Error> {
match self.eval_stmts_hs(stmts, false)? {
HaltStatus::Finished => Ok(()),
HaltStatus::Break(span) | HaltStatus::Hopback(span) => Err(Error {
@ -128,7 +128,7 @@ impl ExecEnv {
/// function over `eval_stmts`.
fn eval_stmts_hs(
&mut self,
stmts: &[Spanned<StmtKind>],
stmts: &[Spanned<Stmt>],
stackframe: bool,
) -> Result<HaltStatus, Error> {
let init_depth = self.stack.len();
@ -155,9 +155,9 @@ impl ExecEnv {
}
/// Evaluate an Expr, returning its value or an error.
fn eval_expr(&self, expr: &Spanned<ExprKind>) -> Result<Value, Error> {
fn eval_expr(&self, expr: &Spanned<Expr>) -> Result<Value, Error> {
use crate::ast::BinOpKind::*;
use crate::ast::ExprKind::*;
use crate::ast::Expr::*;
Ok(match &expr.item {
BinOp { lhs, rhs, kind } => {
@ -176,7 +176,7 @@ impl ExecEnv {
}
Not(expr) => !self.eval_expr(expr)?,
Literal(value) => value.clone(),
ExprKind::Cart(members) => Value::Cart(
Expr::Cart(members) => Value::Cart(
members
.iter()
.map(|(value, key)| {
@ -200,47 +200,44 @@ impl ExecEnv {
// TODO: not too happy with constructing an artificial
// Ident here.
Variable(name) => self.get_var(&Ident {
ident: name.to_owned(),
span: expr.span.clone(),
})?,
Variable(name) => self.get_var(&Spanned::new(name.to_owned(), expr.span.clone()))?,
})
}
/// Perform the action indicated by a statement.
fn eval_stmt(&mut self, stmt: &Spanned<StmtKind>) -> Result<HaltStatus, Error> {
fn eval_stmt(&mut self, stmt: &Spanned<Stmt>) -> Result<HaltStatus, Error> {
match &stmt.item {
StmtKind::Print(expr) => {
Stmt::Print(expr) => {
println!("{}", self.eval_expr(expr)?);
}
StmtKind::Var { ident, init } => {
Stmt::Var { ident, init } => {
let init = match init {
Some(e) => self.eval_expr(e)?,
None => Value::Nul,
};
self.decl_var(&ident.ident, init);
self.decl_var(&ident.item, init);
}
StmtKind::Functio {
Stmt::Functio {
ident,
params,
body,
} => {
self.decl_var(
&ident.ident,
&ident.item,
Value::Functio(Functio::Able {
params: params.iter().map(|ident| ident.ident.to_owned()).collect(),
body: body.block.to_owned(),
params: params.iter().map(|ident| ident.item.to_owned()).collect(),
body: body.to_owned(),
}),
);
}
StmtKind::BfFunctio {
Stmt::BfFunctio {
ident,
tape_len,
code,
} => {
self.decl_var(
&ident.ident,
&ident.item,
Value::Functio(Functio::Bf {
instructions: code.to_owned(),
tape_len: tape_len
@ -252,47 +249,47 @@ impl ExecEnv {
}),
);
}
StmtKind::If { cond, body } => {
Stmt::If { cond, body } => {
if self.eval_expr(cond)?.into_abool().to_bool() {
return self.eval_stmts_hs(&body.block, true);
return self.eval_stmts_hs(body, true);
}
}
StmtKind::Call { expr, args } => {
Stmt::Call { expr, args } => {
let func = self.eval_expr(expr)?.into_functio();
self.fn_call(func, args, &stmt.span)?;
}
StmtKind::Loop { body } => loop {
let res = self.eval_stmts_hs(&body.block, true)?;
Stmt::Loop { body } => loop {
let res = self.eval_stmts_hs(body, true)?;
match res {
HaltStatus::Finished => {}
HaltStatus::Break(_) => break,
HaltStatus::Hopback(_) => continue,
}
},
StmtKind::Assign { assignable, value } => {
Stmt::Assign { assignable, value } => {
self.assign(assignable, self.eval_expr(value)?)?;
}
StmtKind::Break => {
Stmt::Break => {
return Ok(HaltStatus::Break(stmt.span.clone()));
}
StmtKind::HopBack => {
Stmt::HopBack => {
return Ok(HaltStatus::Hopback(stmt.span.clone()));
}
StmtKind::Melo(ident) => {
Stmt::Melo(ident) => {
self.get_var_mut(ident)?.melo = true;
}
StmtKind::Rlyeh => {
Stmt::Rlyeh => {
// Maybe print a creepy error message or something
// here at some point. ~~Alex
exit(random());
}
StmtKind::Rickroll => {
Stmt::Rickroll => {
stdout()
.write_all(include_str!("rickroll").as_bytes())
.expect("Failed to write to stdout");
}
StmtKind::Read(assignable) => {
Stmt::Read(assignable) => {
let mut value = 0;
for _ in 0..READ_BITS {
value <<= 1;
@ -360,7 +357,7 @@ impl ExecEnv {
fn fn_call(
&mut self,
func: Functio,
args: &[Spanned<ExprKind>],
args: &[Spanned<Expr>],
span: &Range<usize>,
) -> Result<(), Error> {
// Arguments that are ExprKind::Variable are pass by
@ -368,11 +365,8 @@ impl ExecEnv {
let args = args
.iter()
.map(|arg| {
if let ExprKind::Variable(name) = &arg.item {
self.get_var_rc(&Ident {
ident: name.to_owned(),
span: arg.span.clone(),
})
if let Expr::Variable(name) = &arg.item {
self.get_var_rc(&Spanned::new(name.to_owned(), arg.span.clone()))
} else {
self.eval_expr(arg).map(ValueRef::new)
}
@ -522,9 +516,9 @@ impl ExecEnv {
/// Get the value of a variable. Throw an error if the variable is
/// inaccessible or banned.
fn get_var(&self, name: &Ident) -> Result<Value, Error> {
fn get_var(&self, name: &Spanned<String>) -> Result<Value, Error> {
// One-letter names are reserved as base55 numbers.
let mut chars = name.ident.chars();
let mut chars = name.item.chars();
if let (Some(first), None) = (chars.next(), chars.next()) {
return Ok(Value::Int(base_55::char2num(first)));
}
@ -535,20 +529,20 @@ impl ExecEnv {
.stack
.iter()
.rev()
.find_map(|scope| scope.variables.get(&name.ident))
.find_map(|scope| scope.variables.get(&name.item))
{
Some(var) => {
if !var.melo {
Ok(var.value.borrow().clone())
} else {
Err(Error {
kind: ErrorKind::MeloVariable(name.ident.to_owned()),
kind: ErrorKind::MeloVariable(name.item.to_owned()),
span: name.span.clone(),
})
}
}
None => Err(Error {
kind: ErrorKind::UnknownVariable(name.ident.to_owned()),
kind: ErrorKind::UnknownVariable(name.item.to_owned()),
span: name.span.clone(),
}),
}
@ -556,27 +550,27 @@ impl ExecEnv {
/// Get a mutable reference to a variable. Throw an error if the
/// variable is inaccessible or banned.
fn get_var_mut(&mut self, name: &Ident) -> Result<&mut Variable, Error> {
fn get_var_mut(&mut self, name: &Spanned<String>) -> Result<&mut Variable, Error> {
// This function has a lot of duplicated code with `get_var`,
// which I feel like is a bad sign...
match self
.stack
.iter_mut()
.rev()
.find_map(|scope| scope.variables.get_mut(&name.ident))
.find_map(|scope| scope.variables.get_mut(&name.item))
{
Some(var) => {
if !var.melo {
Ok(var)
} else {
Err(Error {
kind: ErrorKind::MeloVariable(name.ident.to_owned()),
kind: ErrorKind::MeloVariable(name.item.to_owned()),
span: name.span.clone(),
})
}
}
None => Err(Error {
kind: ErrorKind::UnknownVariable(name.ident.to_owned()),
kind: ErrorKind::UnknownVariable(name.item.to_owned()),
span: name.span.clone(),
}),
}
@ -584,7 +578,7 @@ impl ExecEnv {
/// Get an Rc'd pointer to the value of a variable. Throw an error
/// if the variable is inaccessible or banned.
fn get_var_rc(&mut self, name: &Ident) -> Result<ValueRef, Error> {
fn get_var_rc(&mut self, name: &Spanned<String>) -> Result<ValueRef, Error> {
Ok(self.get_var_mut(name)?.value.clone())
}
@ -606,7 +600,7 @@ impl ExecEnv {
#[cfg(test)]
mod tests {
use crate::ast::ExprKind;
use crate::ast::Expr;
use super::*;
@ -615,14 +609,14 @@ mod tests {
// Check that 2 + 2 = 4.
let env = ExecEnv::new();
assert_eq!(
env.eval_expr(&Expr {
kind: ExprKind::BinOp {
lhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(2)),
env.eval_expr(&Spanned {
item: Expr::BinOp {
lhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(2)),
span: 1..1,
}),
rhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(2)),
rhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(2)),
span: 1..1,
}),
kind: crate::ast::BinOpKind::Add,
@ -642,14 +636,14 @@ mod tests {
let env = ExecEnv::new();
assert_eq!(
env.eval_expr(&Expr {
kind: ExprKind::BinOp {
lhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(2)),
env.eval_expr(&Spanned {
item: Expr::BinOp {
lhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(2)),
span: 1..1,
}),
rhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Abool(Abool::Always)),
rhs: Box::new(Spanned {
item: Expr::Literal(Value::Abool(Abool::Always)),
span: 1..1,
}),
kind: crate::ast::BinOpKind::Add,
@ -667,14 +661,14 @@ mod tests {
// of panicking.
let env = ExecEnv::new();
assert_eq!(
env.eval_expr(&Expr {
kind: ExprKind::BinOp {
lhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(isize::MAX)),
env.eval_expr(&Spanned {
item: Expr::BinOp {
lhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(isize::MAX)),
span: 1..1,
}),
rhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(1)),
rhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(1)),
span: 1..1,
}),
kind: crate::ast::BinOpKind::Add,
@ -687,14 +681,14 @@ mod tests {
// And the same for divide by zero.
assert_eq!(
env.eval_expr(&Expr {
kind: ExprKind::BinOp {
lhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(84)),
env.eval_expr(&Spanned {
item: Expr::BinOp {
lhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(84)),
span: 1..1,
}),
rhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(0)),
rhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(0)),
span: 1..1,
}),
kind: crate::ast::BinOpKind::Divide,
@ -728,8 +722,8 @@ mod tests {
// Declaring and reading from a variable.
eval(&mut env, "var foo = 32; var bar = foo + 1;").unwrap();
assert_eq!(
env.get_var(&Ident {
ident: "bar".to_owned(),
env.get_var(&Spanned {
item: "bar".to_owned(),
span: 1..1,
})
.unwrap(),
@ -739,8 +733,8 @@ mod tests {
// Assigning an existing variable.
eval(&mut env, "foo = /*hi*/;").unwrap();
assert_eq!(
env.get_var(&Ident {
ident: "foo".to_owned(),
env.get_var(&Spanned {
item: "foo".to_owned(),
span: 1..1,
})
.unwrap(),
@ -765,8 +759,8 @@ mod tests {
.unwrap();
assert_eq!(
env.get_var(&Ident {
ident: "foo".to_owned(),
env.get_var(&Spanned {
item: "foo".to_owned(),
span: 1..1,
})
.unwrap(),

View file

@ -29,7 +29,7 @@ impl<'source> Parser<'source> {
/// Start parsing tokens
///
/// Loops trough lexer, parses statements, returns AST
pub fn init(&mut self) -> Result<Vec<Spanned<StmtKind>>, Error> {
pub fn init(&mut self) -> Result<Block, Error> {
let mut ast = vec![];
while let Some(token) = self.lexer.next() {
match token {
@ -37,7 +37,7 @@ impl<'source> Parser<'source> {
Token::Comment => continue,
// T-Dark block (replace `lang` with `script`)
Token::TDark => ast.extend(self.tdark_flow()?.block),
Token::TDark => ast.extend(self.tdark_flow()?),
token => ast.push(self.parse(token)?),
}
}
@ -64,7 +64,7 @@ impl<'source> Parser<'source> {
///
/// This function will route to corresponding flow functions
/// which may advance the lexer iterator
fn parse(&mut self, token: Token) -> Result<Spanned<StmtKind>, Error> {
fn parse(&mut self, token: Token) -> Result<Spanned<Stmt>, Error> {
let start = self.lexer.span().start;
match token {
@ -75,22 +75,28 @@ impl<'source> Parser<'source> {
)),
Token::Bff => Ok(Spanned::new(self.bff_flow()?, start..self.lexer.span().end)),
Token::Var => Ok(Spanned::new(self.var_flow()?, start..self.lexer.span().end)),
Token::Melo => Ok(Spanned::new(self.melo_flow()?, start..self.lexer.span().end)),
Token::Loop => Ok(Spanned::new(self.loop_flow()?, start..self.lexer.span().end)),
Token::Melo => Ok(Spanned::new(
self.melo_flow()?,
start..self.lexer.span().end,
)),
Token::Loop => Ok(Spanned::new(
self.loop_flow()?,
start..self.lexer.span().end,
)),
Token::Break => Ok(Spanned::new(
self.semicolon_terminated(StmtKind::Break)?,
self.semicolon_terminated(Stmt::Break)?,
start..self.lexer.span().end,
)),
Token::HopBack => Ok(Spanned::new(
self.semicolon_terminated(StmtKind::HopBack)?,
self.semicolon_terminated(Stmt::HopBack)?,
start..self.lexer.span().end,
)),
Token::Rlyeh => Ok(Spanned::new(
self.semicolon_terminated(StmtKind::Rlyeh)?,
self.semicolon_terminated(Stmt::Rlyeh)?,
start..self.lexer.span().end,
)),
Token::Rickroll => Ok(Spanned::new(
self.semicolon_terminated(StmtKind::Rickroll)?,
self.semicolon_terminated(Stmt::Rickroll)?,
start..self.lexer.span().end,
)),
@ -114,7 +120,7 @@ impl<'source> Parser<'source> {
/// Require statement to be semicolon terminated
///
/// Utility function for short statements
fn semicolon_terminated(&mut self, stmt_kind: StmtKind) -> Result<StmtKind, Error> {
fn semicolon_terminated(&mut self, stmt_kind: Stmt) -> Result<Stmt, Error> {
self.require(Token::Semicolon)?;
Ok(stmt_kind)
}
@ -128,16 +134,16 @@ impl<'source> Parser<'source> {
}
/// Get an Identifier
fn get_ident(&mut self) -> Result<Ident, Error> {
fn get_ident(&mut self) -> Result<Spanned<String>, Error> {
match self.checked_next()? {
Token::Identifier(ident) => Ok(Ident {
ident: if self.tdark {
Token::Identifier(ident) => Ok(Spanned::new(
if self.tdark {
ident.replace("lang", "script")
} else {
ident
},
span: self.lexer.span(),
}),
self.lexer.span(),
)),
t => Err(Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())),
}
}
@ -147,7 +153,11 @@ impl<'source> Parser<'source> {
/// AbleScript strongly separates expressions from statements.
/// Expressions do not have any side effects and the are
/// only mathematial and logical operations or values.
fn parse_expr(&mut self, token: Token, buf: &mut Option<Spanned<ExprKind>>) -> Result<Spanned<ExprKind>, Error> {
fn parse_expr(
&mut self,
token: Token,
buf: &mut Option<Spanned<Expr>>,
) -> Result<Spanned<Expr>, Error> {
let start = match buf {
Some(e) => e.span.start,
None => self.lexer.span().start,
@ -156,7 +166,7 @@ impl<'source> Parser<'source> {
match token {
// Values
Token::Identifier(i) => Ok(Spanned::new(
ExprKind::Variable(if self.tdark {
Expr::Variable(if self.tdark {
i.replace("lang", "script")
} else {
i
@ -164,11 +174,11 @@ impl<'source> Parser<'source> {
start..self.lexer.span().end,
)),
Token::Integer(i) => Ok(Spanned::new(
ExprKind::Literal(Value::Int(i)),
Expr::Literal(Value::Int(i)),
start..self.lexer.span().end,
)),
Token::String(s) => Ok(Spanned::new(
ExprKind::Literal(Value::Str(if self.tdark {
Expr::Literal(Value::Str(if self.tdark {
s.replace("lang", "script")
} else {
s
@ -181,7 +191,10 @@ impl<'source> Parser<'source> {
self.index_flow(buf)?,
start..self.lexer.span().end,
)),
None => Ok(Spanned::new(self.cart_flow()?, start..self.lexer.span().end)),
None => Ok(Spanned::new(
self.cart_flow()?,
start..self.lexer.span().end,
)),
},
// Operations
@ -203,7 +216,7 @@ impl<'source> Parser<'source> {
Token::Not => Ok(Spanned::new(
{
let next = self.checked_next()?;
ExprKind::Not(Box::new(self.parse_expr(next, buf)?))
Expr::Not(Box::new(self.parse_expr(next, buf)?))
},
start..self.lexer.span().end,
)),
@ -214,7 +227,7 @@ impl<'source> Parser<'source> {
}
/// Flow for creating carts
fn cart_flow(&mut self) -> Result<ExprKind, Error> {
fn cart_flow(&mut self) -> Result<Expr, Error> {
let mut cart = vec![];
let mut buf = None;
@ -256,24 +269,24 @@ impl<'source> Parser<'source> {
}
}
Ok(ExprKind::Cart(cart))
Ok(Expr::Cart(cart))
}
/// Flow for indexing operations
///
/// Indexing with empty index resolves to length of expression, else it indexes
fn index_flow(&mut self, expr: Spanned<ExprKind>) -> Result<ExprKind, Error> {
fn index_flow(&mut self, expr: Spanned<Expr>) -> Result<Expr, Error> {
let mut buf = None;
Ok(loop {
match self.checked_next()? {
Token::RightBracket => match buf {
Some(index) => {
break ExprKind::Index {
break Expr::Index {
expr: Box::new(expr),
index: Box::new(index),
}
}
None => break ExprKind::Len(Box::new(expr)),
None => break Expr::Len(Box::new(expr)),
},
token => buf = Some(self.parse_expr(token, &mut buf)?),
}
@ -285,8 +298,12 @@ impl<'source> Parser<'source> {
/// Generates operation from LHS buffer and next expression as RHS
///
/// This is unaware of precedence, as AbleScript do not have it
fn binop_flow(&mut self, kind: BinOpKind, lhs: &mut Option<Spanned<ExprKind>>) -> Result<ExprKind, Error> {
Ok(ExprKind::BinOp {
fn binop_flow(
&mut self,
kind: BinOpKind,
lhs: &mut Option<Spanned<Expr>>,
) -> Result<Expr, Error> {
Ok(Expr::BinOp {
lhs: Box::new(
lhs.take()
.ok_or_else(|| Error::new(ErrorKind::MissingLhs, self.lexer.span()))?,
@ -303,7 +320,7 @@ impl<'source> Parser<'source> {
}
/// Parse expressions until terminate token
fn expr_flow(&mut self, terminate: Token) -> Result<Spanned<ExprKind>, Error> {
fn expr_flow(&mut self, terminate: Token) -> Result<Spanned<Expr>, Error> {
let mut buf = None;
Ok(loop {
match self.checked_next()? {
@ -325,11 +342,11 @@ impl<'source> Parser<'source> {
loop {
match self.checked_next()? {
Token::RightCurly => break,
Token::TDark => block.extend(self.tdark_flow()?.block),
Token::TDark => block.extend(self.tdark_flow()?),
t => block.push(self.parse(t)?),
}
}
Ok(Block { block })
Ok(block)
}
/// Parse T-Dark block
@ -343,13 +360,13 @@ impl<'source> Parser<'source> {
/// If Statement parser gets any kind of value (Identifier or Literal)
/// It cannot parse it as it do not parse expressions. Instead of it it
/// will parse it to function call or print statement.
fn value_flow(&mut self, init: Token) -> Result<StmtKind, Error> {
fn value_flow(&mut self, init: Token) -> Result<Stmt, Error> {
let mut buf = Some(self.parse_expr(init, &mut None)?);
let r = loop {
match self.checked_next()? {
// Print to stdout
Token::Print => {
let stmt = StmtKind::Print(buf.take().ok_or_else(|| {
let stmt = Stmt::Print(buf.take().ok_or_else(|| {
Error::new(ErrorKind::UnexpectedToken(Token::Print), self.lexer.span())
})?);
break self.semicolon_terminated(stmt)?;
@ -368,7 +385,7 @@ impl<'source> Parser<'source> {
// Variable Assignment
Token::Equal => {
if let Some(Ok(assignable)) = buf.take().map(Assignable::from_expr) {
break StmtKind::Assign {
break Stmt::Assign {
assignable,
value: self.expr_flow(Token::Semicolon)?,
};
@ -384,7 +401,7 @@ impl<'source> Parser<'source> {
Token::Read => {
if let Some(Ok(assignable)) = buf.take().map(Assignable::from_expr) {
self.require(Token::Semicolon)?;
break StmtKind::Read(assignable);
break Stmt::Read(assignable);
} else {
return Err(Error::new(
ErrorKind::UnexpectedToken(Token::Read),
@ -403,20 +420,20 @@ impl<'source> Parser<'source> {
/// Parse If flow
///
/// Consists of condition and block, there is no else
fn if_flow(&mut self) -> Result<StmtKind, Error> {
fn if_flow(&mut self) -> Result<Stmt, Error> {
self.require(Token::LeftParen)?;
let cond = self.expr_flow(Token::RightParen)?;
let body = self.get_block()?;
Ok(StmtKind::If { cond, body })
Ok(Stmt::If { cond, body })
}
/// Parse functio flow
///
/// functio $ident (a, b, c) { ... }
fn functio_flow(&mut self) -> Result<StmtKind, Error> {
fn functio_flow(&mut self) -> Result<Stmt, Error> {
let ident = self.get_ident()?;
self.require(Token::LeftParen)?;
@ -426,7 +443,7 @@ impl<'source> Parser<'source> {
match self.checked_next()? {
Token::RightParen => break,
Token::Identifier(i) => {
params.push(Ident::new(i, self.lexer.span()));
params.push(Spanned::new(i, self.lexer.span()));
// Require comma (next) or right paren (end) after identifier
match self.checked_next()? {
@ -446,7 +463,7 @@ impl<'source> Parser<'source> {
let body = self.get_block()?;
Ok(StmtKind::Functio {
Ok(Stmt::Functio {
ident,
params,
body,
@ -456,7 +473,7 @@ impl<'source> Parser<'source> {
/// Parse BF function declaration
///
/// `bff $ident ([tapelen]) { ... }`
fn bff_flow(&mut self) -> Result<StmtKind, Error> {
fn bff_flow(&mut self) -> Result<Stmt, Error> {
let ident = self.get_ident()?;
let tape_len = match self.checked_next()? {
@ -489,7 +506,7 @@ impl<'source> Parser<'source> {
}
}
Ok(StmtKind::BfFunctio {
Ok(Stmt::BfFunctio {
ident,
tape_len,
code,
@ -497,7 +514,7 @@ impl<'source> Parser<'source> {
}
/// Parse functio call flow
fn functio_call_flow(&mut self, expr: Spanned<ExprKind>) -> Result<StmtKind, Error> {
fn functio_call_flow(&mut self, expr: Spanned<Expr>) -> Result<Stmt, Error> {
let mut args = vec![];
let mut buf = None;
loop {
@ -526,11 +543,11 @@ impl<'source> Parser<'source> {
}
self.require(Token::Semicolon)?;
Ok(StmtKind::Call { expr, args })
Ok(Stmt::Call { expr, args })
}
/// Parse variable declaration
fn var_flow(&mut self) -> Result<StmtKind, Error> {
fn var_flow(&mut self) -> Result<Stmt, Error> {
let ident = self.get_ident()?;
let init = match self.checked_next()? {
Token::Equal => Some(self.expr_flow(Token::Semicolon)?),
@ -538,20 +555,20 @@ impl<'source> Parser<'source> {
t => return Err(Error::new(ErrorKind::UnexpectedToken(t), self.lexer.span())),
};
Ok(StmtKind::Var { ident, init })
Ok(Stmt::Var { ident, init })
}
/// Parse Melo flow
fn melo_flow(&mut self) -> Result<StmtKind, Error> {
fn melo_flow(&mut self) -> Result<Stmt, Error> {
let ident = self.get_ident()?;
self.semicolon_terminated(StmtKind::Melo(ident))
self.semicolon_terminated(Stmt::Melo(ident))
}
/// Parse loop flow
///
/// `loop` is an infinite loop, no condition, only body
fn loop_flow(&mut self) -> Result<StmtKind, Error> {
Ok(StmtKind::Loop {
fn loop_flow(&mut self) -> Result<Stmt, Error> {
Ok(Stmt::Loop {
body: self.get_block()?,
})
}
@ -564,23 +581,23 @@ mod tests {
#[test]
fn simple_math() {
let code = "1 * (a + 3) / 666 print;";
let expected = &[Stmt {
kind: StmtKind::Print(Expr {
kind: ExprKind::BinOp {
lhs: Box::new(Expr {
kind: ExprKind::BinOp {
lhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(1)),
let expected = &[Spanned {
item: Stmt::Print(Spanned {
item: Expr::BinOp {
lhs: Box::new(Spanned {
item: Expr::BinOp {
lhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(1)),
span: 0..1,
}),
rhs: Box::new(Expr {
kind: ExprKind::BinOp {
lhs: Box::new(Expr {
kind: ExprKind::Variable("a".to_owned()),
rhs: Box::new(Spanned {
item: Expr::BinOp {
lhs: Box::new(Spanned {
item: Expr::Variable("a".to_owned()),
span: 5..6,
}),
rhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(3)),
rhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(3)),
span: 9..10,
}),
kind: BinOpKind::Add,
@ -591,8 +608,8 @@ mod tests {
},
span: 0..11,
}),
rhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(666)),
rhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(666)),
span: 14..17,
}),
kind: BinOpKind::Divide,
@ -609,14 +626,14 @@ mod tests {
#[test]
fn variable_declaration() {
let code = "var a = 42;";
let expected = &[Stmt {
kind: StmtKind::Var {
ident: Ident {
ident: "a".to_owned(),
let expected = &[Spanned {
item: Stmt::Var {
ident: Spanned {
item: "a".to_owned(),
span: 4..5,
},
init: Some(Expr {
kind: ExprKind::Literal(Value::Int(42)),
init: Some(Spanned {
item: Expr::Literal(Value::Int(42)),
span: 8..10,
}),
},
@ -630,31 +647,29 @@ mod tests {
#[test]
fn if_flow() {
let code = "if (a == always) { /*Buy Able products!*/ print; }";
let expected = &[Stmt {
kind: StmtKind::If {
cond: Expr {
kind: ExprKind::BinOp {
lhs: Box::new(Expr {
kind: ExprKind::Variable("a".to_owned()),
let expected = &[Spanned {
item: Stmt::If {
cond: Spanned {
item: Expr::BinOp {
lhs: Box::new(Spanned {
item: Expr::Variable("a".to_owned()),
span: 4..5,
}),
rhs: Box::new(Expr {
kind: ExprKind::Variable("always".to_owned()),
rhs: Box::new(Spanned {
item: Expr::Variable("always".to_owned()),
span: 9..15,
}),
kind: BinOpKind::Equal,
},
span: 4..15,
},
body: Block {
block: vec![Stmt {
kind: StmtKind::Print(Expr {
kind: ExprKind::Literal(Value::Str("Buy Able products!".to_owned())),
span: 19..39,
}),
span: 19..46,
}],
},
body: vec![Spanned {
item: Stmt::Print(Spanned {
item: Expr::Literal(Value::Str("Buy Able products!".to_owned())),
span: 19..39,
}),
span: 19..46,
}],
},
span: 0..48,
}];
@ -666,20 +681,20 @@ mod tests {
#[test]
fn tdark() {
let code = "T-Dark { var lang = /*lang*/ + lang; }";
let expected = &[Stmt {
kind: StmtKind::Var {
ident: Ident {
ident: "script".to_owned(),
let expected = &[Spanned {
item: Stmt::Var {
ident: Spanned {
item: "script".to_owned(),
span: 13..17,
},
init: Some(Expr {
kind: ExprKind::BinOp {
lhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Str("script".to_owned())),
init: Some(Spanned {
item: Expr::BinOp {
lhs: Box::new(Spanned {
item: Expr::Literal(Value::Str("script".to_owned())),
span: 20..26,
}),
rhs: Box::new(Expr {
kind: ExprKind::Variable("script".to_owned()),
rhs: Box::new(Spanned {
item: Expr::Variable("script".to_owned()),
span: 29..33,
}),
kind: BinOpKind::Add,
@ -697,33 +712,33 @@ mod tests {
#[test]
fn cart_construction() {
let code = "[/*able*/ <= 1, /*script*/ <= 3 - 1] print;";
let expected = &[Stmt {
kind: StmtKind::Print(Expr {
kind: ExprKind::Cart(vec![
let expected = &[Spanned {
item: Stmt::Print(Spanned {
item: Expr::Cart(vec![
(
Expr {
kind: ExprKind::Literal(Value::Str("able".to_owned())),
Spanned {
item: Expr::Literal(Value::Str("able".to_owned())),
span: 1..7,
},
Expr {
kind: ExprKind::Literal(Value::Int(1)),
Spanned {
item: Expr::Literal(Value::Int(1)),
span: 11..12,
},
),
(
Expr {
kind: ExprKind::Literal(Value::Str("script".to_owned())),
Spanned {
item: Expr::Literal(Value::Str("script".to_owned())),
span: 14..22,
},
Expr {
kind: ExprKind::BinOp {
Spanned {
item: Expr::BinOp {
kind: BinOpKind::Subtract,
lhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(3)),
lhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(3)),
span: 26..27,
}),
rhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Int(1)),
rhs: Box::new(Spanned {
item: Expr::Literal(Value::Int(1)),
span: 30..31,
}),
},
@ -743,24 +758,24 @@ mod tests {
#[test]
fn cart_index() {
let code = "[/*able*/ <= /*ablecorp*/][/*ablecorp*/] print;";
let expected = &[Stmt {
kind: StmtKind::Print(Expr {
kind: ExprKind::Index {
expr: Box::new(Expr {
kind: ExprKind::Cart(vec![(
Expr {
kind: ExprKind::Literal(Value::Str("able".to_owned())),
let expected = &[Spanned {
item: Stmt::Print(Spanned {
item: Expr::Index {
expr: Box::new(Spanned {
item: Expr::Cart(vec![(
Spanned {
item: Expr::Literal(Value::Str("able".to_owned())),
span: 1..7,
},
Expr {
kind: ExprKind::Literal(Value::Str("ablecorp".to_owned())),
Spanned {
item: Expr::Literal(Value::Str("ablecorp".to_owned())),
span: 11..21,
},
)]),
span: 0..22,
}),
index: Box::new(Expr {
kind: ExprKind::Literal(Value::Str("ablecorp".to_owned())),
index: Box::new(Spanned {
item: Expr::Literal(Value::Str("ablecorp".to_owned())),
span: 23..33,
}),
},

View file

@ -12,7 +12,7 @@ use std::{
use rand::Rng;
use crate::{brian::INSTRUCTION_MAPPINGS, consts, ast::{Spanned, StmtKind}};
use crate::{ast::Block, brian::INSTRUCTION_MAPPINGS, consts};
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub enum Abool {
@ -58,7 +58,7 @@ pub enum Functio {
},
Able {
params: Vec<String>,
body: Vec<Spanned<StmtKind>>,
body: Block,
},
Builtin(BuiltinFunctio),
Chain {