parser.cpp

#include "parser.h"
#include <stdexcept>
#include <sstream>

namespace AR437 {

Parser::Parser(const std::vector<Token>& tokens) : tokens(tokens), current(0) {}

std::unique_ptr<Program> Parser::parse() {
    try {
        return program();
    } catch (const ParseError& error) {
        throw;
    }
}

Token& Parser::peek() {
    return tokens[current];
}

Token& Parser::previous() {
    return tokens[current - 1];
}

bool Parser::isAtEnd() {
    return peek().type == TokenType::EOF_TOK;
}

Token Parser::advance() {
    if (!isAtEnd()) current++;
    return previous();
}

bool Parser::check(TokenType type) {
    if (isAtEnd()) return false;
    return peek().type == type;
}

bool Parser::match(const std::vector<TokenType>& types) {
    for (TokenType type : types) {
        if (check(type)) {
            advance();
            return true;
        }
    }
    return false;
}

void Parser::consume(TokenType type, const std::string& message) {
    if (check(type)) {
        advance();
        return;
    }
    
    Token token = peek();
    throw ParseError(message + " at line " + std::to_string(token.line) + 
                    ", column " + std::to_string(token.column), token.line, token.column);
}

void Parser::synchronize() {
    advance();
    
    while (!isAtEnd()) {
        if (previous().type == TokenType::SEMICOLON) return;
        
        switch (peek().type) {
            case TokenType::FUNC:
            case TokenType::LET:
            case TokenType::IF:
            case TokenType::WHILE:
            case TokenType::DISPLAY:
            case TokenType::READ:
            case TokenType::RETURN:
                return;
            default:
                break;
        }
        
        advance();
    }
}

std::unique_ptr<Program> Parser::program() {
    auto prog = std::make_unique<Program>();
    
    while (!isAtEnd()) {
        // Skip newlines at the top level
        if (match({TokenType::NEWLINE})) {
            continue;
        }
        
        try {
            auto decl = declaration();
            if (decl) {
                prog->statements.push_back(std::move(decl));
            }
        } catch (const ParseError& error) {
            synchronize();
            throw;
        }
    }
    
    return prog;
}

std::unique_ptr<Statement> Parser::declaration() {
    if (match({TokenType::FUNC})) return funcDeclaration();
    if (match({TokenType::LET})) return varDeclaration();
    return statement();
}

std::unique_ptr<Statement> Parser::varDeclaration() {
    consume(TokenType::IDENTIFIER, "Expected variable name");
    std::string name = previous().value;
    
    std::unique_ptr<Expression> initializer = nullptr;
    if (match({TokenType::ASSIGN})) {
        initializer = expression();
    }
    
    consume(TokenType::SEMICOLON, "Expected ';' after variable declaration");
    return std::make_unique<VariableDeclaration>(name, std::move(initializer));
}

std::unique_ptr<Statement> Parser::funcDeclaration() {
    consume(TokenType::IDENTIFIER, "Expected function name");
    std::string name = previous().value;
    
    consume(TokenType::LPAREN, "Expected '(' after function name");
    
    std::vector<std::string> parameters;
    if (!check(TokenType::RPAREN)) {
        do {
            consume(TokenType::IDENTIFIER, "Expected parameter name");
            parameters.push_back(previous().value);
        } while (match({TokenType::COMMA}));
    }
    
    consume(TokenType::RPAREN, "Expected ')' after parameters");
    
    auto body = blockStatement();
    return std::make_unique<FunctionDeclaration>(name, parameters, std::move(body));
}

std::unique_ptr<Statement> Parser::statement() {
    if (match({TokenType::DISPLAY})) return displayStatement();
    if (match({TokenType::READ})) return readStatement();
    if (match({TokenType::RETURN})) return returnStatement();
    if (match({TokenType::IF})) return ifStatement();
    if (match({TokenType::WHILE})) return whileStatement();
    if (match({TokenType::LBRACE})) return blockStatement();
    
    return expressionStatement();
}

std::unique_ptr<Statement> Parser::displayStatement() {
    auto expr = expression();
    consume(TokenType::SEMICOLON, "Expected ';' after display statement");
    return std::make_unique<DisplayStatement>(std::move(expr));
}

std::unique_ptr<Statement> Parser::readStatement() {
    consume(TokenType::IDENTIFIER, "Expected variable name after 'read'");
    std::string varName = previous().value;
    consume(TokenType::SEMICOLON, "Expected ';' after read statement");
    return std::make_unique<ReadStatement>(varName);
}

std::unique_ptr<Statement> Parser::returnStatement() {
    std::unique_ptr<Expression> value = nullptr;
    if (!check(TokenType::SEMICOLON)) {
        value = expression();
    }
    
    consume(TokenType::SEMICOLON, "Expected ';' after return statement");
    return std::make_unique<ReturnStatement>(std::move(value));
}

std::unique_ptr<Statement> Parser::ifStatement() {
    consume(TokenType::LPAREN, "Expected '(' after 'if'");
    auto condition = expression();
    consume(TokenType::RPAREN, "Expected ')' after if condition");
    
    auto thenBranch = statement();
    std::unique_ptr<Statement> elseBranch = nullptr;
    
    if (match({TokenType::ELSE})) {
        elseBranch = statement();
    }
    
    return std::make_unique<IfStatement>(std::move(condition), std::move(thenBranch), std::move(elseBranch));
}

std::unique_ptr<Statement> Parser::whileStatement() {
    consume(TokenType::LPAREN, "Expected '(' after 'while'");
    auto condition = expression();
    consume(TokenType::RPAREN, "Expected ')' after while condition");
    
    auto body = statement();
    return std::make_unique<WhileStatement>(std::move(condition), std::move(body));
}

std::unique_ptr<Statement> Parser::expressionStatement() {
    auto expr = expression();
    consume(TokenType::SEMICOLON, "Expected ';' after expression");
    return std::make_unique<ExpressionStatement>(std::move(expr));
}

std::unique_ptr<Block> Parser::blockStatement() {
    auto block = std::make_unique<Block>();
    
    while (!check(TokenType::RBRACE) && !isAtEnd()) {
        // Skip newlines inside blocks
        if (match({TokenType::NEWLINE})) {
            continue;
        }
        
        auto stmt = declaration();
        if (stmt) {
            block->statements.push_back(std::move(stmt));
        }
    }
    
    if (!isAtEnd()) {
        consume(TokenType::RBRACE, "Expected '}' after block");
    }
    return block;
}

std::unique_ptr<Expression> Parser::expression() {
    return assignment();
}

std::unique_ptr<Expression> Parser::assignment() {
    auto expr = logicalOr();
    
    if (match({TokenType::ASSIGN})) {
        auto value = assignment();
        
        // Check if left side is an identifier
        auto identifier = dynamic_cast<Identifier*>(expr.get());
        if (identifier) {
            std::string name = identifier->name;
            expr.release(); // Release ownership since we're using the name
            return std::make_unique<Assignment>(name, std::move(value));
        }
        
        throw ParseError("Invalid assignment target");
    }
    
    return expr;
}

std::unique_ptr<Expression> Parser::logicalOr() {
    auto expr = logicalAnd();
    
    while (match({TokenType::OR})) {
        TokenType operator_ = previous().type;
        auto right = logicalAnd();
        expr = std::make_unique<BinaryOperation>(std::move(expr), operator_, std::move(right));
    }
    
    return expr;
}

std::unique_ptr<Expression> Parser::logicalAnd() {
    auto expr = equality();
    
    while (match({TokenType::AND})) {
        TokenType operator_ = previous().type;
        auto right = equality();
        expr = std::make_unique<BinaryOperation>(std::move(expr), operator_, std::move(right));
    }
    
    return expr;
}

std::unique_ptr<Expression> Parser::equality() {
    auto expr = comparison();
    
    while (match({TokenType::NOT_EQUAL, TokenType::EQUAL})) {
        TokenType operator_ = previous().type;
        auto right = comparison();
        expr = std::make_unique<BinaryOperation>(std::move(expr), operator_, std::move(right));
    }
    
    return expr;
}

std::unique_ptr<Expression> Parser::comparison() {
    auto expr = term();
    
    while (match({TokenType::GREATER, TokenType::GREATER_EQUAL, TokenType::LESS, TokenType::LESS_EQUAL})) {
        TokenType operator_ = previous().type;
        auto right = term();
        expr = std::make_unique<BinaryOperation>(std::move(expr), operator_, std::move(right));
    }
    
    return expr;
}

std::unique_ptr<Expression> Parser::term() {
    auto expr = factor();
    
    while (match({TokenType::MINUS, TokenType::PLUS})) {
        TokenType operator_ = previous().type;
        auto right = factor();
        expr = std::make_unique<BinaryOperation>(std::move(expr), operator_, std::move(right));
    }
    
    return expr;
}

std::unique_ptr<Expression> Parser::factor() {
    auto expr = unary();
    
    while (match({TokenType::DIVIDE, TokenType::MULTIPLY, TokenType::MODULO})) {
        TokenType operator_ = previous().type;
        auto right = unary();
        expr = std::make_unique<BinaryOperation>(std::move(expr), operator_, std::move(right));
    }
    
    return expr;
}

std::unique_ptr<Expression> Parser::unary() {
    if (match({TokenType::NOT, TokenType::MINUS})) {
        TokenType operator_ = previous().type;
        auto right = unary();
        return std::make_unique<UnaryOperation>(operator_, std::move(right));
    }
    
    return call();
}

std::unique_ptr<Expression> Parser::call() {
    auto expr = primary();
    
    while (true) {
        if (match({TokenType::LPAREN})) {
            // Function call
            auto identifier = dynamic_cast<Identifier*>(expr.get());
            if (!identifier) {
                throw ParseError("Can only call functions");
            }
            
            std::string name = identifier->name;
            expr.release(); // Release ownership
            
            auto call = std::make_unique<FunctionCall>(name);
            
            if (!check(TokenType::RPAREN)) {
                do {
                    call->arguments.push_back(expression());
                } while (match({TokenType::COMMA}));
            }
            
            consume(TokenType::RPAREN, "Expected ')' after arguments");
            expr = std::move(call);
        } else {
            break;
        }
    }
    
    return expr;
}

std::unique_ptr<Expression> Parser::primary() {
    if (match({TokenType::TRUE})) {
        return std::make_unique<BooleanLiteral>(true);
    }
    
    if (match({TokenType::FALSE})) {
        return std::make_unique<BooleanLiteral>(false);
    }
    
    if (match({TokenType::NULL_TOK})) {
        return std::make_unique<NullLiteral>();
    }
    
    if (match({TokenType::NUMBER})) {
        double value = std::stod(previous().value);
        return std::make_unique<NumberLiteral>(value);
    }
    
    if (match({TokenType::STRING})) {
        return std::make_unique<StringLiteral>(previous().value);
    }
    
    if (match({TokenType::IDENTIFIER})) {
        return std::make_unique<Identifier>(previous().value);
    }
    
    if (match({TokenType::LPAREN})) {
        auto expr = expression();
        consume(TokenType::RPAREN, "Expected ')' after expression");
        return expr;
    }
    
    throw ParseError("Expected expression at line " + std::to_string(peek().line) + 
                    ", column " + std::to_string(peek().column));
}

} // namespace AR437