mConfigurationParser.cpp

#include <state/mConfiguration/mConfigurationParser.h>
 
namespace TuringSim::State::MConfiguration {
    void MConfigurationParser::checkInitialization() const {
        std::set<char> symbols {left, right, separator};
        if(symbols.size() != 3) {
            throw MConfigurationParserBadInitializationException(
                    "Left, right and separator should be distinct.",
                    left, right, separator, ignore, variablePrefix);
        }
        for(char i: ignore) {
            if(symbols.count(i) > 0) {
                throw MConfigurationParserBadInitializationException(
                        "Left, right and separator should not be ignore characters.",
                        left, right, separator, ignore, variablePrefix);
            }
        }
        for(char c: variablePrefix) {
            if(symbols.count(c) > 0) {
                throw MConfigurationParserBadInitializationException(
                        "variablePrefix should not contain delimiters and separators.",
                        left, right, separator, ignore, variablePrefix);
            }
            if(ignore.count(c) > 0) {
                throw MConfigurationParserBadInitializationException(
                        "variablePrefix should not contain ignore characters",
                        left, right, separator, ignore, variablePrefix);
            }
        }
    }
 
    MConfigurationParser::MConfigurationParser() {
        checkInitialization();
    }
 
    MConfigurationParser::MConfigurationParser(char left, char right, char separator, std::set<char> ignore, const std::string& variablePrefix)
            : left(left), right(right), separator(separator), ignore(ignore), variablePrefix(variablePrefix) {
        checkInitialization();
    }
 
    std::shared_ptr<const MConfiguration<std::string>> MConfigurationParser::parse(const std::string& m_fun) const {
        std::vector<Token> tokens = tokenize(m_fun);
        translateKeywords(m_fun, tokens);
        auto [parsed, position] = parse_tokens_m_func(m_fun, tokens, 0);
 
        if(position != tokens.size() - 1) {
            using Utils::Debug::operator<<;
            std::stringstream ss;
            ss << "parsed: " << parsed;
            throw MConfigurationParserSyntaxErrorException("Extra token at the end.", m_fun, tokens, position, ss.str());
        }
        else if(std::get<0>(tokens[position]) != TokenKind::EOS) {
            using Utils::Debug::operator<<;
            std::stringstream ss;
            ss << "parsed: " << parsed;
            throw MConfigurationParserSyntaxErrorException("Non terminated token stream." , m_fun, tokens, position, ss.str());
        }
 
        return parsed;
    }
 
    MConfigurationParser::Token MConfigurationParser::tokenize(const std::string& m_fun, size_t start) const {
        for(; start < m_fun.size() && ignore.count(m_fun[start]) != 0; ++start)
            ;
        if(start == m_fun.size())
            return {TokenKind::EOS, start, start};
        if(m_fun[start] == left)
            return {TokenKind::LEFT, start, start};
        if(m_fun[start] == right)
            return {TokenKind::RIGHT, start, start};
        if(m_fun[start] == separator)
            return {TokenKind::SEPARATOR, start, start};
        size_t end;
        for(end = start; end < m_fun.size() && ignore.count(m_fun[end]) == 0 && m_fun[end] != left && m_fun[end] != right && m_fun[end] != separator; ++end)
            ;
        return {TokenKind::IDENT, start, end - 1};
    }
 
    std::vector<MConfigurationParser::Token> MConfigurationParser::tokenize(const std::string& m_fun) const {
        std::vector<Token> tokens;
        size_t start = 0;
        while(true) {
            Token t = tokenize(m_fun, start);
            tokens.push_back(t);
            if(std::get<0>(t) == TokenKind::EOS)
                break;
            start = std::get<2>(t) + 1;
        }
        return tokens;
    }
 
    std::optional<MConfigurationParser::Token> MConfigurationParser::translateKeyword(const std::string& pattern, const Token& token) const {
        if(std::get<TokenKind>(token) != TokenKind::IDENT)
            return std::optional<Token>(std::nullopt);
        std::string name = sub(pattern, token);
 
        if(name == "blank")
            return std::make_optional(std::make_tuple(TokenKind::BLANK, std::get<1>(token), std::get<2>(token)));
        return std::optional<Token>(std::nullopt);
    }
 
    void MConfigurationParser::translateKeywords(const std::string& pattern, std::vector<Token>& tokens) const {
        for(size_t i = 0; i < tokens.size(); ++i) {
            const Token& token = tokens[i];
            std::optional<Token> new_token = translateKeyword(pattern, token);
            if(new_token)
                tokens[i] = new_token.value();
        }
    }
 
    std::string MConfigurationParser::sub(const std::string& m_fun, const MConfigurationParser::Token& token) const {
        size_t begin, end;
        std::tie(std::ignore, begin, end) = token;
        size_t len = end - begin + 1;
        return m_fun.substr(begin, len);
    }
 
