Relocation.h File Reference

Go to the source code of this file.

Classes
class	REL::detail::memory_map
struct	REL::detail::meets_length_req< T >
struct	REL::detail::meets_function_req< T >
struct	REL::detail::meets_member_req< T >
struct	REL::detail::is_x64_pod< T, class >
struct	REL::detail::is_x64_pod< T, std::enable_if_t< std::is_union_v< T > > >
struct	REL::detail::is_x64_pod< T, std::enable_if_t< std::is_class_v< T > > >
class	REL::Version
class	REL::Segment
class	REL::Module
class	REL::IDDatabase
class	REL::IDDatabase::Offset2ID
class	REL::Offset
class	REL::ID
class	REL::Relocation< T >
class	REL::detail::rules::Hexadecimal< HI, LO >
class	REL::detail::rules::Wildcard
class	REL::detail::PatternMatcher< Rules >

Namespaces
namespace	REL
namespace	REL::detail
namespace	REL::detail::characters
namespace	REL::detail::rules
namespace	REL::detail::rules::detail

Macros
#define	REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER_IMPL(a_nopropQual, a_propQual, ...)
#define	REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER(a_qualifer, ...)
#define	REL_MAKE_MEMBER_FUNCTION_POD_TYPE(...)
#define	REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER_IMPL(a_nopropQual, a_propQual, ...)
#define	REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER(a_qualifer, ...)
#define	REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE(...)

Typedefs
template<class F >
using	REL::detail::member_function_pod_type_t = typename member_function_pod_type< F >::type
template<class F >
using	REL::detail::member_function_non_pod_type_t = typename member_function_non_pod_type< F >::type

Functions
	REL::detail::REL_MAKE_MEMBER_FUNCTION_POD_TYPE ()
	REL::detail::REL_MAKE_MEMBER_FUNCTION_POD_TYPE (const)
	REL::detail::REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE ()
	REL::detail::REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE (const)
template<class F , class First , class... Rest>
decltype(auto)	REL::detail::invoke_member_function_non_pod (F &&a_func, First &&a_first, Rest &&... a_rest) noexcept(std::is_nothrow_invocable_v< F, First, Rest... >)
template<class F , class... Args> requires (std::invocable<F, Args...>)
std::invoke_result_t< F, Args... >	REL::invoke (F &&a_func, Args &&... a_args) noexcept(std::is_nothrow_invocable_v< F, Args... >)
void	REL::safe_write (std::uintptr_t a_dst, const void *a_src, std::size_t a_count)
template<std::integral T>
void	REL::safe_write (std::uintptr_t a_dst, const T &a_data)
template<class T >
void	REL::safe_write (std::uintptr_t a_dst, std::span< T > a_data)
void	REL::safe_fill (std::uintptr_t a_dst, std::uint8_t a_value, std::size_t a_count)
constexpr bool	REL::operator== (const Version &a_lhs, const Version &a_rhs) noexcept
constexpr std::strong_ordering	REL::operator<=> (const Version &a_lhs, const Version &a_rhs) noexcept
std::optional< Version >	REL::get_file_version (stl::zwstring a_filename)
constexpr bool	REL::detail::characters::hexadecimal (char a_ch) noexcept
constexpr bool	REL::detail::characters::space (char a_ch) noexcept
constexpr bool	REL::detail::characters::wildcard (char a_ch) noexcept
consteval std::byte	REL::detail::rules::detail::hexacharacters_to_hexadecimal (char a_hi, char a_lo) noexcept
template<char , char >
void	REL::detail::rules::rule_for () noexcept
template<char C1, char C2> requires (characters::hexadecimal(C1) && characters::hexadecimal(C2))
Hexadecimal< C1, C2 >	REL::detail::rules::rule_for () noexcept
template<char C1, char C2> requires (characters::wildcard(C1) && characters::wildcard(C2))
Wildcard	REL::detail::rules::rule_for () noexcept
void	REL::detail::consteval_error (const char *a_error)
template<stl::nttp::string S, class... Rules>
constexpr auto	REL::detail::do_make_pattern () noexcept
template<class... Bytes>
consteval auto	REL::detail::make_byte_array (Bytes... a_bytes) noexcept -> std::array< std::byte, sizeof...(Bytes)>
template<stl::nttp::string S>
constexpr auto	REL::make_pattern () noexcept

Variables
template<class T >
constexpr bool	REL::detail::is_x64_pod_v = is_x64_pod<T>::value
constexpr std::uint8_t	REL::NOP = 0x90
constexpr std::uint8_t	REL::RET = 0xC3
constexpr std::uint8_t	REL::INT3 = 0xCC

Macro Definition Documentation

REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE

#define REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE

(

...

)

Value:

    REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER(, __VA_ARGS__)    \
    REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER(&, ##__VA_ARGS__) \
    REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER(&&, ##__VA_ARGS__)

REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER

#define REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER	(		a_qualifer,
			...
	)

Value:

    REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER_IMPL(a_qualifer, , ##__VA_ARGS__) \
    REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER_IMPL(a_qualifer, noexcept, ##__VA_ARGS__)

REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER_IMPL

#define REL_MAKE_MEMBER_FUNCTION_NON_POD_TYPE_HELPER_IMPL	(		a_nopropQual,
			a_propQual,
			...
	)

Value:

    template <                                                                                        \
        class R,                                                                                      \
        class Cls,                                                                                    \
        class... Args>                                                                                \
    struct member_function_non_pod_type<R (Cls::*)(Args...) __VA_ARGS__ a_nopropQual a_propQual>      \
    {                                                                                                 \
        using type = R&(__VA_ARGS__ Cls*, void*, Args...)a_propQual;                                  \
    };                                                                                                \
                                                                                                      \
    template <                                                                                        \
        class R,                                                                                      \
        class Cls,                                                                                    \
        class... Args>                                                                                \
    struct member_function_non_pod_type<R (Cls::*)(Args..., ...) __VA_ARGS__ a_nopropQual a_propQual> \
    {                                                                                                 \
        using type = R&(__VA_ARGS__ Cls*, void*, Args..., ...)a_propQual;                             \
    };

REL_MAKE_MEMBER_FUNCTION_POD_TYPE

#define REL_MAKE_MEMBER_FUNCTION_POD_TYPE

(

...

)

Value:

    REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER(, __VA_ARGS__)    \
    REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER(&, ##__VA_ARGS__) \
    REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER(&&, ##__VA_ARGS__)

REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER

#define REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER	(		a_qualifer,
			...
	)

Value:

    REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER_IMPL(a_qualifer, , ##__VA_ARGS__) \
    REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER_IMPL(a_qualifer, noexcept, ##__VA_ARGS__)

REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER_IMPL

#define REL_MAKE_MEMBER_FUNCTION_POD_TYPE_HELPER_IMPL	(		a_nopropQual,
			a_propQual,
			...
	)

Value:

    template <                                                                                    \
        class R,                                                                                  \
        class Cls,                                                                                \
        class... Args>                                                                            \
    struct member_function_pod_type<R (Cls::*)(Args...) __VA_ARGS__ a_nopropQual a_propQual>      \
    {                                                                                             \
        using type = R(__VA_ARGS__ Cls*, Args...) a_propQual;                                     \
    };                                                                                            \
                                                                                                  \
    template <                                                                                    \
        class R,                                                                                  \
        class Cls,                                                                                \
        class... Args>                                                                            \
    struct member_function_pod_type<R (Cls::*)(Args..., ...) __VA_ARGS__ a_nopropQual a_propQual> \
    {                                                                                             \
        using type = R(__VA_ARGS__ Cls*, Args..., ...) a_propQual;                                \
    };