lexer.cpp

#include "lexer.h"
#include <cctype>
#include <unordered_map>

Lexer::Lexer(const std::string& source) : src(source), i(0), line(1) {}

bool Lexer::isAtEnd() const { return i >= src.size(); }
char Lexer::peek() const { return isAtEnd() ? '\0' : src[i]; }
char Lexer::peekNext() const { return (i + 1 < src.size()) ? src[i + 1] : '\0'; }
char Lexer::advance() { return isAtEnd() ? '\0' : src[i++]; }

void Lexer::skipSpacesAndComments() {
    while (!isAtEnd()) {
        char c = peek();
        if (c == ' ' || c == '\t' || c == '\r') { advance(); continue; }
        if (c == '\n') { advance(); line++; continue; }
        if (c == '/' && peekNext() == '/') {
            while (!isAtEnd() && peek() != '\n') advance();
            continue;
        }
        break;
    }
}

std::vector<Token> Lexer::tokenize() {
    std::vector<Token> out;
    while (!isAtEnd()) {
        skipSpacesAndComments();
        if (isAtEnd()) break;

        char c = peek();
        if (std::isalpha((unsigned char)c) || c == '_') out.push_back(identOrKeyword());
        else if (std::isdigit((unsigned char)c)) out.push_back(number());
        else if (c == '"') out.push_back(stringLit());
        else if (c == '\'') out.push_back(charLit());
        else out.push_back(opOrPunct());
    }
    out.push_back({TokenType::END, "", line});
    return out;
}

Token Lexer::identOrKeyword() {
    int startLine = line;
    size_t start = i;
    while (!isAtEnd()) {
        char c = peek();
        if (std::isalnum((unsigned char)c) || c == '_') advance();
        else break;
    }
    std::string text = src.substr(start, i - start);

    static const std::unordered_map<std::string, TokenType> kw = {
        {"int", TokenType::KW_INT},
        {"float", TokenType::KW_FLOAT},
        {"bool", TokenType::KW_BOOL},
        {"string", TokenType::KW_STRING},
        {"char", TokenType::KW_CHAR},
        {"fun", TokenType::KW_FUN},
        {"done", TokenType::KW_DONE},
        {"return", TokenType::KW_RETURN},
        {"print", TokenType::KW_PRINT},
        {"true", TokenType::KW_TRUE},
        {"false", TokenType::KW_FALSE},

        // NEW:
        {"while", TokenType::KW_WHILE},
        {"for", TokenType::KW_FOR},

        //else if
        {"if", TokenType::KW_IF},
        {"else", TokenType::KW_ELSE},
        {"do", TokenType::KW_DO},

    };

    auto it = kw.find(text);
    if (it != kw.end()) return {it->second, text, startLine};
    return {TokenType::IDENT, text, startLine};
}

Token Lexer::number() {
    int startLine = line;
    size_t start = i;
    bool dot = false;
    while (!isAtEnd()) {
        char c = peek();
        if (std::isdigit((unsigned char)c)) advance();
        else if (c == '.' && !dot && std::isdigit((unsigned char)peekNext())) { dot = true; advance(); }
        else break;
    }
    return {TokenType::NUMBER, src.substr(start, i - start), startLine};
}

Token Lexer::stringLit() {
    int startLine = line;
    advance(); // "
    std::string val;
    while (!isAtEnd() && peek() != '"') {
        char c = advance();
        if (c == '\n') line++;
        val.push_back(c);
    }
    if (isAtEnd()) return {TokenType::INVALID, "Unterminated string", startLine};
    advance(); // "
    return {TokenType::STRING_LIT, val, startLine};
}

Token Lexer::charLit() {
    int startLine = line;
    advance(); // '
    if (isAtEnd()) return {TokenType::INVALID, "Unterminated char", startLine};
    char c = advance();
    if (peek() != '\'') return {TokenType::INVALID, "Invalid char", startLine};
    advance(); // '
    return {TokenType::CHAR_LIT, std::string(1, c), startLine};
}

Token Lexer::opOrPunct() {
    int startLine = line;
    char c = advance();

    if (c == '=' && peek() == '=') { advance(); return {TokenType::EQ, "==", startLine}; }
    if (c == '!' && peek() == '=') { advance(); return {TokenType::NEQ, "!=", startLine}; }
    if (c == '<' && peek() == '=') { advance(); return {TokenType::LE, "<=", startLine}; }
    if (c == '>' && peek() == '=') { advance(); return {TokenType::GE, ">=", startLine}; }
    if (c == '&' && peek() == '&') { advance(); return {TokenType::AND, "&&", startLine}; }
    if (c == '|' && peek() == '|') { advance(); return {TokenType::OR, "||", startLine}; }

    switch (c) {
        case '=': return {TokenType::ASSIGN, "=", startLine};
        case '+': return {TokenType::PLUS, "+", startLine};
        case '-': return {TokenType::MINUS, "-", startLine};
        case '*': return {TokenType::MUL, "*", startLine};
        case '/': return {TokenType::DIV, "/", startLine};
        case '%': return {TokenType::MOD, "%", startLine};
        case '<': return {TokenType::LT, "<", startLine};
        case '>': return {TokenType::GT, ">", startLine};
        case '!': return {TokenType::NOT, "!", startLine};
        case '(': return {TokenType::LPAREN, "(", startLine};
        case ')': return {TokenType::RPAREN, ")", startLine};
        case ':': return {TokenType::COLON, ":", startLine};
        case ';': return {TokenType::SEMI, ";", startLine};
        case ',': return {TokenType::COMMA, ",", startLine};
    }
    return {TokenType::INVALID, std::string(1, c), startLine};
}