use super::*;
impl S2sParser {
pub(super) fn parse_args(lexer: &mut S2sLexer) -> S2sResult<Vec<Expr>> {
let mut args = Vec::new();
loop {
Self::skip_comments(lexer);
match lexer.peek() {
None | Some((Token::Semicolon, _)) | Some((Token::RBrace, _)) => break,
_ => {}
}
if let Some((Token::RParen, _)) = lexer.peek() {
break;
}
args.push(Self::parse_expr(lexer)?);
Self::skip_comments(lexer);
if let Some((Token::Comma, _)) = lexer.peek() {
let _ = lexer.next_token();
}
}
Ok(args)
}
pub(super) fn parse_expr(lexer: &mut S2sLexer) -> S2sResult<Expr> {
let left = Self::parse_primary_expr(lexer)?;
Self::parse_infix_arithmetic(lexer, left)
}
fn parse_primary_expr(lexer: &mut S2sLexer) -> S2sResult<Expr> {
let peeked = lexer.peek().cloned();
let (tok, span) = match peeked {
Some(t) => t,
None => {
return Err(Self::error(lexer, 0, "unexpected end of input in expression"));
}
};
match tok {
Token::String => {
let _ = lexer.next_token();
let raw = lexer.slice(&span);
let content = &raw[1..raw.len() - 1];
Ok(Expr::String(content.to_string()))
}
Token::Number => {
let _ = lexer.next_token();
let num = lexer.slice(&span);
Ok(Expr::Number(num.to_string()))
}
Token::Variable => {
let _ = lexer.next_token();
let var = lexer.slice(&span);
let var = var.strip_prefix('$').unwrap_or(var).to_string();
Ok(Expr::Variable(var))
}
Token::Ident => {
let (_, id_span) = lexer.next_token().unwrap();
let name = lexer.slice(&id_span).to_string();
let next = lexer.peek().map(|(t, _)| t.clone());
if next == Some(Token::LParen) {
Self::parse_return_command_body(lexer, name)
} else {
Ok(Expr::Variable(name))
}
}
Token::LParen => {
let _ = lexer.next_token();
let expr = Self::parse_condition_inner(lexer)?;
Self::expect_token(lexer, Token::RParen)?;
Ok(expr)
}
Token::Plus | Token::Minus => {
let sign = if tok == Token::Plus { "+" } else { "-" };
let _ = lexer.next_token();
let next_peek = lexer.peek().cloned();
match next_peek {
Some((Token::Number, num_span)) => {
let _ = lexer.next_token();
let num = lexer.slice(&num_span);
Ok(Expr::Number(format!("{}{}", sign, num)))
}
Some((Token::Variable, var_span)) => {
let _ = lexer.next_token();
let var = lexer.slice(&var_span);
let var = var.strip_prefix('$').unwrap_or(var).to_string();
if sign == "-" {
Ok(Expr::Negate(Box::new(Expr::Variable(var))))
} else {
Ok(Expr::Variable(var))
}
}
Some((Token::LParen, _)) => {
let expr = Self::parse_condition_inner(lexer)?;
if sign == "-" {
Ok(Expr::Negate(Box::new(expr)))
} else {
Ok(expr)
}
}
_ => {
let (line, col) = Self::peek_linecol(lexer);
Err(S2sError::Parse {
line,
column: col,
message: format!(
"expected number, variable, or '(' after '{}'",
sign
),
})
}
}
}
_ => {
let (line, col) = Self::peek_linecol(lexer);
Err(S2sError::Parse {
line,
column: col,
message: format!("unexpected token '{}' in expression", tok.name()),
})
}
}
}
fn parse_infix_arithmetic(lexer: &mut S2sLexer, mut left: Expr) -> S2sResult<Expr> {
loop {
let op = match lexer.peek().map(|(t, _)| t.clone()) {
Some(Token::Plus) => {
let _ = lexer.next_token();
ArithOp::Add
}
Some(Token::Minus) => {
let _ = lexer.next_token();
ArithOp::Sub
}
Some(Token::Star) => {
let _ = lexer.next_token();
ArithOp::Mul
}
Some(Token::Slash) => {
let _ = lexer.next_token();
ArithOp::Div
}
_ => return Ok(left),
};
let right = Self::parse_primary_expr(lexer)?;
left = Expr::Arithmetic {
left: Box::new(left),
op,
right: Box::new(right),
};
}
}
fn parse_return_command_body(lexer: &mut S2sLexer, name: String) -> S2sResult<Expr> {
let _ = lexer.next_token();
let mut args = Vec::new();
loop {
Self::skip_comments(lexer);
match lexer.peek() {
Some((Token::RParen, _)) => break,
Some((_, _)) => {
args.push(Self::parse_expr(lexer)?);
Self::skip_comments(lexer);
if let Some((Token::Comma, _)) = lexer.peek() {
let _ = lexer.next_token();
}
}
None => {
return Err(Self::error(
lexer,
0,
"unterminated argument list in return command",
));
}
}
}
let _ = lexer.next_token();
Ok(Expr::CommandCall { name, args })
}
fn parse_condition_inner(lexer: &mut S2sLexer) -> S2sResult<Expr> {
let left = Self::parse_condition_atom(lexer)?;
let left = Self::parse_infix_arithmetic(lexer, left)?;
Self::skip_comments(lexer);
let op = match lexer.peek() {
Some((Token::Eq, _)) => {
let _ = lexer.next_token();
"=="
}
Some((Token::Assign, _)) => {
let _ = lexer.next_token();
"=="
}
Some((Token::Ne, _)) => {
let _ = lexer.next_token();
"!="
}
Some((Token::Lt, _)) => {
let _ = lexer.next_token();
"<"
}
Some((Token::Gt, _)) => {
let _ = lexer.next_token();
">"
}
Some((Token::Le, _)) => {
let _ = lexer.next_token();
"<="
}
Some((Token::Ge, _)) => {
let _ = lexer.next_token();
">="
}
_ => return Ok(left),
};
let right = Self::parse_condition_atom(lexer)?;
let right = Self::parse_infix_arithmetic(lexer, right)?;
Ok(Expr::Condition {
left: Box::new(left),
op: op.to_string(),
right: Box::new(right),
})
}
fn parse_condition_atom(lexer: &mut S2sLexer) -> S2sResult<Expr> {
Self::skip_comments(lexer);
let peeked = lexer.peek().cloned();
match peeked {
Some((Token::LParen, _)) => {
let _ = lexer.next_token();
let expr = Self::parse_condition_inner(lexer)?;
Self::expect_token(lexer, Token::RParen)?;
Self::maybe_logical(lexer, expr)
}
Some((Token::String, _))
| Some((Token::Number, _))
| Some((Token::Variable, _))
| Some((Token::Ident, _))
| Some((Token::Plus, _))
| Some((Token::Minus, _))
| Some((Token::At, _)) => {
let expr = Self::parse_expr(lexer)?;
Self::maybe_logical(lexer, expr)
}
Some((tok, _)) => {
let (line, col) = Self::peek_linecol(lexer);
Err(S2sError::Parse {
line,
column: col,
message: format!(
"unexpected token '{}' in condition, expected value or '('",
tok.name()
),
})
}
None => Err(Self::error(lexer, 0, "unexpected end of input in condition")),
}
}
fn maybe_logical(lexer: &mut S2sLexer, left: Expr) -> S2sResult<Expr> {
Self::skip_comments(lexer);
let op = match lexer.peek() {
Some((Token::And, _)) | Some((Token::AndKw, _)) => {
let _ = lexer.next_token();
LogicalOp::And
}
Some((Token::Or, _)) | Some((Token::OrKw, _)) => {
let _ = lexer.next_token();
LogicalOp::Or
}
Some((Token::Xor, _)) => {
let _ = lexer.next_token();
LogicalOp::Xor
}
_ => return Ok(left),
};
let right = Self::parse_condition_atom(lexer)?;
Self::maybe_logical(
lexer,
Expr::Logical {
left: Box::new(left),
op,
right: Box::new(right),
},
)
}
pub(super) fn parse_paren_condition(lexer: &mut S2sLexer) -> S2sResult<Expr> {
Self::expect_token(lexer, Token::LParen)?;
let expr = Self::parse_condition_inner(lexer)?;
Self::expect_token(lexer, Token::RParen)?;
Self::maybe_logical(lexer, expr)
}
pub(super) fn parse_arg_as_string(lexer: &mut S2sLexer) -> S2sResult<String> {
let (tok, span) = match lexer.peek() {
Some(t) => t.clone(),
None => {
return Err(Self::error(lexer, 0, "expected argument"));
}
};
match tok {
Token::String => {
let _ = lexer.next_token();
let raw = lexer.slice(&span);
Ok(raw[1..raw.len() - 1].to_string())
}
Token::Number => {
let _ = lexer.next_token();
Ok(lexer.slice(&span).to_string())
}
Token::Ident => {
let _ = lexer.next_token();
Ok(lexer.slice(&span).to_string())
}
Token::Variable => {
let _ = lexer.next_token();
let text = lexer.slice(&span);
Ok(text.strip_prefix('$').unwrap_or(text).to_string())
}
_ => {
let (line, col) = Self::peek_linecol(lexer);
Err(S2sError::Parse {
line,
column: col,
message: format!("expected argument, got '{}'", tok.name()),
})
}
}
}
}