autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.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 {
};
 
const Def* normalize_conj(const Def*, const Def*, const Def*);
///@}
 
/// @name %%regex.disj
///@{
enum class disj : flags_t {
};
 
const Def* normalize_disj(const Def*, const Def*, const Def*);
///@}
 
/// @name %%regex.range
///@{
enum class range : flags_t {
};
 
const Def* normalize_range(const Def*, const Def*, const Def*);
///@}
 
/// @name %%regex.lit
///@{
enum class lit : flags_t {
};
 
///@}
 
/// @name %%regex.not_
///@{
enum class not_ : flags_t {
};
 
const Def* normalize_not(const Def*, const Def*, const Def*);
///@}
 
/// @name %%regex.neg_lookahead
///@{
enum class neg_lookahead : flags_t {
};
 
///@}
 
/// @name %%regex.cls
///@{
enum class cls : flags_t {
    d = 0x4c62066400000600,
    D = 0x4c62066400000601,
    w = 0x4c62066400000602,
    W = 0x4c62066400000603,
    s = 0x4c62066400000604,
    S = 0x4c62066400000605,
};
 
///@}
 
/// @name %%regex.any
///@{
enum class any : flags_t {
};
 
///@}
 
/// @name %%regex.empty
///@{
enum class empty : flags_t {
};
 
///@}
 
/// @name %%regex.quant
///@{
enum class quant : flags_t {
    optional = 0x4c62066400000900,
    star = 0x4c62066400000901,
    plus = 0x4c62066400000902,
};
 
template<quant>
const Def* normalize_quant(const Def*, const Def*, const Def*);
 
///@}
 
/// @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::neg_lookahead> = 0x4c62066400000500;
template<> constexpr size_t Annex::Num<plug::regex::neg_lookahead> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::cls> = 0x4c62066400000600;
template<> constexpr size_t Annex::Num<plug::regex::cls> = 6;
template<> constexpr flags_t Annex::Base<plug::regex::any> = 0x4c62066400000700;
template<> constexpr size_t Annex::Num<plug::regex::any> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::empty> = 0x4c62066400000800;
template<> constexpr size_t Annex::Num<plug::regex::empty> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::quant> = 0x4c62066400000900;
template<> constexpr size_t Annex::Num<plug::regex::quant> = 3;
template<> constexpr flags_t Annex::Base<plug::regex::lower_regex> = 0x4c62066400000a00;
template<> constexpr size_t Annex::Num<plug::regex::lower_regex> = 0;
 
template<> struct Axm::IsANode<plug::regex::lit> { using type = Axm; };
template<> struct Axm::IsANode<plug::regex::cls> { using type = Axm; };
template<> struct Axm::IsANode<plug::regex::any> { using type = Axm; };
template<> struct Axm::IsANode<plug::regex::empty> { using type = Axm; };
template<> struct Axm::IsANode<plug::regex::lower_regex> { using type = Axm; };
 
#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