wwwc/css_syntax/token.hpp

#pragma once
 
#include <cassert>
#include <memory>
#include <string>
#include <variant>
#include <vector>
 
namespace wordring::wwwc::css
{
    class syntax_primitive;
 
    // --------------------------------------------------------------------------------------------
    // 4. Tokenization
    //
    // https://drafts.csswg.org/css-syntax-3/#tokenization
    // https://triple-underscore.github.io/css-syntax-ja.html#tokenization
    // --------------------------------------------------------------------------------------------
 
    enum class syntax_primitive_name : std::size_t
    {
        Token = 1,        
 
        IdentToken,       
        FunctionToken,    
        AtKeywordToken,   
        HashToken,        
        StringToken,      
        BadStringToken,   
        UrlToken,         
        BadUrlToken,      
        DelimToken,       
        NumberToken,      
        PercentageToken,  
        DimensionToken,   
        WhitespaceToken,  
        CdoToken,         
        CdcToken,         
        ColonToken,       
        SemicolonToken,   
        CommaToken,       
        OpenSquareToken,  
        CloseSquareToken, 
        OpenParenToken,   
        CloseParenToken,  
        OpenCurlyToken,   
        CloseCurlyToken,  
        EofToken,         
 
        SyntaxItem,        
 
        AtRule,          
        QualifiedRule,   
        Declaration,     
        ComponentValue,  
        PreservedTokens, 
        Function,        
        SimpleBlock,     
    };
 
    enum class number_type_flag_name { integer = 1, number };
 
    struct ident_token { std::u32string m_value;  };
 
    struct function_token { std::u32string m_value;  };
 
    struct at_keyword_token { std::u32string m_value;  };
 
    struct hash_token
    {
        enum class type_flag_name
        {
            id = 1,      
            unrestricted 
        };
 
        std::u32string m_value;
        type_flag_name m_type_flag = type_flag_name::unrestricted;
    };
 
    struct string_token { std::u32string m_value;  };
 
    struct bad_string_token {};
 
    struct url_token { std::u32string m_value;  };
 
    struct bad_url_token {};
 
    struct delim_token { char32_t m_value = 0;  };
 
    struct number_token
    {
        double m_value = 0; 
        number_type_flag_name m_type_flag = number_type_flag_name::integer; 
    };
 
    struct percentage_token { double m_value;  };
 
    struct dimension_token
    {
        double m_value = 0;    
        std::u32string m_unit; 
        number_type_flag_name m_type_flag = number_type_flag_name::integer; 
    };
 
    struct whitespace_token {};
 
    struct CDO_token {};
 
    struct CDC_token {};
 
    struct colon_token {};
 
    struct semicolon_token {};
 
    struct comma_token {};
 
    struct open_square_token {};
 
    struct close_square_token {};
 
    struct open_paren_token {};
 
    struct close_paren_token {};
 
    struct open_curly_token {};
 
    struct close_curly_token {};
 
    struct eof_token {};
 
    // --------------------------------------------------------------------------------------------
    // 5. Parsing
    //
    // https://drafts.csswg.org/css-syntax-3/#parsing
    // https://triple-underscore.github.io/css-syntax-ja.html#parsing
    // --------------------------------------------------------------------------------------------
 
    class component_value;
 
    struct function
    {
        std::u32string               m_name;
        std::vector<component_value> m_value;
    };
 
    struct simple_block
    {
        char32_t                     m_associated_token = 0;
        std::vector<component_value> m_value;
    };
 
    class preserved_tokens
    {
        using value_type = std::variant<
            ident_token,
            at_keyword_token,
            hash_token,
            string_token,
            bad_string_token,
            url_token,
            bad_url_token,
            delim_token,
            number_token,
            percentage_token,
            dimension_token,
            whitespace_token,
            CDO_token,
            CDC_token,
            colon_token,
            semicolon_token,
            comma_token,
            close_square_token,
            close_paren_token,
            close_curly_token,
            eof_token>;
    };
 
    class component_value
    {
    public:
        struct container_fn
        {
            container_fn() = default;
            container_fn(container_fn const& rhs);
            container_fn(container_fn&& rhs) = default;
            container_fn(function const& fn);
            ~container_fn();
 
            container_fn& operator=(container_fn const& rhs);
            container_fn& operator=(container_fn&& rhs) = default;
 
            std::unique_ptr<function> m_value;
        };
 
        struct container_sb
        {
            container_sb() = default;
            container_sb(container_sb const& rhs);
            container_sb(container_sb&& rhs) = default;
            container_sb(simple_block const& fn);
            ~container_sb();
 
            container_sb& operator=(container_sb const& rhs);
            container_sb& operator=(container_sb&& rhs) = default;
 
            std::unique_ptr<simple_block> m_value;
        };
 
