autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::refly @ref refly
namespace mim {
namespace plug::refly {
 
static constexpr plugin_t Plugin_Id = 0x4c61cd6800000000;
 
/// @name `refly.Code`
///@{
enum class Code : flags_t {
};
 
///@}
 
/// @name `refly.reify`
///@{
enum class reify : flags_t {
};
 
const Def* normalize_reify(const Def*, const Def*, const Def*);
///@}
 
/// @name `refly.reflect`
///@{
enum class reflect : flags_t {
};
 
const Def* normalize_reflect(const Def*, const Def*, const Def*);
///@}
 
/// @name `refly.type`
///@{
enum class type : flags_t {
};
 
const Def* normalize_type(const Def*, const Def*, const Def*);
///@}
 
/// @name `refly.gid`
///@{
enum class gid : flags_t {
};
 
const Def* normalize_gid(const Def*, const Def*, const Def*);
///@}
 
/// @name `refly.error`
///@{
enum class error : flags_t {
};
 
///@}
 
/// @name `refly.warn`
///@{
enum class warn : flags_t {
};
 
///@}
 
/// @name `refly.info`
///@{
enum class info : flags_t {
};
 
///@}
 
/// @name `refly.verbose`
///@{
enum class verbose : flags_t {
};
 
///@}
 
/// @name `refly.debug`
///@{
enum class debug : flags_t {
};
 
///@}
 
/// @name `refly.dbg`
///@{
enum class dbg : flags_t {
    tmp = 0x4c61cd6800000a00,
    perm = 0x4c61cd6800000a01,
};
 
template<dbg>
const Def* normalize_dbg(const Def*, const Def*, const Def*);
 
///@}
 
/// @name `refly.struc`
///@{
enum class struc : flags_t {
    ne = 0x4c61cd6800000b00,
    e = 0x4c61cd6800000b01,
};
 
template<struc>
const Def* normalize_struc(const Def*, const Def*, const Def*);
 
///@}
 
/// @name `refly.alpha`
///@{
enum class alpha : flags_t {
    ne = 0x4c61cd6800000c00,
    e = 0x4c61cd6800000c01,
};
 
template<alpha>
const Def* normalize_alpha(const Def*, const Def*, const Def*);
 
///@}
 
/// @name `refly.check_bot`
///@{
enum class check_bot : flags_t {
};
 
const Def* normalize_check_bot(const Def*, const Def*, const Def*);
///@}
 
/// @name `refly.check`
///@{
enum class check : flags_t {
};
 
const Def* normalize_check(const Def*, const Def*, const Def*);
///@}
 
/// @name `refly.remove_dbg_repl`
///@{
enum class remove_dbg_repl : flags_t {
};
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_refly_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(Annex::Base<reify>)] = &normalize_reify; \
        normalizers[flags_t(Annex::Base<reflect>)] = &normalize_reflect; \
        normalizers[flags_t(Annex::Base<type>)] = &normalize_type; \
        normalizers[flags_t(Annex::Base<gid>)] = &normalize_gid; \
        normalizers[flags_t(dbg::tmp)] = &normalize_dbg<dbg::tmp>; \
        normalizers[flags_t(dbg::perm)] = &normalize_dbg<dbg::perm>; \
        normalizers[flags_t(struc::ne)] = &normalize_struc<struc::ne>; \
        normalizers[flags_t(struc::e)] = &normalize_struc<struc::e>; \
        normalizers[flags_t(alpha::ne)] = &normalize_alpha<alpha::ne>; \
        normalizers[flags_t(alpha::e)] = &normalize_alpha<alpha::e>; \
        normalizers[flags_t(Annex::Base<check_bot>)] = &normalize_check_bot; \
        normalizers[flags_t(Annex::Base<check>)] = &normalize_check; \
    }
} // namespace plug::refly
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::refly::Code> = 0x4c61cd6800000000;
template<> constexpr size_t Annex::Num<plug::refly::Code> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::reify> = 0x4c61cd6800000100;
template<> constexpr size_t Annex::Num<plug::refly::reify> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::reflect> = 0x4c61cd6800000200;
template<> constexpr size_t Annex::Num<plug::refly::reflect> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::type> = 0x4c61cd6800000300;
template<> constexpr size_t Annex::Num<plug::refly::type> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::gid> = 0x4c61cd6800000400;
template<> constexpr size_t Annex::Num<plug::refly::gid> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::error> = 0x4c61cd6800000500;
template<> constexpr size_t Annex::Num<plug::refly::error> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::warn> = 0x4c61cd6800000600;
template<> constexpr size_t Annex::Num<plug::refly::warn> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::info> = 0x4c61cd6800000700;
template<> constexpr size_t Annex::Num<plug::refly::info> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::verbose> = 0x4c61cd6800000800;
template<> constexpr size_t Annex::Num<plug::refly::verbose> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::debug> = 0x4c61cd6800000900;
template<> constexpr size_t Annex::Num<plug::refly::debug> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::dbg> = 0x4c61cd6800000a00;
template<> constexpr size_t Annex::Num<plug::refly::dbg> = 2;
template<> constexpr flags_t Annex::Base<plug::refly::struc> = 0x4c61cd6800000b00;
template<> constexpr size_t Annex::Num<plug::refly::struc> = 2;
template<> constexpr flags_t Annex::Base<plug::refly::alpha> = 0x4c61cd6800000c00;
template<> constexpr size_t Annex::Num<plug::refly::alpha> = 2;
template<> constexpr flags_t Annex::Base<plug::refly::check_bot> = 0x4c61cd6800000d00;
template<> constexpr size_t Annex::Num<plug::refly::check_bot> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::check> = 0x4c61cd6800000e00;
template<> constexpr size_t Annex::Num<plug::refly::check> = 0;
template<> constexpr flags_t Annex::Base<plug::refly::remove_dbg_repl> = 0x4c61cd6800000f00;
template<> constexpr size_t Annex::Num<plug::refly::remove_dbg_repl> = 0;
 
template<> struct Axm::IsANode<plug::refly::error> { using type = Axm; };
template<> struct Axm::IsANode<plug::refly::warn> { using type = Axm; };
template<> struct Axm::IsANode<plug::refly::info> { using type = Axm; };
template<> struct Axm::IsANode<plug::refly::verbose> { using type = Axm; };
template<> struct Axm::IsANode<plug::refly::debug> { using type = Axm; };
template<> struct Axm::IsANode<plug::refly::remove_dbg_repl> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> struct fe::is_bit_enum<mim::plug::refly::dbg> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::refly::struc> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::refly::alpha> : std::true_type {};
 
#endif