autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axiom.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::regex @ref regex 
namespace mim {
namespace plug::regex {
 
static constexpr plugin_t Plugin_Id = 0x4c62066400000000;
 
/// @name %%regex.conj
///@{
enum class conj : flags_t {
};
 
Ref normalize_conj(Ref, Ref, Ref);
///@}
 
/// @name %%regex.disj
///@{
enum class disj : flags_t {
};
 
Ref normalize_disj(Ref, Ref, Ref);
///@}
 
/// @name %%regex.range
///@{
enum class range : flags_t {
};
 
Ref normalize_range(Ref, Ref, Ref);
///@}
 
/// @name %%regex.lit
///@{
enum class lit : flags_t {
};
 
///@}
 
/// @name %%regex.not_
///@{
enum class not_ : flags_t {
};
 
Ref normalize_not(Ref, Ref, Ref);
///@}
 
/// @name %%regex.cls
///@{
enum class cls : flags_t {
    d = 0x4c62066400000500,
    D = 0x4c62066400000501,
    w = 0x4c62066400000502,
    W = 0x4c62066400000503,
    s = 0x4c62066400000504,
    S = 0x4c62066400000505,
};
 
///@}
 
/// @name %%regex.any
///@{
enum class any : flags_t {
};
 
///@}
 
/// @name %%regex.quant
///@{
enum class quant : flags_t {
    optional = 0x4c62066400000700,
    star = 0x4c62066400000701,
    plus = 0x4c62066400000702,
};
 
template<quant>
Ref normalize_quant(Ref, Ref, Ref);
 
///@}
 
/// @name %%regex.lower_regex
///@{
enum class lower_regex : flags_t {
};
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_regex_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(Annex::Base<conj>)] = &normalize_conj; \
        normalizers[flags_t(Annex::Base<disj>)] = &normalize_disj; \
        normalizers[flags_t(Annex::Base<range>)] = &normalize_range; \
        normalizers[flags_t(Annex::Base<not_>)] = &normalize_not; \
        normalizers[flags_t(quant::optional)] = &normalize_quant<quant::optional>; \
        normalizers[flags_t(quant::star)] = &normalize_quant<quant::star>; \
        normalizers[flags_t(quant::plus)] = &normalize_quant<quant::plus>; \
    }
} // namespace plug::regex
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::regex::conj> = 0x4c62066400000000;
template<> constexpr size_t Annex::Num<plug::regex::conj> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::disj> = 0x4c62066400000100;
template<> constexpr size_t Annex::Num<plug::regex::disj> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::range> = 0x4c62066400000200;
template<> constexpr size_t Annex::Num<plug::regex::range> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::lit> = 0x4c62066400000300;
template<> constexpr size_t Annex::Num<plug::regex::lit> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::not_> = 0x4c62066400000400;
template<> constexpr size_t Annex::Num<plug::regex::not_> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::cls> = 0x4c62066400000500;
template<> constexpr size_t Annex::Num<plug::regex::cls> = 6;
template<> constexpr flags_t Annex::Base<plug::regex::any> = 0x4c62066400000600;
template<> constexpr size_t Annex::Num<plug::regex::any> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::quant> = 0x4c62066400000700;
template<> constexpr size_t Annex::Num<plug::regex::quant> = 3;
template<> constexpr flags_t Annex::Base<plug::regex::lower_regex> = 0x4c62066400000800;
template<> constexpr size_t Annex::Num<plug::regex::lower_regex> = 0;
 
template<> struct Axiom::Match<plug::regex::lit> { using type = Axiom; };
template<> struct Axiom::Match<plug::regex::cls> { using type = Axiom; };
template<> struct Axiom::Match<plug::regex::lower_regex> { using type = Axiom; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> struct fe::is_bit_enum<mim::plug::regex::cls> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::regex::quant> : std::true_type {};
 
#endif