gplib/include/gp/dynamic/compiler/lexer.hpp

#pragma once

#include "gp/containers/array.hpp"
#include "gp/containers/vector.hpp"
#include "gp/text/ascii.hpp"

using string = gp::vector<char>;

#define FOREACH_LEXEME_TYPE \
    LEX(leftBracket) \
    LEX(rightBracket) \
    LEX(leftParenthesis) \
    LEX(rightParenthesis) \
    LEX(leftCurlyBrace) \
    LEX(rightCurlyBrace) \
    LEX(period) \
    LEX(semicolon) \
    LEX(colon) \
    LEX(doubleColon) \
    LEX(comma) \
    LEX(at) \
    LEX(pointer) \
    LEX(as) \
    LEX(try_) \
    LEX(catch_) \
    LEX(raise_) \
    LEX(defer) \
    LEX(assign) \
    LEX(addAssign) \
    LEX(substractAssign) \
    LEX(multiplyAssign) \
    LEX(divideAssign) \
    LEX(concatenateAssign) \
    LEX(remainderAssign) \
    LEX(powerAssign) \
    LEX(plus) \
    LEX(minus) \
    LEX(add) \
    LEX(substract) \
    LEX(multiply) \
    LEX(divide) \
    LEX(concatenate) \
    LEX(remainder) \
    LEX(power) \
    LEX(equal) \
    LEX(doubleEqual) \
    LEX(threeWayComparison) \
    LEX(notEqual) \
    LEX(greaterOrEqual) \
    LEX(greater) \
    LEX(lesserOrEqual) \
    LEX(lesser) \
    LEX(leftShift) \
    LEX(rightShift) \
    LEX(and_) \
    LEX(or_) \
    LEX(xor_) \
    LEX(not_) \
    LEX(increment) \
    LEX(decrement) \
    LEX(identifier) \
    LEX(integer) \
    LEX(float_) \
    LEX(boolean) \
    LEX(string_) \
    LEX(null_) \
    LEX(public_) \
    LEX(main_) \
    LEX(type_) \
    LEX(event_) \
    LEX(class_) \
    LEX(enum_) \
    LEX(template_) \
    LEX(new_) \
    LEX(copy) \
    LEX(send) \
    LEX(receive) \
    LEX(intType) \
    LEX(floatType) \
    LEX(boolType) \
    LEX(stringType) \
    LEX(arrayType) \
    LEX(functionType) \
    LEX(taskType) \
    LEX(chanType) \
    LEX(autoType) \
    LEX(if_) \
    LEX(unless) \
    LEX(else_) \
    LEX(switch_) \
    LEX(select) \
    LEX(case_) \
    LEX(while_) \
    LEX(do_) \
    LEX(until) \
    LEX(for_) \
    LEX(loop) \
    LEX(return_) \
    LEX(self) \
    LEX(kill) \
    LEX(killAll) \
    LEX(yield) \
    LEX(break_) \
    LEX(continue_)

#define LEX(x) x,
enum class gr_lexeme_type {
    FOREACH_LEXEME_TYPE
};
#undef LEX

#define LEX(x) case gr_lexeme_type::x: return #x;
constexpr inline const char* to_string(const gr_lexeme_type& value) {
    switch(value) {
        FOREACH_LEXEME_TYPE
    }
}
#undef LEX

#define LEX(x) +1
constexpr inline const char* to_pretty_string(const gr_lexeme_type& value) {
    constexpr gp::array<const char*, 0 + FOREACH_LEXEME_TYPE> names = {
        "[", "]", "(", ")", "{", "}", ".", ";", ":", "::", ",", "@", "&", "as",
        "try", "catch", "raise", "defer", "=", "+=", "-=", "*=", "/=", "~=",
        "%=", "^=", "+", "-", "+", "-", "*", "/", "~", "%", "^", "==", "===",
        "<=>", "!=", ">=", ">", "<=", "<", "<<", ">>", "and", "or", "xor", "not", "++",
        "--", "identifier", "const_int", "const_float", "const_bool",
        "const_str", "null", "pub", "main", "type", "event", "class", "enum",
        "template", "new", "copy", "send", "receive", "int", "float", "bool",
        "string", "array", "func", "task", "chan", "let", "if", "unless",
        "else", "switch", "select", "case", "while", "do", "until", "for", "loop",
        "return", "self", "kill", "killall", "yield", "break", "continue"
    };
    return names[(uint64_t)value];
}
#undef LEX

