char_class.hpp File Reference

#include <lexy/_detail/code_point.hpp>
#include <lexy/_detail/swar.hpp>
#include <lexy/dsl/base.hpp>
#include <lexy/dsl/token.hpp>

Include dependency graph for char_class.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	lexyd::_calt< Cs >
struct	lexyd::_cand< Cs >
struct	lexyd::_cb< Byte >
struct	lexyd::_ccomp< C >
struct	lexyd::_ccp< Cp >
struct	lexyd::_cminus< Set, Minus >
struct	lexyd::_lcp< Cp >
struct	lexyd::_lit< CharT, C >
struct	lexy::_detail::ascii_set
struct	lexy::_detail::ascii_set_matcher< CompressedAsciiSet, typename, typename >
struct	lexy::_detail::ascii_set_matcher< CompressedAsciiSet, index_sequence< RangeIdx... >, index_sequence< SingleIdx... > >
struct	lexyd::char_class_base< Derived >
struct	lexy::_detail::compressed_ascii_set< RangeCount, SingleCount >
struct	lexyd::char_class_base< Derived >::tp< Reader >

Namespaces
	lexy
	lexy::_detail
	lexyd

Macros
#define	LEXY_CHAR_CLASS(Name, Rule)

Functions
template<typename C , typename = std::enable_if_t<lexy::is_char_class_rule<C>>>
constexpr auto	lexyd::_make_char_class (C c)
template<typename T >
constexpr auto	lexy::_detail::compress_ascii_set ()
template<typename... Cs, typename... Ds>
constexpr auto	lexyd::operator& (_cand< Cs... >, _cand< Ds... >) -> _cand< Cs..., Ds... >
template<typename... Cs, typename C >
constexpr auto	lexyd::operator& (_cand< Cs... >, C c) -> _cand< Cs..., decltype(_make_char_class(c))>
template<typename C , typename... Cs>
constexpr auto	lexyd::operator& (C c, _cand< Cs... >) -> _cand< decltype(_make_char_class(c)), Cs... >
template<typename C1 , typename C2 >
constexpr auto	lexyd::operator& (C1 c1, C2 c2) -> _cand< decltype(_make_char_class(c1)), decltype(_make_char_class(c2))>
template<typename C >
constexpr auto	lexyd::operator- (_ccomp< C >) -> C
template<typename Set , typename Minus , typename OtherMinus >
constexpr auto	lexyd::operator- (_cminus< Set, Minus >, OtherMinus other)
template<typename C >
constexpr auto	lexyd::operator- (C c) -> _ccomp< decltype(_make_char_class(c))>
template<typename Set , typename Minus >
constexpr auto	lexyd::operator- (Set, Minus minus)
template<typename... Cs, typename... Ds>
constexpr auto	lexyd::operator/ (_calt< Cs... >, _calt< Ds... >) -> _calt< Cs..., Ds... >
template<typename... Cs, typename C >
constexpr auto	lexyd::operator/ (_calt< Cs... >, C c) -> _calt< Cs..., decltype(_make_char_class(c))>
template<typename C , typename... Cs>
constexpr auto	lexyd::operator/ (C c, _calt< Cs... >) -> _calt< decltype(_make_char_class(c)), Cs... >
template<typename R1 , typename R2 >
constexpr auto	lexyd::operator/ (R1 r1, R2 r2) -> _calt< decltype(_make_char_class(r1)), decltype(_make_char_class(r2))>

Variables
template<typename CharSet >
constexpr auto	lexyd::_cas = lexy::_detail::compress_ascii_set<CharSet>()

Macro Definition Documentation

LEXY_CHAR_CLASS

#define LEXY_CHAR_CLASS	(		Name,
			Rule
	)

Value:

    [] {                                                                                           \
        static_assert(::lexy::is_char_class_rule<LEXY_DECAY_DECLTYPE(Rule)>);                      \
        struct c : ::lexyd::char_class_base<c>                                                     \
        {                                                                                          \
            static constexpr auto char_class_unicode()                                             \
            {                                                                                      \
                return (Rule).char_class_unicode();                                                \
            }                                                                                      \
            static LEXY_CONSTEVAL auto char_class_name()                                           \
            {                                                                                      \
                return Name;                                                                       \
            }                                                                                      \
            static LEXY_CONSTEVAL auto char_class_ascii()                                          \
            {                                                                                      \
                return (Rule).char_class_ascii();                                                  \
            }                                                                                      \
            static constexpr auto char_class_match_cp(char32_t cp)                                 \
            {                                                                                      \
                return (Rule).char_class_match_cp(cp);                                             \
            }                                                                                      \
        };                                                                                         \
        return c{};                                                                                \
    }()

Definition at line 271 of file char_class.hpp.