lexer.hpp

#pragma once
 
#include "fly/types/string/concepts.hpp"
#include "fly/types/string/detail/classifier.hpp"
#include "fly/types/string/detail/traits.hpp"
#include "fly/types/string/literals.hpp"
 
#include <cstdint>
#include <optional>
 
namespace fly {
 
template <StandardCharacter CharType>
class BasicLexer;
 
using Lexer = BasicLexer<char>;
using WLexer = BasicLexer<wchar_t>;
using Lexer8 = BasicLexer<char8_t>;
using Lexer16 = BasicLexer<char16_t>;
using Lexer32 = BasicLexer<char32_t>;
 
template <StandardCharacter CharType>
class BasicLexer
{
    using traits = detail::BasicStringTraits<CharType>;
    using classifier = detail::BasicClassifier<CharType>;
    using view_type = typename traits::view_type;
 
public:
    template <std::size_t N>
    constexpr explicit BasicLexer(const CharType (&literals)[N]) noexcept;
 
    constexpr explicit BasicLexer(view_type view) noexcept;
 
    constexpr view_type view() const;
 
    constexpr std::size_t position() const;
 
    constexpr void set_position(std::size_t position);
 
    constexpr std::optional<CharType> peek(std::size_t offset = 0);
 
    constexpr std::optional<CharType> consume();
 
    constexpr bool consume_if(CharType ch);
 
    constexpr std::optional<std::uintmax_t> consume_number();
 
    constexpr std::optional<std::uintmax_t> consume_hex_number();
 
private:
    template <typename Condition>
    constexpr std::optional<CharType> consume_if(Condition condition);
 
    static constexpr const auto s_zero = FLY_CHR(CharType, '0');
    static constexpr const auto s_upper_a = FLY_CHR(CharType, 'A');
    static constexpr const auto s_upper_f = FLY_CHR(CharType, 'F');
    static constexpr const auto s_lower_a = FLY_CHR(CharType, 'a');
    static constexpr const auto s_lower_f = FLY_CHR(CharType, 'f');
 
    const std::size_t m_size;
    const view_type m_view;
 
    std::size_t m_index {0};
};
 
//==================================================================================================
template <StandardCharacter CharType>
template <std::size_t N>
constexpr BasicLexer<CharType>::BasicLexer(const CharType (&literals)[N]) noexcept :
    m_size(classifier::size(literals)),
    m_view(literals, m_size)
{
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr BasicLexer<CharType>::BasicLexer(view_type view) noexcept :
    m_size(view.size()),
    m_view(std::move(view))
{
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr auto BasicLexer<CharType>::view() const -> view_type
{
    return m_view;
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr std::size_t BasicLexer<CharType>::position() const
{
    return m_index;
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr void BasicLexer<CharType>::set_position(std::size_t position)
{
    m_index = position;
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr std::optional<CharType> BasicLexer<CharType>::peek(std::size_t offset)
{
    if ((m_index + offset) >= m_size)
    {
        return std::nullopt;
    }
 
    return *(m_view.data() + m_index + offset);
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr std::optional<CharType> BasicLexer<CharType>::consume()
{
    if (m_index >= m_size)
    {
        return std::nullopt;
    }
 
    return *(m_view.data() + m_index++);
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr bool BasicLexer<CharType>::consume_if(CharType ch)
{
    if (auto next = peek(); next && (next.value() == ch))
    {
        ++m_index;
        return true;
    }
 
    return false;
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr std::optional<std::uintmax_t> BasicLexer<CharType>::consume_number()
{
    bool parsed_number = false;
    std::uintmax_t number = 0;
 
    while (auto ch = consume_if(classifier::is_digit))
    {
        parsed_number = true;
 
        number *= 10;
        number += static_cast<std::uintmax_t>(ch.value() - s_zero);
    }
 
    return parsed_number ? std::optional<std::uintmax_t>(number) : std::nullopt;
}
 
//==================================================================================================
template <StandardCharacter CharType>
constexpr std::optional<std::uintmax_t> BasicLexer<CharType>::consume_hex_number()
{
    bool parsed_number = false;
    std::uintmax_t number = 0;
 
    while (auto ch = consume_if(classifier::is_x_digit))
    {
        parsed_number = true;
        number *= 16;
 
        if ((ch.value() >= s_upper_a) && (ch.value() <= s_upper_f))
        {
            number += static_cast<std::uintmax_t>(ch.value()) - s_upper_a + 0xA;
        }
        else if ((ch.value() >= s_lower_a) && (ch.value() <= s_lower_f))
        {
            number += static_cast<std::uintmax_t>(ch.value()) - s_lower_a + 0xa;
        }
        else
        {
            number += static_cast<std::uintmax_t>(ch.value()) - s_zero;
        }
    }
 
    return parsed_number ? std::optional<std::uintmax_t>(number) : std::nullopt;
}
 
//==================================================================================================
template <StandardCharacter CharType>
template <typename Condition>
constexpr std::optional<CharType> BasicLexer<CharType>::consume_if(Condition condition)
{
    if (auto next = peek(); next && condition(next.value()))
    {
        return consume();
    }
 
    return std::nullopt;
}
 
} // namespace fly