    public:
        using value_type = std::variant<
            std::monostate,
            ident_token,
            at_keyword_token,
            hash_token,
            string_token,
            bad_string_token,
            url_token,
            bad_url_token,
            delim_token,
            number_token,
            percentage_token,
            dimension_token,
            whitespace_token,
            CDO_token,
            CDC_token,
            colon_token,
            semicolon_token,
            comma_token,
            close_square_token,
            close_paren_token,
            close_curly_token,
            eof_token,
 
            container_fn,
            container_sb>;
 
    public:
        component_value() = default;
        component_value(component_value const&) = default;
        component_value(component_value&&) = default;
 
        explicit component_value(function const& value)
            : m_value(container_fn(value))
        {
        }
 
        explicit component_value(simple_block const& value)
            : m_value(container_sb(value))
        {
        }
 
        explicit component_value(syntax_primitive const& value);
 
        template <typename T>
        explicit component_value(T const& value)
            : m_value(value)
        {
        }
 
        ~component_value();
 
        component_value& operator=(component_value const&) = default;
 
        syntax_primitive_name type() const
        {
            switch (m_value.index())
            {
            case 1:  return syntax_primitive_name::IdentToken;
            case 2:  return syntax_primitive_name::AtKeywordToken;
            case 3:  return syntax_primitive_name::HashToken;
            case 4:  return syntax_primitive_name::StringToken;
            case 5:  return syntax_primitive_name::BadStringToken;
            case 6:  return syntax_primitive_name::UrlToken;
            case 7:  return syntax_primitive_name::BadUrlToken;
            case 8:  return syntax_primitive_name::DelimToken;
            case 9:  return syntax_primitive_name::NumberToken;
            case 10: return syntax_primitive_name::PercentageToken;
            case 11: return syntax_primitive_name::DimensionToken;
            case 12: return syntax_primitive_name::WhitespaceToken;
            case 13: return syntax_primitive_name::CdoToken;
            case 14: return syntax_primitive_name::CdcToken;
            case 15: return syntax_primitive_name::ColonToken;
            case 16: return syntax_primitive_name::SemicolonToken;
            case 17: return syntax_primitive_name::CommaToken;
            case 18: return syntax_primitive_name::CloseSquareToken;
            case 19: return syntax_primitive_name::CloseParenToken;
            case 20: return syntax_primitive_name::CloseCurlyToken;
            case 21: return syntax_primitive_name::EofToken;
 
            case 22: return syntax_primitive_name::Function;
            case 23: return syntax_primitive_name::SimpleBlock;
 
            default:
                break;
            }
            return static_cast<syntax_primitive_name>(0);
        }
 
        bool has_value() const { return m_value.index() != 0; }
 
        template <typename T>
        T& get()
        {
            if constexpr (std::is_same_v<T, function>)
            {
                assert(std::holds_alternative<container_fn>(m_value));
                return *std::get_if<container_fn>(&m_value)->m_value;
            }
            else if constexpr (std::is_same_v<T, simple_block>)
            {
                assert(std::holds_alternative<container_sb>(m_value));
                return *std::get_if<container_sb>(&m_value)->m_value;
            }
            else
            {
                assert(std::holds_alternative<T>(m_value));
                return *std::get_if<T>(&m_value);
            }
        }
 
        template <typename T>
        T const& get() const
        {
            if constexpr (std::is_same_v<T, function>)
            {
                assert(std::holds_alternative<container_fn>(m_value));
                return *std::get_if<container_fn>(&m_value)->m_value;
            }
            else if constexpr (std::is_same_v<T, simple_block>)
            {
                assert(std::holds_alternative<container_sb>(m_value));
                return *std::get_if<container_sb>(&m_value)->m_value;
            }
            else
            {
                assert(std::holds_alternative<T>(m_value));
                return *std::get_if<T>(&m_value);
            }
        }
 
    private:
        value_type m_value;
    };
 
    struct at_rule
    {
        at_rule()
            : m_block()
        {
        }
 
        at_rule(at_rule const& rhs)
            : m_name(rhs.m_name)
            , m_prelude(rhs.m_prelude)
            , m_block()
        {
            if (rhs.m_block) m_block = std::make_unique<simple_block>(*rhs.m_block.get());
        }
 
        at_rule(at_rule&& rhs) = default;
 
        at_rule& operator=(at_rule const& rhs)
        {
            m_name = rhs.m_name;
            m_prelude = rhs.m_prelude;
            m_block = std::make_unique<simple_block>(*rhs.m_block);
 
            return *this;
        }
 
        at_rule& operator=(at_rule&& rhs) = default;
 
        ~at_rule();
 
        std::u32string m_name;
        std::vector<component_value> m_prelude;
        std::unique_ptr<simple_block> m_block;
    };
 
    struct qualified_rule
    {
        std::vector<component_value> m_prelude;
        simple_block m_block;
    };
 
