s2s2lua 0.1.0

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 {
    // ── Argument / expression parsing ─────────────────────

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

    // ── Condition parsing ─────────────────────────────────

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

    /// Parse an argument as a plain string value.
    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()),
                })
            }
        }
    }
}