utf8_checker.hpp

Go to the documentation of this file.

/*
 * RESTinio
 */

/*!
 * @file
 * @brief An implementation of checker for UTF-8 sequences.
 *
 * @since v.0.6.5
 */

#pragma once

#include <restinio/compiler_features.hpp>

#include <cstdint>

namespace restinio
{

namespace utils
{

//
// utf8_checker_t
//

/*!
 * @brief Helper class for checking UTF-8 byte sequence during parsing
 * URI or incoming byte stream.
 *
 * Note: this class is moved to restinio::utils namespace in v.0.6.5.
 */
class utf8_checker_t
{
public:
    utf8_checker_t() = default;

    RESTINIO_NODISCARD
    bool
    process_byte( std::uint8_t byte ) noexcept
    {
        check_overlong( byte );

        if( m_current_symbol_rest_bytes > 0 )
        {
            // check byte is 10xxxxxx.
            if( (byte  & 0xC0) == 0x80 )
            {
                m_current_symbol <<= 6;
                byte &= 0x3F;

                m_current_symbol |= byte;

                if( --m_current_symbol_rest_bytes == 0 )
                {
                    validate_current_symbol();
                }
            }
            else
            {
                m_state = state_t::invalid;
            }
        }
        else
        {
            m_current_symbol = 0;

            if( (byte & 0x80) == 0x00)
            {
                // mask 0xxxxxxx
                m_current_symbol_rest_bytes = 0;
            }
            else if( (byte & 0xE0) == 0xC0)
            {
                // mask 110xxxxx
                m_current_symbol_rest_bytes = 1;
                byte &= 0x1F;
            }
            else if( (byte & 0xF0) == 0xE0)
            {
                // mask 1110xxxx
                m_current_symbol_rest_bytes = 2;
                byte &= 0xF;
            }
            else if( (byte & 0xF8) == 0xF0)
            {
                // mask 11110xxx
                m_current_symbol_rest_bytes = 3;
                byte &= 0x7;
            }
            else if( (byte & 0xFC) == 0xF8)
            {
                // mask 111110xx
                m_current_symbol_rest_bytes = 4;
                byte &= 0x3;
            }
            else if( (byte & 0xFE) == 0xFC)
            {
                // mask 1111110x
                m_current_symbol_rest_bytes = 5;
                byte &= 0x1;
            }
            else
            {
                m_state = state_t::invalid;
            }

            m_current_symbol = byte;
        }

        return m_state == state_t::valid || m_state == state_t::may_be_overlong;
    }

    /*!
     * @return true if the current sequence finalized.
     */
    RESTINIO_NODISCARD
    bool
    finalized() const noexcept
    {
        return m_current_symbol_rest_bytes == 0;
    }

    void
    reset() noexcept
    {
        m_current_symbol = 0;
        m_current_symbol_rest_bytes = 0;
    }

    RESTINIO_NODISCARD
    std::uint32_t
    current_symbol() const noexcept { return m_current_symbol; }

private:

    void
    validate_current_symbol() noexcept
    {
        if( (m_current_symbol >= 0xD800 && m_current_symbol <= 0xDFFF) ||
            (m_current_symbol >= 0x110000) )
        {
            m_state = state_t::invalid;
        }
    }

    void
    check_overlong( std::uint8_t byte ) noexcept
    {
        if( m_current_symbol_rest_bytes > 0 &&
                m_state == state_t::may_be_overlong )
        {
            if( m_current_symbol_rest_bytes == 2 &&
                (byte & 0xE0) == 0x80 )
                m_state = state_t::overlong;
            else if( m_current_symbol_rest_bytes == 3 &&
                (byte & 0xF0) == 0x80 )
                m_state = state_t::overlong;
            else if( m_current_symbol_rest_bytes == 4 &&
                (byte & 0xF8) == 0x80 )
                m_state = state_t::overlong;
            else if( m_current_symbol_rest_bytes == 5 &&
                (byte & 0xFC) == 0x80 )
                m_state = state_t::overlong;
            else
                m_state = state_t::valid;
        }
        else
        {
            if( byte == 0xC0 || byte == 0xC1 )
            {
                m_state = state_t::overlong;
            }
            else if( byte == 0xE0 )
            {
                m_state = state_t::may_be_overlong;
            }
            else if( byte == 0xF0 )
            {
                m_state = state_t::may_be_overlong;
            }
            if( byte == 0xF8 )
            {
                m_state = state_t::may_be_overlong;
            }
            if( byte == 0xFC )
            {
                m_state = state_t::may_be_overlong;
            }
        }
    }

    std::uint32_t m_current_symbol = 0u;

    std::size_t m_current_symbol_rest_bytes = 0u;

    enum class state_t
    {
        valid,
        invalid,
        may_be_overlong,
        overlong
    };

    state_t m_state = state_t::valid;
};

} /* namespace utils */

} /* namespace restinio */