struct gr_lexeme;

class gr_lexer {
public:
    using file_loader_t = gp::function<gp::vector<char>(const gp::vector<char>&)>;
    gp::allocator& _allocator;
    file_loader_t file_loader;
private:
    gp::vector<string> _files_to_import, _files_imported, _lines;

    string _file, _text;
    uint64_t _line, _current, _position_of_line, _file_id;

    gp::vector<gr_lexeme> _lexemes;

    char get(ssize_t offset = 0);
    bool advance(bool start_from_current = false);
    void scan_script();
    void scan_number();
    void scan_string();
    void scan_operator();
    void scan_word();
    void scan_file_path();
    void scan_use();
    string convert_path_to_import(string&);

public:

    gr_lexer(gp::allocator& alloc, file_loader_t& loader)
    : _allocator(alloc)
    , file_loader(loader)
    , _files_to_import(_allocator)
    , _files_imported(_allocator)
    , _lines(_allocator)
    , _file(_allocator)
    , _text(_allocator)
    , _lexemes(_allocator)
    {}

    const gp::vector<gr_lexeme>& lexemes() {
        return _lexemes;
    }

    void scan_file(gp::vector<char>& file_name);

    const string& get_line(const gr_lexeme&) const;
    const string& get_file(const gr_lexeme&) const;
    const string& get_file(const size_t&) const;
};

struct gr_lexeme {
    const gr_lexer& lexer;
    size_t _file_id;
    size_t _line, _column, _text_length = 1;
    
    gr_lexeme_type type;
    bool 
        is_literal,
        is_operator,
        is_keyword,
        is_type;
    int ivalue;
    float fvalue;
    bool bvalue;
    string svalue;

    gr_lexeme(const gr_lexer& v)
    : lexer(v)
    , svalue(v._allocator)
    {}

    const string& get_line() const {
        return lexer.get_line(*this);
    }

    const string& get_file() {
        return lexer.get_file(*this);
    }
};

inline char gr_lexer::get(ssize_t offset) {
    const uint position = ssize_t(_current) + offset;
    gp_config::assertion(!(position < 0 || position >= _text.size()), "Unexpected end of script");
    return _text[position];
}

inline const string& gr_lexer::get_line(const gr_lexeme& lex) const {
    gp_config::assertion(!(lex._file_id >= _files_imported.size()), "Lexeme file id out of bounds");
    // TODO: Implement this
    return _files_imported[lex._file_id];
}

inline const string& gr_lexer::get_file(const gr_lexeme& lex) const {
    gp_config::assertion(!(lex._file_id >= _files_imported.size()), "Lexeme file id out of bounds");
    return _files_imported[lex._file_id];
}

inline const string& gr_lexer::get_file(const size_t& file_id) const {
    gp_config::assertion(!(file_id >= _files_imported.size()), "File id out of bounds");
    return _files_imported[file_id];
}

inline bool gr_lexer::advance(bool start_from_current) {
    if(!start_from_current) {
        _current++;
    }

    if(_current >= _text.size()) {
        return false;
    }

    char symbol = _text[_current];

    whileLoop: while(symbol <= 0x20 || symbol == '/' || symbol == '#') {
        if(_current >= _text.size()) {
            return false;
        }

        symbol = _text[_current];

        if(symbol == '\n') {
            _position_of_line = _current;
            _line++;
        }
        else if(symbol == '#')
        {
            do {
                if(_current >= _text.size()) return false;
                _current++;
            } while (_text[_current] != '\n');
            _position_of_line = _current;
            _line++;
        }
        else if(symbol == '/')
        {
            if((_current + 1) >= _text.size()) {
                return false;
            }

            switch(_text[_current + 1]) {
                case '/': {
                    do {
                        if(_current >= _text.size()) {
                            return false;
                        }
                    } while(_current < _text.size() && _text[_current] != '\n');
                    _position_of_line = _current;
                    _line++;
                }break;
                case '*': {
                    for(;;) {
                        if((_current + 1) >= _text.size()) {
                            _current++;
                            return false;
                        }

                        if(_text[_current] == '\n') {
                            _position_of_line = _current;
                            _line++;
                        }

                        if(_text[_current] == '*' && _text[_current + 1] == '/') {
                            _current++;
                            break;
                        }
                        
                        _current++;
                    }
                }break;
                default:
                    // Goto honorable
                    goto whileLoop;
            }
        }

        _current++;

        if(_current >= _text.size()) {
            return false;
        }

        symbol = _text[_current];
    }
    return true;
}

