Parser.cpp

// ============================================================
// SYNTAX ANALYSIS – Parser.cpp
// ============================================================
// Purpose: SYNTAX ANALYSIS – recursive descent parser.
//          Each grammar rule becomes a parseXxx() method.
//          The parser builds an AST as it recognises structure.
// ============================================================

#include "Parser.h"
#include <sstream>

// Constructor: take ownership of the token list, start at index 0
Parser::Parser(std::vector<Token> tokens)
    : tokens_(std::move(tokens)), pos_(0) {}

// Token stream helpers

// CURRENT() – token at the read cursor
Token& Parser::current() {
    return tokens_[pos_];
}

// PEEK() – look ahead without consuming (default 1 step ahead)
Token& Parser::peek(int offset) {
    int idx = pos_ + offset;
    if (idx >= (int)tokens_.size()) return tokens_.back(); // EOF token
    return tokens_[idx];
}

// CONSUME() – return current token and advance the cursor
Token Parser::consume() {
    Token t = tokens_[pos_];
    if (pos_ < (int)tokens_.size() - 1) pos_++;
    return t;
}

// EXCEPT() – consume a token that MUST be of type t; error otherwise
Token Parser::expect(TokenType t) {
    if (current().type != t) {
        throw error("Expected '" + Token::typeName(t) +
                    "' but got '" + current().lexeme + "'");
    }
    return consume();
}

bool Parser::check(TokenType t) const {
    return tokens_[pos_].type == t;
}

bool Parser::match(TokenType t) {
    if (check(t)) { consume(); return true; }
    return false;
}

bool Parser::isAtEnd() const {
    return tokens_[pos_].type == TokenType::END_OF_FILE;
}

// ERROR() – build a runtime_error with line information
std::runtime_error Parser::error(const std::string& msg) {
    return std::runtime_error("Parse error at line " +
                              std::to_string(current().line) +
                              ": " + msg);
}

// PARSE() – entry point
std::vector<ASTNodePtr> Parser::parse() {
    std::vector<ASTNodePtr> stmts;
    while (!isAtEnd()) {
        stmts.push_back(parseStatement());  // Parse one statement at a time
    }
    return stmts;
}

// PARSESTATEMENT() – dispatch by current token
ASTNodePtr Parser::parseStatement() {
    // Variable declaration starts with 'int' or 'float'
    if (check(TokenType::INT) || check(TokenType::FLOAT))
        return parseVarDecl();

    // if statement
    if (check(TokenType::IF))
        return parseIfStatement();

    // while loop
    if (check(TokenType::WHILE))
        return parseWhileStatement();

    // print built-in
    if (check(TokenType::PRINT))
        return parsePrintStatement();

    // return statement
    if (check(TokenType::RETURN))
        return parseReturnStatement();

    // Block of statements { ... }
    if (check(TokenType::LBRACE)) {
        consume();   // eat '{'
        auto stmts = parseBlock();
        auto block = std::make_unique<BlockNode>();
        block->statements = std::move(stmts);
        return block;
    }

    // Otherwise must be an assignment:  ident = expr;
    return parseAssignment();
}

// PARSEVARDECL() – int x = expr; or float y = expr; 
ASTNodePtr Parser::parseVarDecl() {
    // Consume the type keyword
    Token typeToken = consume();                   // "int" or "float"
    Token nameToken = expect(TokenType::IDENTIFIER); // variable name

    ASTNodePtr init = nullptr;
    if (match(TokenType::EQUAL)) {
        init = parseExpression();   // Optional initialiser
    }
    expect(TokenType::SEMICOLON);  // Mandatory terminator

    return std::make_unique<VarDeclNode>(typeToken.lexeme,
                                         nameToken.lexeme,
                                         std::move(init));
}

// PARSEASSIGNMENT() – ident = expr;
ASTNodePtr Parser::parseAssignment() {
    Token nameToken = expect(TokenType::IDENTIFIER);  // Left-hand side
    expect(TokenType::EQUAL);                         // '='
    ASTNodePtr expr = parseExpression();              // Right-hand side
    expect(TokenType::SEMICOLON);

    return std::make_unique<AssignNode>(nameToken.lexeme, std::move(expr));
}

// PARSEIFSTATEMENT() – if (cond) { } [else { }]
ASTNodePtr Parser::parseIfStatement() {
    consume();                        // eat 'if'
    expect(TokenType::LPAREN);        // '('
    ASTNodePtr cond = parseExpression();
    expect(TokenType::RPAREN);        // ')'
    expect(TokenType::LBRACE);        // '{'
    auto thenBranch = parseBlock();   // then-body

    auto node = std::make_unique<IfNode>();
    node->condition  = std::move(cond);
    node->thenBranch = std::move(thenBranch);

    if (match(TokenType::ELSE)) {     // optional else branch
        expect(TokenType::LBRACE);
        node->elseBranch = parseBlock();
    }

    return node;
}

