preprocessor.div

/*
 * Copyright 2025-2026 Yusuf Rençber
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

include "divio", "divstr", "divvec", "divmap", "divfile", "divstd", "lexer.div" : *;

class Preprocessor {
    pub defines: Vector<String>,
    priv file: String, priv index: u64,
    priv conditions: Vector<bool>,
    priv taken: Vector<bool>,
    priv tokens: Vector<Token>
} impl {
    priv Current(this: &Preprocessor) -> Token {
        if this.index >= this.tokens.Size() {
            ret this.tokens[this.tokens.Size() - 1u64];
        } else {
            ret this.tokens[this.index];
        }
    }

    priv Peek(this: &Preprocessor, offset: u64) -> Token {
        let index: u64 = this.index + offset;

        if index >= this.tokens.Size() {
            ret this.tokens[this.tokens.Size() - 1u64];
        } else {
            ret this.tokens[index];
        }
    }

    priv Advance(this: &mut Preprocessor) -> Token {
        let token: Token = this.Current();

        if this.index < this.tokens.Size() {
            this.index += 1u64;
        } ret token;
    }

    priv Match(this: &mut Preprocessor, _type: TokenType) -> bool {
        if this.Current()._type == _type {
            this.Advance();
            ret true;
        } else {
            ret false;
        }
    }

    priv Expect(this: &mut Preprocessor, _type: TokenType) -> Token {
        let token: Token = this.Current();

        if token._type != _type {
            Logger::Log(this.file, token.row, token.column, String("Expected '") + TokenTypeToString(_type) + "' but got '" + TokenTypeToString(token._type) + "'.", LogSeverity::Error);
        } else {
            this.Advance();
        } ret token;
    }

    pub Condition(this: &Preprocessor) -> bool {
        let mut i: u64 = 0u64;

        while i < this.conditions.Size() {
            if !this.conditions[i] {
                ret false;
            } i += 1u64;
        } ret true;
    }

    priv ProcessPrimary(this: &mut Preprocessor) -> bool {
        if this.Match(TokenType::TRUE) {
            ret true;
        } else if this.Match(TokenType::FALSE) {
            ret false;
        } else if this.Match(TokenType::LPAREN) {
            let result: bool = this.ProcessExpression();
            this.Expect(TokenType::RPAREN);
            ret result;
        } else {
            let name: String = this.Expect(TokenType::IDENTIFIER).value;
            ret this.defines.Contains(name);
        }
    }

    priv ProcessNotExpression(this: &mut Preprocessor) -> bool {
        if this.Match(TokenType::NOT) {
            ret !this.ProcessNotExpression();
        } ret this.ProcessPrimary();
    }

    priv ProcessAndExpression(this: &mut Preprocessor) -> bool {
        let mut result: bool = this.ProcessNotExpression();

        while this.Current()._type == TokenType::AND {
            this.Advance();
            let right: bool = this.ProcessNotExpression();
            result = result && right;
        } ret result;
    }

    priv ProcessOrExpression(this: &mut Preprocessor) -> bool {
        let mut result: bool = this.ProcessAndExpression();

        while this.Current()._type == TokenType::OR {
            this.Advance();
            let right: bool = this.ProcessAndExpression();
            result = result || right;
        } ret result;
    }

    priv ProcessExpression(this: &mut Preprocessor) -> bool {
        ret this.ProcessOrExpression();
    }

    pub ProcessDirective(this: &mut Preprocessor) {
        let token: Token = this.Current();

        if this.Match(TokenType::IF) {
            let active: bool = this.ProcessExpression();
            this.conditions.PushBack(active);
            this.taken.PushBack(active);
        } else if this.Match(TokenType::ELIF) {
            let active: bool = this.ProcessExpression();

            if this.conditions.Empty() {
                Logger::Log(this.file, token.row, token.column, "Unexpected 'elif' directive.", LogSeverity::Error);
            } else if this.taken[this.taken.Size() - 1u64] {
                this.conditions[this.conditions.Size() - 1u64] = false;
            } else {
                this.conditions[this.conditions.Size() - 1u64] = active;
                this.taken[this.taken.Size() - 1u64] = active;
            }
        } else if this.Match(TokenType::ELSE) {
            if this.conditions.Empty() {
                Logger::Log(this.file, token.row, token.column, "Unexpected 'else' directive.", LogSeverity::Error);
            } else if this.taken[this.taken.Size() - 1u64] {
                this.conditions[this.conditions.Size() - 1u64] = false;
            } else {
                this.conditions[this.conditions.Size() - 1u64] = true;
                this.taken[this.taken.Size() - 1u64] = true;
            }
        } else if this.Match(TokenType::ENDIF) {
            if !this.conditions.Empty() {
                this.conditions.PopBack();
                this.taken.PopBack();
            } else {
                Logger::Log(this.file, token.row, token.column, "Unexpected 'endif' directive.", LogSeverity::Error);
            }
        } else if this.Match(TokenType::ERROR) {
            Logger::Log(this.file, token.row, token.column, this.Expect(TokenType::STRING).value, LogSeverity::Error);
        } else if this.Match(TokenType::WARNING) {
            Logger::Log(this.file, token.row, token.column, this.Expect(TokenType::STRING).value, LogSeverity::Warning);
        } else {
            Logger::Log(this.file, token.row, token.column, (String("Unknown directive: '") + token.value + "'."), LogSeverity::Error);
        }
    }

    pub Process(this: &mut Preprocessor, tokens: &Vector<Token>, file: &String) -> Vector<Token> {
        let mut result: Vector<Token>;
        (this.tokens, this.file, this.index) = (tokens, file, 0u64);

        loop {
            let token: Token = this.Current();

            if this.Match(TokenType::PREPROCESSOR_START) {
                this.ProcessDirective();
                this.Expect(TokenType::PREPROCESSOR_END);
            } else if token._type != TokenType::EOF {
                if this.Condition() {
                    result.PushBack(token);
                } this.Advance();
            } else {
                if !this.conditions.Empty() {
                    Logger::Log(this.file, token.row, token.column, "Expected 'endif' directive.", LogSeverity::Error);
                }

                result.PushBack(token);
                break;
            }
        } ret result;
    }
};