parser.cpp

#include "parser.h"
#include <iostream>

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

Token Parser::peek(int offset) const {
    if (current + offset >= tokens.size()) {
        return Token(TokenType::SON, "", 0, 0);
    }
    return tokens[current + offset];
}

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

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

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

bool Parser::match(TokenType type) {
    if (check(type)) {
        advance();
        return true;
    }
    return false;
}

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

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

Token Parser::consume(TokenType type, const std::string& message) {
    if (check(type)) {
        return advance();
    }
    
    throw std::runtime_error(message + " Satır: " + std::to_string(peek().line) + 
                             ", Sütun: " + std::to_string(peek().column));
}

std::unique_ptr<ProgramNode> Parser::parse() {
    auto program = std::make_unique<ProgramNode>();
    
    while (!isAtEnd()) {
        try {
            program->add(statement());
        } catch (const std::exception& e) {
            // Hata durumunda senkronize et ve devam et
            std::cerr << e.what() << std::endl;
            
            // Bir sonraki ifadeye kadar atla
            while (!isAtEnd() && previous().type != TokenType::SATIR_SONU) {
                advance();
            }
        }
    }
    
    return program;
}

std::unique_ptr<ASTNode> Parser::statement() {
    if (match(TokenType::EGER)) {
        return ifStatement();
    }
    
    if (match(TokenType::DONGU)) {
        return loopStatement();
    }
    
    if (match(TokenType::FONKSIYON)) {
        return functionStatement();
    }
    
    if (match(TokenType::DONDUR)) {
        return returnStatement();
    }
    
    if (match(TokenType::YAZ)) {
        return printStatement();
    }
    
    if (match(TokenType::SOL_SUSLU)) {
        return block();
    }
    
    return expressionStatement();
}

std::unique_ptr<BlockNode> Parser::block() {
    auto block = std::make_unique<BlockNode>();
    
    while (!check(TokenType::SAG_SUSLU) && !isAtEnd()) {
        block->add(statement());
    }
    
    consume(TokenType::SAG_SUSLU, "Blok sonunda '}' bekleniyor.");
    
    return block;
}

std::unique_ptr<ASTNode> Parser::expressionStatement() {
    auto expr = expression();
    
    // Noktalı virgül opsiyonel, satır sonu veya süslü parantez de ifadeyi sonlandırabilir
    if (match(TokenType::SATIR_SONU) || check(TokenType::SAG_SUSLU)) {
        // İfade sonlandı
    }
    
    return std::make_unique<ExpressionStatementNode>(std::move(expr));
}

std::unique_ptr<ASTNode> Parser::ifStatement() {
    consume(TokenType::SOL_PARANTEZ, "'eğer' ifadesinden sonra '(' bekleniyor.");
    auto condition = expression();
    consume(TokenType::SAG_PARANTEZ, "Koşul ifadesinden sonra ')' bekleniyor.");
    
    consume(TokenType::SOL_SUSLU, "Koşul bloğu için '{' bekleniyor.");
    auto thenBranch = block();
    
    std::unique_ptr<BlockNode> elseBranch = nullptr;
    if (match(TokenType::DEGILSE)) {
        consume(TokenType::SOL_SUSLU, "'değilse' bloğu için '{' bekleniyor.");
        elseBranch = block();
    }
    
    return std::make_unique<IfNode>(std::move(condition), std::move(thenBranch), std::move(elseBranch));
}

std::unique_ptr<ASTNode> Parser::loopStatement() {
    consume(TokenType::SOL_PARANTEZ, "'döngü' ifadesinden sonra '(' bekleniyor.");
    auto condition = expression();
    consume(TokenType::SAG_PARANTEZ, "Döngü koşulundan sonra ')' bekleniyor.");
    
    consume(TokenType::SOL_SUSLU, "Döngü bloğu için '{' bekleniyor.");
    auto body = block();
    
    return std::make_unique<LoopNode>(std::move(condition), std::move(body));
}

std::unique_ptr<ASTNode> Parser::functionStatement() {
    Token name = consume(TokenType::TANIMLAYICI, "Fonksiyon adı bekleniyor.");
    
    consume(TokenType::SOL_PARANTEZ, "Fonksiyon adından sonra '(' bekleniyor.");
    
    auto function = std::make_unique<FunctionNode>(name.value, nullptr);
    
    // Parametreler
    if (!check(TokenType::SAG_PARANTEZ)) {
        do {
            Token param = consume(TokenType::TANIMLAYICI, "Parametre adı bekleniyor.");
            function->addParameter(param.value);
        } while (match(TokenType::VIRGUL));
    }
    
    consume(TokenType::SAG_PARANTEZ, "Parametre listesinden sonra ')' bekleniyor.");
    
    consume(TokenType::SOL_SUSLU, "Fonksiyon gövdesi için '{' bekleniyor.");
    function->body = block();
    
    return function;
}

std::unique_ptr<ASTNode> Parser::returnStatement() {
    if (check(TokenType::SATIR_SONU) || check(TokenType::SAG_SUSLU)) {
        return std::make_unique<ReturnNode>();
    }
    
    auto value = expression();
    
    return std::make_unique<ReturnNode>(std::move(value));
}

std::unique_ptr<ASTNode> Parser::printStatement() {
    auto value = expression();
    
    return std::make_unique<PrintNode>(std::move(value));
}

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

