s2s2lua 0.1.1

Transpile Stranded II .s2s scripts to Lua for OpenStranded
Documentation
// s2s2lua – transpile Stranded II .s2s scripts to Lua for OpenStranded
// Copyright (C) 2025  s2s2lua contributors
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

use super::*;

impl S2sParser {
    // ── Statement ─────────────────────────────────────────

    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()),
                })
            }
        }
    }

    // ── Event handler ─────────────────────────────────────

    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,
        })
    }

    // ── If / elseif / else ────────────────────────────────

    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,
        })
    }

    // ── Loop ──────────────────────────────────────────────

    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 })
        }
    }

    // ── Commands ──────────────────────────────────────────

    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,
        })
    }

    // ── Simple statement parsers ──────────────────────────

    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)
    }
}