use std::iter::Peekable;
use std::sync::Arc;
use rust_decimal::Decimal;
use crate::tokens::{Lexer, Token};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Program {
pub commands: Arc<[Command]>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Command {
Statement(Statement),
Expression(Expression),
PanicMode(Arc<[Token]>),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Statement {
pub function_name: Arc<str>,
pub function_token: Token,
pub args: Arc<[Expression]>,
pub newline: Option<Token>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Expression {
pub prefix: Arc<[Token]>,
pub suffix: ExpressionSuffix,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExpressionSuffix {
Nothing,
Number { value: Decimal, token: Token },
String { value: Arc<str>, token: Token },
Identifier { name: Arc<str>, token: Token },
List(List),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct List {
pub left_paren: Token,
pub items: Arc<[ListItem]>,
pub right_paren: Option<Token>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ListItem {
Dot(Token),
Expression(Expression),
}
impl Command {
pub fn is_empty(&self) -> bool {
if let Self::PanicMode(tokens) = self {
tokens.is_empty()
} else {
false
}
}
pub fn expression(&self) -> Option<&Expression> {
if let Self::Expression(expr) = self {
Some(expr)
} else {
None
}
}
pub fn statement(&self) -> Option<&Statement> {
if let Self::Statement(statement) = self {
Some(statement)
} else {
None
}
}
}
impl Expression {
pub fn is_quoted(&self) -> bool {
self.prefix.len() == 1 && self.prefix[0].is_apostrophe()
}
}
impl ExpressionSuffix {
pub fn is_empty(&self) -> bool {
matches!(self, Self::Nothing)
}
pub fn number(&self) -> Option<&Decimal> {
if let Self::Number { value, .. } = self {
Some(value)
} else {
None
}
}
pub fn string(&self) -> Option<&Arc<str>> {
if let Self::String { value, .. } = self {
Some(value)
} else {
None
}
}
pub fn identifier(&self) -> Option<&Arc<str>> {
if let Self::Identifier { name, .. } = self {
Some(name)
} else {
None
}
}
pub fn list(&self) -> Option<&List> {
if let Self::List(list) = self {
Some(list)
} else {
None
}
}
}
impl List {
pub fn contains_dot(&self) -> bool {
self.items.iter().any(|item| item.dot().is_some())
}
}
impl ListItem {
pub fn dot(&self) -> Option<&Token> {
if let Self::Dot(token) = self {
Some(token)
} else {
None
}
}
pub fn expression(&self) -> Option<&Expression> {
if let Self::Expression(expression) = self {
Some(expression)
} else {
None
}
}
}
fn parse_many<R>(
lexer: &mut Peekable<Lexer>,
predicate: fn(&Token) -> bool,
parser: fn(&mut Peekable<Lexer>) -> Result<R, String>,
) -> Result<Vec<R>, String> {
let mut items = Vec::new();
while let Some(next) = lexer.peek() {
if !predicate(next) {
break;
}
items.push(parser(lexer)?)
}
Ok(items)
}
fn parse_if<R>(
lexer: &mut Peekable<Lexer>,
predicate: fn(&Token) -> bool,
parser: fn(&mut Peekable<Lexer>) -> Result<R, String>,
) -> Option<Result<R, String>> {
let next = lexer.peek()?;
predicate(next).then(|| parser(lexer))
}
fn skip_whitespace_and_comments(lexer: &mut Peekable<Lexer>) {
while lexer
.next_if(|token| token.is_comment() || token.is_whitespace())
.is_some()
{}
}
fn skip_spaces_and_comments(lexer: &mut Peekable<Lexer>) {
while lexer
.next_if(|token: &Token| {
(token.is_whitespace() && !token.contains_newline()) || token.is_comment()
})
.is_some()
{}
}
fn skip_non_expression_tokens(lexer: &mut Peekable<Lexer>) -> Vec<Token> {
let mut tokens = Vec::new();
while let Some(token) = lexer.next_if(|token| !begins_expression(token)) {
tokens.push(token);
}
tokens
}
fn begins_expression(token: &Token) -> bool {
match &token.ty {
crate::tokens::TokenType::Whitespace(_) => false,
crate::tokens::TokenType::LineComment(_) => false,
crate::tokens::TokenType::BlockComment { .. } => false,
crate::tokens::TokenType::LeftParenthesis => true,
crate::tokens::TokenType::RightParenthesis => false,
crate::tokens::TokenType::Apostrophe => true,
crate::tokens::TokenType::Pound => true,
crate::tokens::TokenType::Dot => false,
crate::tokens::TokenType::Identifier(_) => true,
crate::tokens::TokenType::String { .. } => true,
crate::tokens::TokenType::Number(_) => true,
}
}
fn begins_list_item(token: &Token) -> bool {
begins_expression(token) || token.is_dot()
}
pub fn parse_program(lexer: &mut Peekable<Lexer>) -> Result<Program, String> {
skip_whitespace_and_comments(lexer);
let mut commands = parse_many(lexer, |_| true, parse_command)?;
if commands.last().map(|c| c.is_empty()).unwrap_or(false) {
commands.pop();
}
let commands = commands.into();
Ok(Program { commands })
}
fn parse_command(lexer: &mut Peekable<Lexer>) -> Result<Command, String> {
skip_whitespace_and_comments(lexer);
if let Some(result) = parse_if(lexer, |token| token.is_identifier(), parse_statement) {
result.map(Command::Statement)
} else if let Some(result) = parse_if(lexer, begins_expression, parse_expression) {
result.map(Command::Expression)
} else {
Ok(Command::PanicMode(skip_non_expression_tokens(lexer).into()))
}
}
fn parse_statement(lexer: &mut Peekable<Lexer>) -> Result<Statement, String> {
skip_whitespace_and_comments(lexer);
let function_token = lexer
.next()
.ok_or_else(|| String::from("expected a function name"))?;
let function_name = function_token
.identifier()
.ok_or_else(|| String::from("expected the function name to be an identifier"))?
.into();
skip_spaces_and_comments(lexer);
let args = parse_many(lexer, begins_expression, parse_expression)?.into();
skip_spaces_and_comments(lexer);
let newline = lexer.next_if(|token| token.contains_newline());
Ok(Statement {
function_name,
function_token,
args,
newline,
})
}
fn parse_expression(lexer: &mut Peekable<Lexer>) -> Result<Expression, String> {
skip_whitespace_and_comments(lexer);
let prefix = parse_many(
lexer,
|token| token.is_pound() || token.is_apostrophe(),
|parser| {
let result = parser.next().ok_or(String::new());
skip_whitespace_and_comments(parser);
result
},
)?
.into();
skip_whitespace_and_comments(lexer);
let suffix = parse_expression_suffix(lexer)?;
skip_spaces_and_comments(lexer);
Ok(Expression { prefix, suffix })
}
fn parse_expression_suffix(lexer: &mut Peekable<Lexer>) -> Result<ExpressionSuffix, String> {
skip_whitespace_and_comments(lexer);
if let Some(list) = parse_if(lexer, |token| token.is_left_parenthesis(), parse_list) {
list.map(ExpressionSuffix::List)
} else if let Some(identifier) = lexer.next_if(|token| token.is_identifier()) {
Ok(ExpressionSuffix::Identifier {
name: identifier
.identifier()
.ok_or_else(|| String::from("we just checked for an identifier"))?
.into(),
token: identifier,
})
} else if let Some(string) = lexer.next_if(|token| token.is_string()) {
Ok(ExpressionSuffix::String {
value: string
.computed_string()
.ok_or_else(|| String::from("we just checked for an string"))?
.into(),
token: string,
})
} else if let Some(number) = lexer.next_if(|token| token.is_number()) {
Ok(ExpressionSuffix::Number {
value: *number
.number()
.ok_or_else(|| String::from("we just checked for a number"))?,
token: number,
})
} else {
Ok(ExpressionSuffix::Nothing)
}
}
fn parse_list(lexer: &mut Peekable<Lexer>) -> Result<List, String> {
skip_whitespace_and_comments(lexer);
let left_paren = lexer
.next_if(|token| token.is_left_parenthesis())
.ok_or_else(|| String::from("Unexpected token. Expected a left parenthesis"))?;
skip_whitespace_and_comments(lexer);
let items = parse_many(lexer, begins_list_item, parse_list_item)?.into();
skip_whitespace_and_comments(lexer);
let right_paren = lexer.next_if(|token| token.is_right_parenthesis());
Ok(List {
left_paren,
items,
right_paren,
})
}
fn parse_list_item(lexer: &mut Peekable<Lexer>) -> Result<ListItem, String> {
skip_whitespace_and_comments(lexer);
if let Some(dot) = lexer.next_if(|token| token.is_dot()) {
skip_whitespace_and_comments(lexer);
Ok(ListItem::Dot(dot))
} else {
let result = parse_expression(lexer).map(ListItem::Expression);
skip_whitespace_and_comments(lexer);
result
}
}
|