    struct declaration
    {
        std::u32string m_name;
        std::vector<component_value> m_value;
        bool m_important_flag = false;
    };
 
    class syntax_primitive
    {
        using value_type = std::variant<
            std::monostate,
            ident_token,
            function_token,
            at_keyword_token,
            hash_token,
            string_token,
            bad_string_token,
            url_token,
            bad_url_token,
            delim_token,
            number_token,
            percentage_token,
            dimension_token,
            whitespace_token,
            CDO_token,
            CDC_token,
            colon_token,
            semicolon_token,
            comma_token,
            open_square_token,
            close_square_token,
            open_paren_token,
            close_paren_token,
            open_curly_token,
            close_curly_token,
            eof_token,
 
            preserved_tokens,
            function,
            simple_block,
            component_value,
            at_rule,
            qualified_rule,
            declaration>;
 
    public:
        syntax_primitive() = default;
        syntax_primitive(syntax_primitive const& rhs) = default;
        syntax_primitive(syntax_primitive&& rhs) = default;
 
        template <typename T>
        syntax_primitive(T const& token)
            : m_value(token)
        {
        }
 
        syntax_primitive(component_value const& token);
 
        void operator=(syntax_primitive const& rhs) { m_value = rhs.m_value; }
 
        syntax_primitive_name type() const
        {
            switch (m_value.index())
            {
            case 1:  return syntax_primitive_name::IdentToken;
            case 2:  return syntax_primitive_name::FunctionToken;
            case 3:  return syntax_primitive_name::AtKeywordToken;
            case 4:  return syntax_primitive_name::HashToken;
            case 5:  return syntax_primitive_name::StringToken;
            case 6:  return syntax_primitive_name::BadStringToken;
            case 7:  return syntax_primitive_name::UrlToken;
            case 8:  return syntax_primitive_name::BadUrlToken;
            case 9:  return syntax_primitive_name::DelimToken;
            case 10: return syntax_primitive_name::NumberToken;
            case 11: return syntax_primitive_name::PercentageToken;
            case 12: return syntax_primitive_name::DimensionToken;
            case 13: return syntax_primitive_name::WhitespaceToken;
            case 14: return syntax_primitive_name::CdoToken;
            case 15: return syntax_primitive_name::CdcToken;
            case 16: return syntax_primitive_name::ColonToken;
            case 17: return syntax_primitive_name::SemicolonToken;
            case 18: return syntax_primitive_name::CommaToken;
            case 19: return syntax_primitive_name::OpenSquareToken;
            case 20: return syntax_primitive_name::CloseSquareToken;
            case 21: return syntax_primitive_name::OpenParenToken;
            case 22: return syntax_primitive_name::CloseParenToken;
            case 23: return syntax_primitive_name::OpenCurlyToken;
            case 24: return syntax_primitive_name::CloseCurlyToken;
            case 25: return syntax_primitive_name::EofToken;
 
            case 26: return syntax_primitive_name::PreservedTokens;
            case 27: return syntax_primitive_name::Function;
            case 28: return syntax_primitive_name::SimpleBlock;
            case 29: return syntax_primitive_name::ComponentValue;
            case 30: return syntax_primitive_name::AtRule;
            case 31: return syntax_primitive_name::QualifiedRule;
            case 32: return syntax_primitive_name::Declaration;
 
            default:
                break;
            }
            return static_cast<syntax_primitive_name>(0);
        }
 
        bool has_value() const { return m_value.index() != 0; }
 
        template <typename T>
        T& get()
        {
            assert(std::holds_alternative<T>(m_value));
            return *std::get_if<T>(&m_value);
        }
 
        template <typename T>
        T const& get() const
        {
            assert(std::holds_alternative<T>(m_value));
            return *std::get_if<T>(&m_value);
        }
 
    private:
        value_type m_value;
    };
 
    class syntax_primitive_stream
    {
    public:
        using container      = std::vector<syntax_primitive>;
        //using iterator       = typename container::iterator;
        using const_iterator = typename container::const_iterator;
        using value_type     = syntax_primitive;
 
    public:
        syntax_primitive_stream() = default;
        syntax_primitive_stream(syntax_primitive_stream const&) = default;
        syntax_primitive_stream(syntax_primitive_stream&&) = default;
 
        syntax_primitive_stream(container& c);
 
        syntax_primitive_stream(const_iterator first, const_iterator last);
 
        operator bool() const;
 
        bool operator !() const;
 
        std::size_t size() const;
 
        const_iterator begin() const;
 
        const_iterator end() const;
 
        syntax_primitive const& current() const;
 
        syntax_primitive const& consume();
 
        void reconsume();
 
        void advance(const_iterator it);
 
        bool skip_whitespace();
 
    private:
        const_iterator m_first;
        const_iterator m_last;
 
        syntax_primitive m_eof;
    };
}