parser.h

#ifndef PARSER_H
#define PARSER_H

#include "token.h"
#include "lexer.h"
#include "ast.h"
#include <vector>
#include <memory>

namespace AR437 {

class ParseError : public std::exception {
private:
    std::string message;
    int line;
    int column;

public:
    ParseError(const std::string& msg, int l = 0, int c = 0) 
        : message(msg), line(l), column(c) {}
    
    const char* what() const noexcept override {
        return message.c_str();
    }
    
    int getLine() const { return line; }
    int getColumn() const { return column; }
};

class Parser {
private:
    std::vector<Token> tokens;
    size_t current;

    Token& peek();
    Token& previous();
    bool isAtEnd();
    Token advance();
    bool check(TokenType type);
    bool match(const std::vector<TokenType>& types);
    void consume(TokenType type, const std::string& message);
    void synchronize();

    // Grammar rules
    std::unique_ptr<Program> program();
    std::unique_ptr<Statement> declaration();
    std::unique_ptr<Statement> varDeclaration();
    std::unique_ptr<Statement> funcDeclaration();
    std::unique_ptr<Statement> statement();
    std::unique_ptr<Statement> displayStatement();
    std::unique_ptr<Statement> readStatement();
    std::unique_ptr<Statement> returnStatement();
    std::unique_ptr<Statement> ifStatement();
    std::unique_ptr<Statement> whileStatement();
    std::unique_ptr<Statement> expressionStatement();
    std::unique_ptr<Block> blockStatement();
    
    std::unique_ptr<Expression> expression();
    std::unique_ptr<Expression> assignment();
    std::unique_ptr<Expression> logicalOr();
    std::unique_ptr<Expression> logicalAnd();
    std::unique_ptr<Expression> equality();
    std::unique_ptr<Expression> comparison();
    std::unique_ptr<Expression> term();
    std::unique_ptr<Expression> factor();
    std::unique_ptr<Expression> unary();
    std::unique_ptr<Expression> call();
    std::unique_ptr<Expression> primary();

public:
    Parser(const std::vector<Token>& tokens);
    std::unique_ptr<Program> parse();
};

} // namespace AR437

#endif // PARSER_H