// PARSEWHILESTATEMENT() – while (cond) { body }
ASTNodePtr Parser::parseWhileStatement() {
    consume();                          // eat 'while'
    expect(TokenType::LPAREN);
    ASTNodePtr cond = parseExpression();
    expect(TokenType::RPAREN);
    expect(TokenType::LBRACE);
    auto body = parseBlock();

    auto node = std::make_unique<WhileNode>();
    node->condition = std::move(cond);
    node->body      = std::move(body);
    return node;
}

// PARSEPRINTSTATEMENT() – print(expr);
ASTNodePtr Parser::parsePrintStatement() {
    consume();                       // eat 'print'
    expect(TokenType::LPAREN);
    ASTNodePtr expr = parseExpression();
    expect(TokenType::RPAREN);
    expect(TokenType::SEMICOLON);
    return std::make_unique<PrintNode>(std::move(expr));
}

// PARSERETURNSTATEMENT() – return expr;
ASTNodePtr Parser::parseReturnStatement() {
    consume();   // eat 'return'
    ASTNodePtr expr = nullptr;
    if (!check(TokenType::SEMICOLON))
        expr = parseExpression();
    expect(TokenType::SEMICOLON);
    return std::make_unique<ReturnNode>(std::move(expr));
}

// PARSEBLOCK() – { stmt* }
std::vector<ASTNodePtr> Parser::parseBlock() {
    std::vector<ASTNodePtr> stmts;
    while (!check(TokenType::RBRACE) && !isAtEnd())
        stmts.push_back(parseStatement());
    expect(TokenType::RBRACE);   // Consume closing '}'
    return stmts;
}

// EXPRESSION PARSING – recursive descent with operator precedence

// PARSEEXPRESSION() – lowest precedence entry point
ASTNodePtr Parser::parseExpression() {
    return parseEquality();
}

// PARSEEQUALITY() – handles == and !=
ASTNodePtr Parser::parseEquality() {
    ASTNodePtr left = parseComparison();

    while (check(TokenType::EQ_EQ) || check(TokenType::NOT_EQ)) {
        Token op = consume();                     // eat == or !=
        ASTNodePtr right = parseComparison();
        left = std::make_unique<BinaryOpNode>(op.lexeme,
                                              std::move(left),
                                              std::move(right));
    }
    return left;
}

// PARSECOMPARISON() – handles <, >, <=, >=
ASTNodePtr Parser::parseComparison() {
    ASTNodePtr left = parseTerm();

    while (check(TokenType::LESS)    || check(TokenType::GREATER) ||
           check(TokenType::LESS_EQ) || check(TokenType::GREATER_EQ)) {
        Token op = consume();
        ASTNodePtr right = parseTerm();
        left = std::make_unique<BinaryOpNode>(op.lexeme,
                                              std::move(left),
                                              std::move(right));
    }
    return left;
}

// PARSETERM() – handles + and -
ASTNodePtr Parser::parseTerm() {
    ASTNodePtr left = parseFactor();

    while (check(TokenType::PLUS) || check(TokenType::MINUS)) {
        Token op = consume();
        ASTNodePtr right = parseFactor();
        left = std::make_unique<BinaryOpNode>(op.lexeme,
                                              std::move(left),
                                              std::move(right));
    }
    return left;
}

// PARSEFACTOR() – handles * and /
ASTNodePtr Parser::parseFactor() {
    ASTNodePtr left = parsePrimary();

    while (check(TokenType::STAR) || check(TokenType::SLASH)) {
        Token op = consume();
        ASTNodePtr right = parsePrimary();
        left = std::make_unique<BinaryOpNode>(op.lexeme,
                                              std::move(left),
                                              std::move(right));
    }
    return left;
}

// PARSEPRIMARY() – handles literals, identifiers, and grouped expressions
ASTNodePtr Parser::parsePrimary() {
    if (check(TokenType::NUMBER)) {
        Token t = consume();
        return std::make_unique<NumberNode>(std::stod(t.lexeme));
    }

    if (check(TokenType::STRING_LIT)) {
        Token t = consume();
        return std::make_unique<StringNode>(t.lexeme);
    }

    if (check(TokenType::IDENTIFIER)) {
        Token t = consume();
        return std::make_unique<IdentifierNode>(t.lexeme);
    }

    if (match(TokenType::LPAREN)) {
        ASTNodePtr expr = parseExpression();   // Grouped expression
        expect(TokenType::RPAREN);
        return expr;
    }

    throw error("Unexpected token '" + current().lexeme + "'");
}

// example :
// The rest of the parseXxx() methods (parseVarDecl, parseIfStatement, etc.) are defined above.
// "int x = 45;"
// [INT,"int",1] [IDENTIFIER,"x",1] [EQUAL,"=",1] [NUMBER,"45",1] [SEMICOLON,";",1] [EOF,"",1]
// The parser will consume these tokens and build an AST representing the variable declaration of 'x' with an initial value of 45.