    std::pair<bool, std::string> MConfigurationParser::isVariableNode(const std::string& node) const {
        size_t nodeLen = variablePrefix.size();
        size_t prefixLen = variablePrefix.size();
        if(nodeLen < prefixLen) {
            return {false, node};
        }
        if(variablePrefix == node.substr(0, prefixLen)) {
            return {true, node.substr(prefixLen)};
        }
        return {false, node};
    }
 
    std::pair<std::shared_ptr<const MConfiguration<std::string>>, size_t> MConfigurationParser::parse_tokens_m_func(
            const std::string& m_fun,
            const std::vector<Token>& tokens,
            size_t position) const {
        using namespace std::string_literals;
        size_t l = tokens.size();
        if(position >= l) {
            throw MConfigurationParserSyntaxErrorException("Reached end of string. This should not happen.", m_fun, tokens, position);
        }
 
        std::string node;
        bool explicitBlank = false;
 
        switch(std::get<0>(tokens[position])) {
            case TokenKind::IDENT:
                node = sub(m_fun, tokens[position]);
                break;
            case TokenKind::BLANK:
                node = "";
                explicitBlank = true;
                break;
            case TokenKind::LEFT:
            case TokenKind::RIGHT:
            case TokenKind::SEPARATOR:
            case TokenKind::EOS:
                throw MConfigurationParserSyntaxErrorException("M-configuration should start with an identifier.", m_fun, tokens, position);
        }
 
        position++;
 
        std::function<std::shared_ptr<const MConfiguration<std::string>>(std::string)> make_leaf =
                [&](const std::string& node_str) -> std::shared_ptr<const MConfiguration<std::string>> {
                    if(!explicitBlank && node_str.empty()) {
                        throw MConfigurationParserSyntaxErrorException("Token shouldn't be empty.", m_fun, tokens, position);
                    }
                    auto [isVariable, nodeName] = isVariableNode(node_str);
                    return std::make_shared<const MConfiguration<std::string>>(nodeName, isVariable);
                };
 
        switch(std::get<0>(tokens[position])) {
            case TokenKind::EOS:
                return {make_leaf(node), position};
            case TokenKind::IDENT:
            case TokenKind::BLANK: {
                throw MConfigurationParserSyntaxErrorException("Expected a left or right parenthesis or a delimiter after a node name.", m_fun, tokens, position);
            }
            case TokenKind::SEPARATOR:
            case TokenKind::RIGHT:
                return {make_leaf(node), position};
            case TokenKind::LEFT:
                std::vector<std::shared_ptr<const MConfiguration<std::string>>> params;
                position++;
                std::tie(params, position) = parse_tokens_m_func_list(m_fun, tokens, position);
                switch(std::get<0>(tokens[position])){
                    case TokenKind::RIGHT:
                        return {std::make_shared<const MConfiguration<std::string>>(node, params), position + 1};
                    case TokenKind::LEFT:
                    case TokenKind::IDENT:
                    case TokenKind::BLANK:
                    case TokenKind::SEPARATOR:
                    case TokenKind::EOS: {
                        throw MConfigurationParserSyntaxErrorException("Expected right parenthesis after a list of parameters.", m_fun, tokens, position);
 
                    }
                }
        }
    }
 
    std::pair<std::vector<std::shared_ptr<const MConfiguration<std::string>>>, size_t> MConfigurationParser::parse_tokens_m_func_list(const std::string& m_fun, const std::vector<Token>& tokens, size_t position) const {
        std::vector<std::shared_ptr<const MConfiguration<std::string>>> params;
 
        while(true) {
            auto [param, new_position] = parse_tokens_m_func(m_fun, tokens, position);
 
            std::function<MConfigurationParserSyntaxErrorException(const std::string&)> make_exception =
                    [&, new_position = new_position](const std::string& message) -> MConfigurationParserSyntaxErrorException {
                        using Utils::Debug::operator<<;
                        std::stringstream ss;
                        ss << "new_position: " << new_position;
                        return MConfigurationParserSyntaxErrorException(message, m_fun, tokens, position, ss.str());
                    };
 
            position = new_position;
            params.push_back(param);
 
            if(std::get<0>(tokens[position]) == TokenKind::IDENT) {
                throw make_exception("Expected delimiter or right parenthesis, got an identifier");
            }
            if(std::get<0>(tokens[position]) == TokenKind::LEFT) {
                throw make_exception("Expected delimiter or right parenthesis, got a left parenthesis");
            }
            if(std::get<0>(tokens[position]) == TokenKind::EOS) {
                throw make_exception("Expected delimiter or right parenthesis, got end of string");
            }
            if(std::get<0>(tokens[position]) == TokenKind::RIGHT) {
                break;
            }
            if(std::get<0>(tokens[position]) == TokenKind::SEPARATOR) {
                position++;
            }
        }
 
        return {params, position};
    }
}