std::unique_ptr<ExpressionNode> Parser::assignment() {
    auto expr = logicalOr();
    
    if (match(TokenType::ESITTIR)) {
        auto value = assignment();
        
        if (auto* identifier = dynamic_cast<IdentifierNode*>(expr.get())) {
            return std::make_unique<AssignmentNode>(identifier->name, std::move(value));
        }
        
        throw std::runtime_error("Geçersiz atama hedefi.");
    }
    
    return expr;
}

std::unique_ptr<ExpressionNode> Parser::logicalOr() {
    auto expr = logicalAnd();
    
    while (match(TokenType::VEYA)) {
        auto op = previous().type;
        auto right = logicalAnd();
        expr = std::make_unique<BinaryOpNode>(op, std::move(expr), std::move(right));
    }
    
    return expr;
}

std::unique_ptr<ExpressionNode> Parser::logicalAnd() {
    auto expr = equality();
    
    while (match(TokenType::VE)) {
        auto op = previous().type;
        auto right = equality();
        expr = std::make_unique<BinaryOpNode>(op, std::move(expr), std::move(right));
    }
    
    return expr;
}

std::unique_ptr<ExpressionNode> Parser::equality() {
    auto expr = comparison();
    
    while (match({TokenType::ESIT, TokenType::ESIT_DEGIL})) {
        auto op = previous().type;
        auto right = comparison();
        expr = std::make_unique<BinaryOpNode>(op, std::move(expr), std::move(right));
    }
    
    return expr;
}

std::unique_ptr<ExpressionNode> Parser::comparison() {
    auto expr = term();
    
    while (match({TokenType::KUCUK, TokenType::KUCUK_ESIT, TokenType::BUYUK, TokenType::BUYUK_ESIT})) {
        auto op = previous().type;
        auto right = term();
        expr = std::make_unique<BinaryOpNode>(op, std::move(expr), std::move(right));
    }
    
    return expr;
}

std::unique_ptr<ExpressionNode> Parser::term() {
    auto expr = factor();
    
    while (match({TokenType::ARTI, TokenType::EKSI})) {
        auto op = previous().type;
        auto right = factor();
        expr = std::make_unique<BinaryOpNode>(op, std::move(expr), std::move(right));
    }
    
    return expr;
}

std::unique_ptr<ExpressionNode> Parser::factor() {
    auto expr = unary();
    
    while (match({TokenType::CARPI, TokenType::BOLU, TokenType::MOD})) {
        auto op = previous().type;
        auto right = unary();
        expr = std::make_unique<BinaryOpNode>(op, std::move(expr), std::move(right));
    }
    
    return expr;
}

std::unique_ptr<ExpressionNode> Parser::unary() {
    if (match({TokenType::EKSI, TokenType::DEGIL})) {
        auto op = previous().type;
        auto right = unary();
        return std::make_unique<UnaryOpNode>(op, std::move(right));
    }
    
    if (match(TokenType::TIP)) {
        consume(TokenType::SOL_PARANTEZ, "'tip' ifadesinden sonra '(' bekleniyor.");
        Token typeToken = consume(TokenType::TANIMLAYICI, "Tip adı bekleniyor.");
        consume(TokenType::VIRGUL, "Tip adından sonra ',' bekleniyor.");
        auto expr = expression();
        consume(TokenType::SAG_PARANTEZ, "Tip dönüşümünden sonra ')' bekleniyor.");
        
        return std::make_unique<CastNode>(typeToken.value, std::move(expr));
    }
    
    return call();
}

std::unique_ptr<ExpressionNode> Parser::call() {
    auto expr = primary();
    
    while (true) {
        if (match(TokenType::SOL_PARANTEZ)) {
            expr = finishCall(std::move(expr));
        } else {
            break;
        }
    }
    
    return expr;
}

std::unique_ptr<ExpressionNode> Parser::finishCall(std::unique_ptr<ExpressionNode> callee) {
    std::vector<std::unique_ptr<ExpressionNode>> arguments;
    
    if (!check(TokenType::SAG_PARANTEZ)) {
        do {
            arguments.push_back(expression());
        } while (match(TokenType::VIRGUL));
    }
    
    consume(TokenType::SAG_PARANTEZ, "Fonksiyon çağrısından sonra ')' bekleniyor.");
    
    auto* identifier = dynamic_cast<IdentifierNode*>(callee.get());
    if (!identifier) {
        throw std::runtime_error("Fonksiyon çağrısı için geçersiz ifade.");
    }
    
    auto call = std::make_unique<FunctionCallNode>(identifier->name);
    for (auto& arg : arguments) {
        call->addArgument(std::move(arg));
    }
    
    return call;
}

std::unique_ptr<ExpressionNode> Parser::primary() {
    if (match(TokenType::DOGRU)) {
        return std::make_unique<BooleanNode>(true);
    }
    
    if (match(TokenType::YANLIS)) {
        return std::make_unique<BooleanNode>(false);
    }
    
    if (match(TokenType::SAYI)) {
        return std::make_unique<NumberNode>(std::stod(previous().value));
    }
    
    if (match(TokenType::METIN)) {
        return std::make_unique<StringNode>(previous().value);
    }
    
    if (match(TokenType::TANIMLAYICI)) {
        return std::make_unique<IdentifierNode>(previous().value);
    }
    
    if (match(TokenType::SOL_PARANTEZ)) {
        auto expr = expression();
        consume(TokenType::SAG_PARANTEZ, "İfadeden sonra ')' bekleniyor.");
        return expr;
    }
    
    throw std::runtime_error("İfade bekleniyor.");
}