98 lines
2.7 KiB
Rust
98 lines
2.7 KiB
Rust
|
use super::tokens::{token, TokenKind as tk, TokenSpan};
|
||
|
|
use super::{IResult, Span};
|
||
|
|
use nom::{
|
||
|
|
branch::alt,
|
||
|
|
combinator::map,
|
||
|
|
multi::separated_list0,
|
||
|
|
sequence::{delimited, preceded, separated_pair, tuple},
|
||
|
|
};
|
||
|
|
|
||
|
|
#[derive(Debug, Clone)]
|
||
|
|
pub enum Operation<'a> {
|
||
|
|
And {
|
||
|
|
a: Expression<'a>,
|
||
|
|
b: Expression<'a>,
|
||
|
|
},
|
||
|
|
Or {
|
||
|
|
a: Expression<'a>,
|
||
|
|
b: Expression<'a>,
|
||
|
|
},
|
||
|
|
Xor {
|
||
|
|
a: Expression<'a>,
|
||
|
|
b: Expression<'a>,
|
||
|
|
},
|
||
|
|
Not(Expression<'a>),
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn operation(input: TokenSpan) -> IResult<TokenSpan, Operation> {
|
||
|
|
// temporarily given up on before I learn the shunting yard algorithm
|
||
|
|
alt((
|
||
|
|
map(
|
||
|
|
separated_pair(expression_nonrecurse, token(tk::BitAnd), expression),
|
||
|
|
|(a, b)| Operation::And { a, b },
|
||
|
|
),
|
||
|
|
map(
|
||
|
|
separated_pair(expression_nonrecurse, token(tk::BitOr), expression),
|
||
|
|
|(a, b)| Operation::Or { a, b },
|
||
|
|
),
|
||
|
|
map(
|
||
|
|
separated_pair(expression_nonrecurse, token(tk::BitXor), expression),
|
||
|
|
|(a, b)| Operation::Xor { a, b },
|
||
|
|
),
|
||
|
|
map(preceded(token(tk::BitNot), expression), Operation::Not),
|
||
|
|
))(input)
|
||
|
|
}
|
||
|
|
|
||
|
|
#[derive(Debug, Clone)]
|
||
|
|
pub struct Call<'a> {
|
||
|
|
pub name: Span<'a>,
|
||
|
|
pub args: Vec<Expression<'a>>,
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn call_item(input: TokenSpan) -> IResult<TokenSpan, Call> {
|
||
|
|
map(
|
||
|
|
tuple((
|
||
|
|
token(tk::Ident),
|
||
|
|
delimited(
|
||
|
|
token(tk::LParen),
|
||
|
|
separated_list0(token(tk::Comma), expression),
|
||
|
|
token(tk::RParen),
|
||
|
|
),
|
||
|
|
)),
|
||
|
|
|(name, args)| Call {
|
||
|
|
name: name.span(),
|
||
|
|
args,
|
||
|
|
},
|
||
|
|
)(input)
|
||
|
|
}
|
||
|
|
|
||
|
|
#[derive(Debug, Clone)]
|
||
|
|
pub enum Expression<'a> {
|
||
|
|
Ident(&'a str),
|
||
|
|
Literal(u64),
|
||
|
|
Call(Box<Call<'a>>),
|
||
|
|
Operation(Box<Operation<'a>>),
|
||
|
|
}
|
||
|
|
|
||
|
|
/// parser combinators can not parse left-recursive grammars. To work around this, we split
|
||
|
|
/// expressions into a recursive and non-recursive portion.
|
||
|
|
/// Parsers reachable from this point must call expression_nonrecurse instead
|
||
|
|
pub fn expression(input: TokenSpan) -> IResult<TokenSpan, Expression> {
|
||
|
|
alt((
|
||
|
|
map(operation, |op| Expression::Operation(Box::new(op))),
|
||
|
|
expression_nonrecurse,
|
||
|
|
))(input)
|
||
|
|
}
|
||
|
|
|
||
|
|
/// the portion of the expression grammar that can be parsed without left recursion
|
||
|
|
fn expression_nonrecurse(input: TokenSpan) -> IResult<TokenSpan, Expression> {
|
||
|
|
alt((
|
||
|
|
map(token(tk::Number), |_| Expression::Literal(42)),
|
||
|
|
map(call_item, |call| Expression::Call(Box::new(call))),
|
||
|
|
map(token(tk::Ident), |ident| {
|
||
|
|
Expression::Ident(*ident.span().fragment())
|
||
|
|
}),
|
||
|
|
delimited(token(tk::LParen), expression, token(tk::RParen)),
|
||
|
|
))(input)
|
||
|
|
}
|