inline void gr_lexer::scan_script() {
    advance(true);

    constexpr static auto is_operator = [](char v) {
        if(v == '!') return true;
        if(v >= '#' && v <='&') return true;
        if(v >= '(' && v <='-') return true;
        if(v == '/') return true;
        if(v >= ':' && v <='@') return true;
        if(v >= '[' && v <='^') return true;
        if(v >= '{' && v <='~') return true;
        return false;
    };

    do {
        if (_current >= _text.size())
            break;
        auto c = get();
        if(is_digit(c)) scan_number();
        else if(c ==  '.') {
            if (get(1) >= '0' && get(1) <= '9') 
                scan_number();
            else
                scan_operator();
        }
        else if(is_operator(c)) scan_operator();
        else if(c == '\"') scan_string();
        else scan_word();
    }while (advance());
}

    inline void gr_lexer::scan_number(){
        gr_lexeme lex = gr_lexeme(*this);
        lex.is_literal = true;

        bool isFloat;
        string buffer(_allocator);
        for (;;) {
            char symbol = get();

            if (symbol >= '0' && symbol <= '9')
                buffer.push_back(symbol);
            else if (symbol == '_') {
                // Do nothing, only cosmetic (e.g. 1_000_000).
            }
            else if (symbol == '.') {
                if (isFloat)
                    break;
                isFloat = true;
                buffer.push_back(symbol);
            }
            else if (symbol == 'f') {
                isFloat = true;
                break;
            }
            else {
                if (_current)
                    _current--;
                break;
            }

            _current++;

            if (_current >= _text.size())
                break;
        }
    }

    inline void gr_lexer::scan_string(){
        gr_lexeme lex = gr_lexeme(*this);
        lex.type = gr_lexeme_type::string_;
        lex.is_literal = true;

        gp_config::assertion(get() != '\"',"Expected \'\"\' at the beginning of the string.");
        _current++;

        string buffer(_allocator);
        bool escape = false;
        bool wasEscape = false;
        for (;;) {
            gp_config::assertion(_current >= _text.size(),"Missing \'\"\' character.");
            char symbol = get();

            if (symbol == '\n') {
                _position_of_line = _current;
                _line++;
            }
            else if (symbol == '\"' && (!wasEscape))
                break;
            else if (symbol == '\\' && (!wasEscape)) {
                escape = true;
            }

            if (!escape) {
                if (!wasEscape) {
                        buffer.push_back(symbol);
                }
                else {
                    if (symbol == 'n')
                        buffer.push_back('\n');
                    else
                        buffer.push_back(symbol);
                }
            }
            wasEscape = escape;
            escape = false;

            _current++;
        }

        lex._text_length = size_t(buffer.size() + 2u);
        lex.svalue = buffer;
        _lexemes.push_back(lex);
    }

    inline void gr_lexer::scan_operator(){
        gr_lexeme lex = gr_lexeme(*this);
        lex.is_operator = true;

        switch (get()) {
        case '{':
            lex.type = gr_lexeme_type::leftCurlyBrace;
            break;
        case '}':
            lex.type = gr_lexeme_type::rightCurlyBrace;
            break;
        case '(':
            lex.type = gr_lexeme_type::leftParenthesis;
            break;
        case ')':
            lex.type = gr_lexeme_type::rightParenthesis;
            break;
        case '[':
            lex.type = gr_lexeme_type::leftBracket;
            break;
        case ']':
            lex.type = gr_lexeme_type::rightBracket;
            break;
        case '.':
            lex.type = gr_lexeme_type::period;
            break;
        case ';':
            lex.type = gr_lexeme_type::semicolon;
            break;
        case ':':
            lex.type = gr_lexeme_type::colon;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == ':') {
                lex.type = gr_lexeme_type::doubleColon;
                lex._text_length = 2;
                _current++;
            }
            break;
        case ',':
            lex.type = gr_lexeme_type::comma;
            break;
        case '^':
            lex.type = gr_lexeme_type::power;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::powerAssign;
                lex._text_length = 2;
                _current++;
            }
            break;
        case '@':
            lex.type = gr_lexeme_type::at;
            break;
        case '&':
            lex.type = gr_lexeme_type::pointer;
            break;
        case '~':
            lex.type = gr_lexeme_type::concatenate;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::concatenateAssign;
                lex._text_length = 2;
                _current++;
            }
            break;
        case '+':
            lex.type = gr_lexeme_type::add;
            if (_current + 1 >= _text.size())
                break;
            switch (get(1)) {
            case '=':
                lex.type = gr_lexeme_type::addAssign;
                lex._text_length = 2;
                _current++;
                break;
            case '+':
                lex.type = gr_lexeme_type::increment;
                lex._text_length = 2;
                _current++;
                break;
            default:
                break;
            }
            break;
        case '-':
            lex.type = gr_lexeme_type::substract;
            if (_current + 1 >= _text.size())
                break;
            switch (get(1)) {
            case '=':
                lex.type = gr_lexeme_type::substractAssign;
                lex._text_length = 2;
                _current++;
                break;
            case '-':
                lex.type = gr_lexeme_type::decrement;
                lex._text_length = 2;
                _current++;
                break;
            default:
                break;
            }
            break;
        case '*':
            lex.type = gr_lexeme_type::multiply;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::multiplyAssign;
                lex._text_length = 2;
                _current++;
            }
            break;
        case '/':
            lex.type = gr_lexeme_type::divide;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::divideAssign;
                lex._text_length = 2;
                _current++;
            }
            break;
        case '%':
            lex.type = gr_lexeme_type::remainder;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::remainderAssign;
                lex._text_length = 2;
                _current++;
            }
            break;
        case '=':
            lex.type = gr_lexeme_type::assign;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::equal;
                lex._text_length = 2;
                _current++;
                if (_current + 1 >= _text.size())
                    break;
                if (get(1) == '=') {
                    lex.type = gr_lexeme_type::doubleEqual;
                    lex._text_length = 3;
                    _current++;
                }
            }
            break;
        case '<':
            lex.type = gr_lexeme_type::lesser;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::lesserOrEqual;
                lex._text_length = 2;
                _current++;
                if (_current + 1 >= _text.size())
                    break;
                if (get(1) == '>') {
                    lex.type = gr_lexeme_type::threeWayComparison;
                    lex._text_length = 3;
                    _current++;
                }
            }
            else if (get(1) == '-') {
                lex.type = gr_lexeme_type::send;
                lex._text_length = 2;
                _current++;
            }
            else if (get(1) == '<') {
                lex.type = gr_lexeme_type::leftShift;
                lex._text_length = 2;
                _current++;
            }
            break;
        case '>':
            lex.type = gr_lexeme_type::greater;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::greaterOrEqual;
                lex._text_length = 2;
                _current++;
            }
            else if (get(1) == '>') {
                lex.type = gr_lexeme_type::rightShift;
                lex._text_length = 2;
                _current++;
            }
            break;
        case '!':
            lex.type = gr_lexeme_type::not_;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::notEqual;
                lex._text_length = 2;
                _current++;
            }
            break;
        default:
            gp_config::assertion(false, "GrLexer: invalid operator");
        }

        _lexemes.push_back(lex);
    }

    namespace _hidden {
        bool operator==(const gp::vector<char>& lhs, const char* rhs) {
            for(size_t index = 0; index < lhs.size() && rhs[index] != 0; index++){
                if(lhs[index] != rhs[index]) return false;
            }
            return true;
        }
    }

    inline void gr_lexer::scan_word(){
        gr_lexeme lex = gr_lexeme(*this);
        lex.is_keyword = true;

        string symbol_buffer(_allocator);
        for (;;) {
            if (_current >= _text.size())
                break;

            char symbol = get();
            if (symbol == '!' || symbol == '?') {
                symbol_buffer.push_back(symbol);
                _current++;
                break;
            }
            if (symbol <= '&' || (symbol >= '(' && symbol <= '/') || (symbol >= ':'
                    && symbol <= '@') || (symbol >= '[' && symbol <= '^')
                    || (symbol >= '{' && symbol <= 0x7F))
                break;

            symbol_buffer.push_back(symbol);
            _current++;
        }
        _current--;

        lex._text_length = symbol_buffer.size();

        using namespace _hidden;

        if(symbol_buffer == "use"){
            scan_use();
            return;
        }
        else if(symbol_buffer == "pub"){
            lex.type = gr_lexeme_type::public_;
        }
        else if(symbol_buffer == "main"){
            lex.type = gr_lexeme_type::main_;
        }
        else if(symbol_buffer == "type"){
            lex.type = gr_lexeme_type::type_;
        }
        else if(symbol_buffer == "event"){
            lex.type = gr_lexeme_type::event_;
        }
        else if(symbol_buffer == "class"){
            lex.type = gr_lexeme_type::class_;
        }
        else if(symbol_buffer == "enum"){
            lex.type = gr_lexeme_type::enum_;
        }
        else if(symbol_buffer == "template"){
            lex.type = gr_lexeme_type::template_;
        }
        else if(symbol_buffer == "if"){
            lex.type = gr_lexeme_type::if_;
        }
        else if(symbol_buffer == "unless"){
            lex.type = gr_lexeme_type::unless;
        }
        else if(symbol_buffer == "else"){
            lex.type = gr_lexeme_type::else_;
        }
        else if(symbol_buffer == "switch"){
            lex.type = gr_lexeme_type::switch_;
        }
        else if(symbol_buffer == "select"){
            lex.type = gr_lexeme_type::select;
        }
        else if(symbol_buffer == "case"){
            lex.type = gr_lexeme_type::case_;
        }
        else if(symbol_buffer == "while"){
            lex.type = gr_lexeme_type::while_;
        }
        else if(symbol_buffer == "do"){
            lex.type = gr_lexeme_type::do_;
        }
        else if(symbol_buffer == "until"){
            lex.type = gr_lexeme_type::until;
        }
        else if(symbol_buffer == "for"){
            lex.type = gr_lexeme_type::for_;
        }
        else if(symbol_buffer == "loop"){
            lex.type = gr_lexeme_type::loop;
        }
        else if(symbol_buffer == "return"){
            lex.type = gr_lexeme_type::return_;
        }
        else if(symbol_buffer == "self"){
            lex.type = gr_lexeme_type::self;
        }
        else if(symbol_buffer == "kill"){
            lex.type = gr_lexeme_type::kill;
        }
        else if(symbol_buffer == "killall"){
            lex.type = gr_lexeme_type::killAll;
        }
        else if(symbol_buffer == "yield"){
            lex.type = gr_lexeme_type::yield;
        }
        else if(symbol_buffer == "break"){
            lex.type = gr_lexeme_type::break_;
        }
        else if(symbol_buffer == "continue"){
            lex.type = gr_lexeme_type::continue_;
        }
        else if(symbol_buffer == "as"){
            lex.type = gr_lexeme_type::as;
        }
        else if(symbol_buffer == "try"){
            lex.type = gr_lexeme_type::try_;
        }
        else if(symbol_buffer == "catch"){
            lex.type = gr_lexeme_type::catch_;
        }
        else if(symbol_buffer == "raise"){
            lex.type = gr_lexeme_type::raise_;
        }
        else if(symbol_buffer == "defer"){
            lex.type = gr_lexeme_type::defer;
        }
        else if(symbol_buffer == "task"){
            lex.type = gr_lexeme_type::taskType;
            lex.is_type = true;
        }
        else if(symbol_buffer == "func"){
            lex.type = gr_lexeme_type::functionType;
            lex.is_type = true;
        }
        else if(symbol_buffer == "int"){
            lex.type = gr_lexeme_type::intType;
            lex.is_type = true;
        }
        else if(symbol_buffer == "float"){
            lex.type = gr_lexeme_type::floatType;
            lex.is_type = true;
        }
        else if(symbol_buffer == "bool"){
            lex.type = gr_lexeme_type::boolType;
            lex.is_type = true;
        }
        else if(symbol_buffer == "string"){
            lex.type = gr_lexeme_type::stringType;
            lex.is_type = true;
        }
        else if(symbol_buffer == "array"){
            lex.type = gr_lexeme_type::arrayType;
            lex.is_type = true;
        }
        else if(symbol_buffer == "chan"){
            lex.type = gr_lexeme_type::chanType;
            lex.is_type = true;
        }
        else if(symbol_buffer == "new"){
            lex.type = gr_lexeme_type::new_;
            lex.is_type = false;
        }
        else if(symbol_buffer == "let"){
            lex.type = gr_lexeme_type::autoType;
            lex.is_type = false;
        }
        else if(symbol_buffer == "true"){
            lex.type = gr_lexeme_type::boolean;
            lex.is_keyword = false;
            lex.is_literal = true;
            lex.bvalue = true;
        }
        else if(symbol_buffer == "false"){
            lex.type = gr_lexeme_type::boolean;
            lex.is_keyword = false;
            lex.is_literal = true;
            lex.bvalue = false;
        }
        else if(symbol_buffer == "null"){
            lex.type = gr_lexeme_type::null_;
            lex.is_keyword = false;
            lex.is_literal = true;
        }
        else if(symbol_buffer == "not"){
            lex.type = gr_lexeme_type::not_;
            lex.is_keyword = false;
            lex.is_operator = true;
        }
        else if(symbol_buffer == "and"){
            lex.type = gr_lexeme_type::and_;
            lex.is_keyword = false;
            lex.is_operator = true;
        }
        else if(symbol_buffer == "or"){
            lex.type = gr_lexeme_type::or_;
            lex.is_keyword = false;
            lex.is_operator = true;
        }
        else if(symbol_buffer == "xor"){
            lex.type = gr_lexeme_type::xor_;
            lex.is_keyword = false;
            lex.is_operator = true;
        } else {
            lex.is_keyword = false;
            lex.type = gr_lexeme_type::identifier;
            lex.svalue = symbol_buffer;
        }

        _lexemes.push_back(lex);
    }
    
    inline string gr_lexer::convert_path_to_import(string& path) {
        return path;
    }

    inline void gr_lexer::scan_file(gp::vector<char>& file_name){
        _files_to_import.push_back(file_name);

        while (_files_to_import.size()) {
            _file = _files_to_import[_files_to_import.size()-1];
            _files_imported.push_back(_file);
            _text = file_loader(file_name);
            _files_to_import.pop_back();

            _line = 0u;
            _current = 0u;
            _lines = gp::vector<string>(_allocator);

            gp::vector<char> tmp(_allocator);
            for(char c : _text) {
                if(c == '\n') {
                    _lines.push_back(tmp);
                    tmp = gp::vector<char>(_allocator);
                } else {
                    tmp.push_back(c);
                }
            }

            scan_script();

            _file_id++;
        }
    }

    inline void gr_lexer::scan_file_path(){
        gp_config::assertion(get() != '\"', "Expected \'\"\' at the beginning of the import.");
        _current++;

        string buffer(_allocator);
        for (;;) {
            gp_config::assertion(_current >= _text.size(), "Missing \'\"\' character.");
            char symbol = get();
            if (symbol == '\n') {
                _position_of_line = _current;
                _line++;
            }
            else if (symbol == '\"')
                break;

            buffer.push_back(symbol);
            _current++;
        }
        buffer = convert_path_to_import(buffer);

        for(auto& file : _files_imported) {
            if(file == buffer) return;
        }
        for(auto& file : _files_to_import) {
            if(file == buffer) return;
        }

        _files_to_import.push_back(buffer);
    }

    inline void gr_lexer::scan_use(){
        advance();

        // Multiple files import.
        if (get() == '{') {
            advance();
            bool isFirst = true;
            for (;;) {
                if (isFirst)
                    isFirst = false;
                else if (get() == '\"')
                    advance();
                else
                    gp_config::assertion(false, "Missing \'}\' after import list.");
                // EOF
                gp_config::assertion(_current >= _text.size(), "Missing \'}\' after import list.");
                // End of the import list.
                if (get() == '}')
                    break;
                // Scan
                scan_file_path();
            }
        }
        else {
            scan_file_path();
        }
    }