use super::*;
impl S2sParser {
pub(super) fn parse_statement(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let (token, span) = match lexer.peek() {
Some(t) => t.clone(),
None => return Err(Self::error(lexer, 0, "unexpected end of input")),
};
match token {
Token::LineComment => {
let _ = lexer.next_token();
let text = lexer.slice(&span);
Ok(Stmt::Comment(text.to_string()))
}
Token::BlockComment => {
let _ = lexer.next_token();
let text = lexer.slice(&span);
Ok(Stmt::Comment(text.to_string()))
}
Token::On => Self::parse_event_handler(lexer),
Token::If => Self::parse_if(lexer),
Token::Loop => Self::parse_loop(lexer),
Token::Exit => Self::parse_exit_stmt(lexer),
Token::Skip => Self::parse_skip_stmt(lexer),
Token::SkipEvent => Self::parse_skipevent_stmt(lexer),
Token::At => Self::parse_suppressed_command(lexer),
Token::Variable => Self::parse_assignment_or_command(lexer),
Token::Ident => Self::parse_command_or_return(lexer),
_ => {
let (line, col) = Self::peek_linecol(lexer);
Err(S2sError::Parse {
line,
column: col,
message: format!("unexpected token '{}'", token.name()),
})
}
}
}
fn parse_event_handler(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let _ = lexer.next_token();
Self::expect_token(lexer, Token::Colon)?;
let (_, span) = Self::expect_token(lexer, Token::Ident)?;
let event_name = lexer.slice(&span).to_string();
Self::expect_token(lexer, Token::LBrace)?;
let body = Self::parse_block(lexer)?;
Ok(Stmt::EventHandler {
event: event_name,
body,
})
}
fn parse_if(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let _ = lexer.next_token();
let condition = Self::parse_paren_condition(lexer)?;
Self::expect_token(lexer, Token::LBrace)?;
let then_body = Self::parse_block(lexer)?;
let mut else_ifs = Vec::new();
Self::skip_comments(lexer);
while let Some((Token::ElseIf, _)) = lexer.peek() {
let _ = lexer.next_token();
let cond = Self::parse_paren_condition(lexer)?;
Self::expect_token(lexer, Token::LBrace)?;
let body = Self::parse_block(lexer)?;
else_ifs.push(ElseIfClause {
condition: cond,
body,
});
Self::skip_comments(lexer);
}
let mut else_body = Vec::new();
Self::skip_comments(lexer);
if let Some((Token::Else, _)) = lexer.peek() {
let _ = lexer.next_token();
Self::expect_token(lexer, Token::LBrace)?;
else_body = Self::parse_block(lexer)?;
}
Ok(Stmt::If {
condition,
then_body,
else_ifs,
else_body,
})
}
fn parse_loop(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let _ = lexer.next_token();
let next_tok = lexer.peek().map(|(t, _)| t.clone());
if next_tok == Some(Token::LParen) {
let _ = lexer.next_token();
let (_, class_span) = Self::expect_token(lexer, Token::String)?;
let raw_class = lexer.slice(&class_span);
let class_name = &raw_class[1..raw_class.len() - 1];
Self::expect_token(lexer, Token::Comma)?;
let arg = Self::parse_arg_as_string(lexer)?;
Self::expect_token(lexer, Token::RParen)?;
Self::expect_token(lexer, Token::LBrace)?;
let body = Self::parse_block(lexer)?;
Ok(Stmt::Loop {
mode: class_name.to_string(),
arg,
body,
})
} else {
let (_, mode_span) = Self::expect_token(lexer, Token::Ident)?;
let mode = lexer.slice(&mode_span).to_string();
Self::expect_token(lexer, Token::Comma)?;
let arg = Self::parse_arg_as_string(lexer)?;
Self::expect_token(lexer, Token::LBrace)?;
let body = Self::parse_block(lexer)?;
Ok(Stmt::Loop { mode, arg, body })
}
}
fn parse_suppressed_command(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let _ = lexer.next_token();
let (_, name_span) = Self::expect_token(lexer, Token::Ident)?;
let name = lexer.slice(&name_span).to_string();
let args = Self::parse_args(lexer)?;
Self::expect_semicolon(lexer)?;
Ok(Stmt::Command {
name,
args,
suppress: true,
})
}
fn parse_assignment_or_command(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let (_, var_span) = lexer.next_token().unwrap();
let var_name = lexer.slice(&var_span).to_string();
let var_name = var_name.strip_prefix('$').unwrap_or(&var_name).to_string();
let next = lexer.peek().cloned();
match next {
Some((Token::Assign, _)) => {
let _ = lexer.next_token();
let value = Self::parse_expr(lexer)?;
Self::expect_semicolon(lexer)?;
Ok(Stmt::Assign {
var: var_name,
value: Box::new(value),
})
}
Some((Token::AddAssign, _)) => {
let _ = lexer.next_token();
let value = Self::parse_expr(lexer)?;
Self::expect_semicolon(lexer)?;
Ok(Stmt::CompoundAssign {
var: var_name,
op: AssignOp::Add,
value: Box::new(value),
})
}
Some((Token::SubAssign, _)) => {
let _ = lexer.next_token();
let value = Self::parse_expr(lexer)?;
Self::expect_semicolon(lexer)?;
Ok(Stmt::CompoundAssign {
var: var_name,
op: AssignOp::Sub,
value: Box::new(value),
})
}
Some((Token::Inc, _)) => {
let _ = lexer.next_token();
Self::expect_semicolon(lexer)?;
Ok(Stmt::IncDec {
var: var_name,
inc: true,
})
}
Some((Token::Dec, _)) => {
let _ = lexer.next_token();
Self::expect_semicolon(lexer)?;
Ok(Stmt::IncDec {
var: var_name,
inc: false,
})
}
Some((Token::Semicolon, _)) => {
let _ = lexer.next_token();
Ok(Stmt::Command {
name: String::new(),
args: vec![Expr::Variable(var_name)],
suppress: false,
})
}
Some((tok, _)) => {
let (line, col) = Self::peek_linecol(lexer);
Err(S2sError::Parse {
line,
column: col,
message: format!(
"unexpected token '{}' after variable '${}'",
tok.name(),
var_name
),
})
}
None => Err(Self::error(lexer, 0, "unexpected end of input after variable")),
}
}
fn parse_command_or_return(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let (_, name_span) = lexer.next_token().unwrap();
let name = lexer.slice(&name_span).to_string();
let args = Self::parse_args(lexer)?;
Self::expect_semicolon(lexer)?;
Ok(Stmt::Command {
name,
args,
suppress: false,
})
}
fn parse_exit_stmt(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let _ = lexer.next_token();
Self::expect_semicolon(lexer)?;
Ok(Stmt::Exit)
}
fn parse_skip_stmt(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let _ = lexer.next_token();
Self::expect_semicolon(lexer)?;
Ok(Stmt::Skip)
}
fn parse_skipevent_stmt(lexer: &mut S2sLexer) -> S2sResult<Stmt> {
let _ = lexer.next_token();
Self::expect_semicolon(lexer)?;
Ok(Stmt::SkipEvent)
}
}