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.Pos`
///@{
enum class Pos : flags_t {
};
 
///@}
 
/// @name `regex.pos`
///@{
enum class pos : flags_t {
};
 
///@}
 
/// @name `regex.Res`
///@{
enum class Res : flags_t {
};
 
///@}
 
/// @name `regex.RE`
///@{
enum class RE : flags_t {
};
 
///@}
 
/// @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 = 0x4c62066400000a00,
    D = 0x4c62066400000a01,
    w = 0x4c62066400000a02,
    W = 0x4c62066400000a03,
    s = 0x4c62066400000a04,
    S = 0x4c62066400000a05,
};
 
///@}
 
/// @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 = 0x4c62066400000d00,
    star = 0x4c62066400000d01,
    plus = 0x4c62066400000d02,
};
 
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::Pos> = 0x4c62066400000000;
template<> constexpr size_t Annex::Num<plug::regex::Pos> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::pos> = 0x4c62066400000100;
template<> constexpr size_t Annex::Num<plug::regex::pos> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::Res> = 0x4c62066400000200;
template<> constexpr size_t Annex::Num<plug::regex::Res> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::RE> = 0x4c62066400000300;
template<> constexpr size_t Annex::Num<plug::regex::RE> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::conj> = 0x4c62066400000400;
template<> constexpr size_t Annex::Num<plug::regex::conj> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::disj> = 0x4c62066400000500;
template<> constexpr size_t Annex::Num<plug::regex::disj> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::range> = 0x4c62066400000600;
template<> constexpr size_t Annex::Num<plug::regex::range> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::lit> = 0x4c62066400000700;
template<> constexpr size_t Annex::Num<plug::regex::lit> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::not_> = 0x4c62066400000800;
template<> constexpr size_t Annex::Num<plug::regex::not_> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::neg_lookahead> = 0x4c62066400000900;
template<> constexpr size_t Annex::Num<plug::regex::neg_lookahead> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::cls> = 0x4c62066400000a00;
template<> constexpr size_t Annex::Num<plug::regex::cls> = 6;
template<> constexpr flags_t Annex::Base<plug::regex::any> = 0x4c62066400000b00;
template<> constexpr size_t Annex::Num<plug::regex::any> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::empty> = 0x4c62066400000c00;
template<> constexpr size_t Annex::Num<plug::regex::empty> = 0;
template<> constexpr flags_t Annex::Base<plug::regex::quant> = 0x4c62066400000d00;
template<> constexpr size_t Annex::Num<plug::regex::quant> = 3;
template<> constexpr flags_t Annex::Base<plug::regex::lower_regex> = 0x4c62066400000e00;
template<> constexpr size_t Annex::Num<plug::regex::lower_regex> = 0;
 
template<> struct Axm::IsANode<plug::regex::Pos> { using type = Axm; };
template<> struct Axm::IsANode<plug::regex::pos> { using type = Axm; };
template<> struct Axm::IsANode<plug::regex::Res> { using type = Axm; };
template<> struct Axm::IsANode<plug::regex::RE> { using type = Axm; };
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