turingStyleMixedSymbolPatternParser.h

#pragma once
 
#include <utils/messageException.h>
#include <symbol/turingMachineSymbolPattern.h>
 
namespace TuringSim::Symbol {
    class TuringStyleMixedSymbolPatternParser {
        typedef TuringStyleMixedSymbolPattern<std::string> SymbolPattern;
    public:
        enum class TokenKind {
            SEPARATOR,  
            LEFT,  
            RIGHT,  
            IDENT,  
            NONE,  
            NON,  
            ANY,  
            TRUE,  
            EOS,  
        };
 
        typedef std::tuple<TokenKind, size_t, size_t> Token;
 
        TuringStyleMixedSymbolPatternParser();
 
        TuringStyleMixedSymbolPatternParser(char left, char right, char separator, std::string blank, std::set<char> ignore, std::string variablePrefix, std::string escapePrefix);
 
        void checkInitialization() const;
 
        SymbolPattern parse(const std::string& pattern) const;
 
        std::pair<bool, std::string> isVariableNode(const std::string& node) const;
 
        std::pair<SymbolPattern, size_t> parse_negative_pattern(const std::string& pattern, const std::vector <Token>& tokens, size_t position) const;
 
        std::pair<SymbolPattern, size_t> parse_positive_pattern(const std::string& pattern, const std::vector <Token>& tokens, size_t position) const;
        
        std::string sub(const std::string& pattern, const TuringStyleMixedSymbolPatternParser::Token& token) const;
 
        std::vector<Token> tokenize(const std::string& pattern) const;
 
        Token tokenize(const std::string& pattern, size_t start) const;
 
        std::optional<Token> translateKeyword(const std::string& pattern, const TuringStyleMixedSymbolPatternParser::Token& token) const;
 
        void translateKeywords(const std::string& pattern, std::vector <Token>& tokens) const;
 
        template<typename CharT, typename Traits = std::char_traits <CharT>>
        friend std::basic_ostream <CharT, Traits>& operator<<(std::basic_ostream <CharT, Traits>& os, const TokenKind& tokenKind) {
            switch (tokenKind) {
                case TokenKind::IDENT:
                    os << "IDENT";
                    break;
                case TokenKind::LEFT:
                    os << "LEFT";
                    break;
                case TokenKind::RIGHT:
                    os << "RIGHT";
                    break;
                case TokenKind::SEPARATOR:
                    os << "SEPARATOR";
                    break;
                case TokenKind::EOS:
                    os << "EOS";
                    break;
                case TokenKind::NON:
                    os << "NON";
                    break;
                case TokenKind::NONE:
                    os << "NONE";
                    break;
                case TokenKind::ANY:
                    os << "ANY";
                    break;
                case TokenKind::TRUE:
                    os << "TRUE";
                    break;
            }
            return os;
        }
 
        template<typename CharT, typename Traits>
        friend std::basic_ostream <CharT, Traits>& operator<<(std::basic_ostream <CharT, Traits>& os, const Token& token) {
            using Utils::Debug::operator<<;
            return os << Utils::Debug::debug(token);
        }
 
    private:
        char left = '(';
        char right = ')';
        char separator = ',';
        std::string blank = "";
        std::set<char> ignore{'\n', ' ', '\t'};
        std::string variablePrefix = "_";
        std::string escapePrefix = "\\";
    };
 
    class TuringStyleMixedSymbolPatternParserBadInitializationException : public Utils::MessageException {
    public:
        TuringStyleMixedSymbolPatternParserBadInitializationException() = delete;
 
        TuringStyleMixedSymbolPatternParserBadInitializationException(
                std::string message,
                char left,
                char right,
                char separator,
                std::string blank,
                std::set<char> ignore,
                const std::string& variablePrefix,
                const std::string& escapePrefix
        ) :
                Utils::MessageException(message),
                left(left),
                right(right),
                separator(separator),
                blank(blank),
                ignore(ignore),
                variablePrefix(variablePrefix),
                escapePrefix(escapePrefix)
        {}
 
        virtual std::string makeFullMessage() const override {
            using Utils::Debug::operator<<;
            std::ostringstream ss;
            ss << this->msg << std::endl;
            ss << "  left: " << left << std::endl;
            ss << "  right: " << right << std::endl;
            ss << "  separator: " << separator << std::endl;
            ss << "  blank: " << blank << std::endl;
            ss << "  ignore: " << Utils::Debug::debug(ignore) << std::endl;
            ss << "  variablePrefix: " << variablePrefix << std::endl;
            ss << "  escapePrefix: " << escapePrefix << std::endl;
            return ss.str();
        }
 
    protected:
        char left;
        char right;
        char separator;
        std::string blank;
        std::set<char> ignore;
        std::string variablePrefix;
        std::string escapePrefix;
    };
 
    class TuringStyleMixedSymbolPatternSyntaxErrorException : public Utils::MessageException {
    public:
        TuringStyleMixedSymbolPatternSyntaxErrorException() = delete;
 
        TuringStyleMixedSymbolPatternSyntaxErrorException(
                std::string message,
                std::string toParse,
                const std::vector<TuringStyleMixedSymbolPatternParser::Token>& tokens,
                size_t position,
                std::string additionalMessage = "") :
                Utils::MessageException(message),
                additionalMessage(additionalMessage),
                toParse(toParse),
                tokens(tokens),
                position(position) {}
 
    protected:
        virtual std::string makeFullMessage() const override {
            using Utils::Debug::operator<<;
            std::ostringstream ss;
            ss << this->msg << std::endl;
            if (!additionalMessage.empty()) {
                ss << "  " << additionalMessage << std::endl;
            }
            ss << "  toParse: " << toParse << std::endl;
            ss << "  tokens (" << tokens.size() << "): " << Utils::Debug::debug(tokens) << std::endl;
            ss << "  position: " << position << std::endl;
            if (position == tokens.size()) {
                ss << "  position at the end" << std::endl;
            } else if (position > tokens.size()) {
                ss << "  position after the end" << std::endl;
            } else {
                ss << "  token at position" << tokens[position] << std::endl;
            }
            return ss.str();
        }
 
        std::string additionalMessage;
        std::string toParse;
        std::vector <TuringStyleMixedSymbolPatternParser::Token> tokens;
        size_t position;
    };
}