Compiler Explorer

Source code

#include <concepts>
#include <functional>
#include <type_traits>

namespace moar
{
	namespace types
	{
		struct variadic_t {};

struct calling_convention {};
		struct cdecl_t : calling_convention {};
		struct stdcall_t : calling_convention {};
		struct thiscall_t : calling_convention {};
		struct fastcall_t : calling_convention {};
		struct vectorcall_t : calling_convention {};
		struct regcall_t : calling_convention {};

using default_variadic = void;
		using default_calling_convention = cdecl_t;
	}
}

namespace moar
{
	namespace concepts
	{
		template<typename T>
		concept Function = std::is_function_v<T>;

template<typename T>
		concept CallingConvention = std::derived_from<T, types::calling_convention>;

template<typename T>
		concept Variadic = std::is_same_v<T, types::variadic_t> || std::is_same_v<T, void>;

template<typename T>
		concept CommonType = CallingConvention<T> || Variadic<T>;
	}
}

namespace moar
{
	namespace type_traits
	{
		/// <summary>
		/// Selects T1 or T2 depending on if T1 or T2 is Variadic
		/// </summary>
		template<concepts::CommonType T1, concepts::CommonType T2>
		struct SelectVariadic {
			static_assert(sizeof(T1) == 0 || sizeof(T2) == 0, "Incorrect Usage of SelectVariadic (T1 and/or T2 missing.)");
			using type = void;
		};

template<concepts::CallingConvention T1, concepts::Variadic T2>
		struct SelectVariadic<T1, T2> { using type = T2; };

template<concepts::Variadic T1, concepts::CallingConvention T2>
		struct SelectVariadic<T1, T2> { using type = T1; };

/// <summary>
		/// Selects T1 or T2 depending on if T1 or T2 is a Calling Convention
		/// </summary>
		template<concepts::CommonType T1, concepts::CommonType T2>
		struct SelectCallingConvention {
			static_assert(sizeof(T1) == 0 || sizeof(T2) == 0, "Incorrect Usage of SelectCallingConvention (T1 and/or T2 missing.)");
			using type = void;
		};

template<concepts::CallingConvention T1, concepts::Variadic T2>
		struct SelectCallingConvention<T1, T2> { using type = T1; };

template<concepts::Variadic T1, concepts::CallingConvention T2>
		struct SelectCallingConvention<T1, T2> { using type = T2; };

template<typename T>
		struct SelectDefaultT3 {
			static_assert(sizeof(T) == 0, "Incorrect Usage of SelectDefaultT3 (T missing.)");
			using type = void;
		};

template<concepts::Variadic T>
		struct SelectDefaultT3<T> { using type = types::default_calling_convention; };

template<concepts::CallingConvention T>
		struct SelectDefaultT3<T> { using type = types::default_variadic; };

}
}

namespace moar
{
	/* https://en.cppreference.com/w/cpp/experimental/observer_ptr */
	template<typename T>
	class extern_ptr
	{
	public:

using element_type = std::remove_extent_t<T>;

constexpr element_type* release() noexcept { auto rt = get(); reset(); return rt; }

constexpr void reset(element_type* new_ptr = nullptr) noexcept { this->immutable_ptr = new_ptr; reset_internal(new_ptr); }

constexpr void swap(extern_ptr<element_type>& other) noexcept
		{
			element_type* first = get();
			element_type* second = other.get();
			reset(second);
			other.reset(first);
		}

[[nodiscard]] constexpr auto get() const noexcept { return immutable_ptr; }

[[nodiscard]] constexpr explicit operator bool() const noexcept { return get() != nullptr; }

[[nodiscard]] constexpr auto operator*() const { return *immutable_ptr; } /* when T is function *T is disallowed; auto returns T* instead of T for *T for functions. */

[[nodiscard]] constexpr auto operator->() const noexcept { return immutable_ptr; }

[[nodiscard]] constexpr explicit operator auto () const noexcept { return get(); };

explicit extern_ptr(void* address) { immutable_ptr = reinterpret_cast<element_type*>(address); }

extern_ptr() : extern_ptr(nullptr) {};

protected:
		element_type* immutable_ptr;

private:
		virtual void reset_internal(element_type* new_ptr) {};
	};

template <typename T>
	[[nodiscard]] constexpr auto make_extern(T* pointer) noexcept { return extern_ptr(pointer); }

/*	Explicit implementations of the various comparision operators.
		https://en.cppreference.com/w/cpp/experimental/observer_ptr/operator_cmp
	*/
	template<class T1, class T2>
	[[nodiscard]] constexpr auto operator==(const extern_ptr<T1>& p1, const extern_ptr<T2>& p2) noexcept { return p1.get() == p2.get(); }

template<class T1, class T2>
	[[nodiscard]] constexpr auto operator!=(const extern_ptr<T1>& p1, const extern_ptr<T2>& p2) noexcept { return !(p1 == p2); }

template<class T>
	[[nodiscard]] constexpr auto operator==(const extern_ptr<T>& p, std::nullptr_t) noexcept { return p == nullptr; }

template<class T>
	[[nodiscard]] constexpr auto operator==(std::nullptr_t, const extern_ptr<T>& p) noexcept { return p == nullptr; }

template<class T>
	[[nodiscard]] constexpr auto operator!=(const extern_ptr<T>& p, std::nullptr_t) noexcept { return p != nullptr; }

template<class T>
	[[nodiscard]] constexpr auto operator!=(std::nullptr_t, const extern_ptr<T>& p) noexcept { return p != nullptr; }

template<class T1, class T2>
	[[nodiscard]] constexpr auto operator<(const extern_ptr<T1>& p1, const extern_ptr<T2>& p2) noexcept { return std::less<std::common_type_t<T1*, T2*>>()(p1.get(), p2.get()); }

template<class T1, class T2>
	[[nodiscard]] constexpr auto operator>(const extern_ptr<T1>& p1, const extern_ptr<T2>& p2) noexcept { return p2 < p1; }

template<class T1, class T2>
	[[nodiscard]] constexpr auto operator<=(const extern_ptr<T1>& p1, const extern_ptr<T2>& p2) noexcept { return !(p2 < p1); }

template<class T1, class T2>
	[[nodiscard]] constexpr auto operator>=(const extern_ptr<T1>& p1, const extern_ptr<T2>& p2) noexcept { return !(p1 < p2); }

/* Explicit implementation of extern_ptr<T> ==/!= T* */
	template<class T1, class T2>
	[[nodiscard]] constexpr auto operator==(const extern_ptr<T1>& p1, T2 p2) noexcept requires std::is_pointer_v<T2> { return p1.get() == p2; }

template<class T1, class T2>
	[[nodiscard]] constexpr auto operator!=(const extern_ptr<T1>& p1, T2 p2) noexcept requires std::is_pointer_v<T2> { return !(p1 == p2); }

/* Handle (extern_ptr<T>, T*) */
	template<class T1, class T2>
	[[nodiscard]] constexpr auto operator<(const extern_ptr<T1>& p1, const T2 p2) noexcept requires std::is_pointer_v<T2> { return std::less<std::common_type_t<T1*, T2>>()(p1.get(), p2); }

/* Handle (T*, extern_ptr<T>) */
	template<class T1, class T2>
	[[nodiscard]] constexpr auto operator<(const T1 p1, const extern_ptr<T2>& p2) noexcept requires std::is_pointer_v<T1> { return std::less<std::common_type_t<T1, T2*>>()(p1, p2.get()); }

template<class T1, class T2>
	[[nodiscard]] constexpr auto operator>(const extern_ptr<T1>& p1, const T2 p2) noexcept requires std::is_pointer_v<T2> { return p2 < p1; }

template<class T1, class T2>
	[[nodiscard]] constexpr auto operator<=(const extern_ptr<T1>& p1, const T2 p2) noexcept requires std::is_pointer_v<T2> { return !(p2 < p1); }

template<class T1, class T2>
	[[nodiscard]] constexpr auto operator>=(const extern_ptr<T1>& p1, const T2 p2) noexcept requires std::is_pointer_v<T2> { return !(p1 < p2); }
}

#pragma region Definitions

#if defined(__GNUC__) || defined(__clang__)
#define CC_CDECL __attribute__((cdecl))
#define CC_STDCALL __attribute__((stdcall))
#define CC_THISCALL __attribute__((thiscall))
#define CC_FASTCALL __attribute__((fastcall))
#define CC_VECTORCALL __attribute__((vectorcall))
#if defined(__INTEL_COMPILER)
#define CC_REGCALL __attribute__((regcall))
#else
#define CC_REGCALL CC_CDECL
#endif
#elif defined(_MSC_VER) || defined(__INTEL_COMPILER)
#define CC_CDECL __cdecl
#define CC_STDCALL __stdcall
#define CC_THISCALL __thiscall
#define CC_FASTCALL __fastcall
#define CC_VECTORCALL __vectorcall
#if defined(__INTEL_COMPILER)
#define CC_REGCALL __regcall
#else
#define CC_REGCALL CC_CDECL
#endif
#else
#define CC_CDECL
#define CC_STDCALL
#define CC_THISCALL
#define CC_FASTCALL
#define CC_VECTORCALL
#define CC_REGCALL
#endif
#if defined(__clang__ ) /* Clang does not support B(A)(C...) syntax, only A B(C...) and refuses to compile otherwise. */
#define FUNCTION_SIGNATURE(x,y,z) x y (z)
#define FUNCTION_SIGNATURE_VA(x,y,z) x y (z, ...)
#elif defined(__GNUC__) || defined(_MSC_VER) || defined(__INTEL_COMPILER) /* GCC Supports A B(C...)  and B(A)(C...) but produces wrong T* for T under A B(C...) */
#define FUNCTION_SIGNATURE(x,y,z) y(x)(z)
#define FUNCTION_SIGNATURE_VA(x,y,z) y(x)(z,...)
#endif

#if defined(__clang__ ) /* Ignore attribute warnings here to shut Clang up. */
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wignored-attributes"
#endif

#pragma endregion

namespace moar
{

template<concepts::Function T1, concepts::CallingConvention T2, concepts::Variadic T3>
	struct function_signature {
		static_assert(sizeof(T2) == 0 || sizeof(T3) == 0, "Illegal Function Signature");
		using type = void;
	};

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::cdecl_t, void> { using type = FUNCTION_SIGNATURE(CC_CDECL, RT, A...); };

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::cdecl_t, types::variadic_t> { using type = FUNCTION_SIGNATURE_VA(CC_CDECL, RT, A...); };

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::stdcall_t, void> { using type = FUNCTION_SIGNATURE(CC_STDCALL, RT, A...); };

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::stdcall_t, types::variadic_t> { using type = FUNCTION_SIGNATURE_VA(CC_STDCALL, RT, A...); };

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::thiscall_t, void> { using type = FUNCTION_SIGNATURE(CC_THISCALL, RT, A...); };

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::fastcall_t, void> { using type = FUNCTION_SIGNATURE(CC_FASTCALL, RT, A...); };

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::fastcall_t, types::variadic_t> { using type = FUNCTION_SIGNATURE_VA(CC_FASTCALL, RT, A...); };

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::vectorcall_t, void> { using type = FUNCTION_SIGNATURE(CC_VECTORCALL, RT, A...); };

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::regcall_t, void> { using type = FUNCTION_SIGNATURE(CC_REGCALL, RT, A...); };

template<typename RT, typename ...A>
	struct function_signature<RT(A...), types::regcall_t, types::variadic_t> { using type = FUNCTION_SIGNATURE_VA(CC_REGCALL, RT, A...); };
}

#pragma region Undefinitions

#if defined(__clang__)
#pragma clang diagnostic pop
#endif

#undef CC_CDECL
#undef CC_STDCALL
#undef CC_THISCALL
#undef CC_FASTCALL
#undef CC_VECTORCALL
#undef CC_REGCALL
#undef FUNCTION_SIGNATURE
#undef FUNCTION_SIGNATURE_VA

#pragma endregion

namespace moar
{
	template<concepts::Function T1, concepts::CommonType T2 = types::default_calling_convention, concepts::CommonType T3 = typename type_traits::SelectDefaultT3<T2>::type>
	class function_ptr {};

template<typename RT, concepts::CommonType T2, concepts::CommonType T3, typename ...A>
	class function_ptr<RT(A...), T2, T3> : public extern_ptr<typename function_signature<RT(A...), typename type_traits::SelectCallingConvention<T2,T3>::type, typename type_traits::SelectVariadic<T2, T3>::type>::type> /* typename not declared yet. */
	{
	public:
		/// <summary>
		/// Construct a function_pointer by raw address.
		/// </summary>
		/// <param name="address">The address to set the immutable and mutable pointers to.</param>
		explicit function_ptr(void* address) : base(address) { mutable_ptr = reinterpret_cast<base::element_type*>(address); }

/// <summary>
		/// Construct a function_pointer by object reference and virtual function table index.
		/// </summary>
		/// <param name="object">An instance of an object with virutal functions to resolve by index.</param>
		/// <param name="vfti">The virtual function table index to resovle on the object instance.</param>
		function_ptr(void* object, int vfti) : function_ptr(from_virtual(object, vfti)) { /*NOP*/ }

/// <summary>
		/// Construct a function_pointer with a value of nullptr.
		/// </summary>
		function_ptr() : function_ptr(nullptr) { /*NOP*/ };

/// <summary>
		/// Gets a pointer to the mutable poitner for mutating.
		/// </summary>
		/// <returns>Pointer to the mutable pointer.</returns>
		[[nodiscard]] auto mut() { return reinterpret_cast<void**>(&mutable_ptr); } /* pointer to the mutable pointer, decayed of all type info. */

/// <summary>
		/// Checks if the pointer has been mutated.
		/// </summary>
		/// <returns>True is the mutable pointer is different from the immutable pointer.</returns>
		[[nodiscard]] auto dirty() { return base::immutable_ptr != mutable_ptr; }

/// <summary>
		/// Calls the function at the immutable pointer. This will include any hooks if any are set.
		/// </summary>
		/// <param name="...args">The arguments of the function.</param>
		/// <returns>The value returned from the function.</returns>
		RT operator()(A... args) requires std::is_same_v<void, T3> || std::is_same_v<void, T2>
		{
			return base::immutable_ptr(args...);
		}

/// <summary>
		/// Calls the function at the immutable pointer. This will include any hooks if any are set.
		/// </summary>
		/// <typeparam name="...B">The variadic argument types for this call (inferred.)</typeparam>
		/// <param name="...args">The arguments of the function.</param>
		/// <param name="...vargs">The variadic arguments of the function.</param>
		/// <returns>The value returned from the function.</returns>
		template<typename ...B>
		RT operator()(A... args, B... vargs) requires std::is_same_v<types::variadic_t, T3> || std::is_same_v<types::variadic_t, T2>
		{
			return base::immutable_ptr(args..., vargs...);
		}

/// <summary>
		/// Calls the function at the mutable pointer. This will be the original function if any hooks are set, otherwise it will be the same as the immutable pointer.
		/// </summary>
		/// <param name="...args">The arguments of the function.</param>
		/// <returns>The value returned from the function.</returns>
		RT original(A... args) requires std::is_same_v<void, T3>
		{
			return mutable_ptr(args...);
		}

/// <summary>
		/// Calls the function at the mutable pointer. This will be the original function if any hooks are set, otherwise it will be the same as the immutable pointer.
		/// </summary>
		/// <typeparam name="...B">The variadic argument types for this call (inferred.)</typeparam>
		/// <param name="...args">The arguments of the function.</param>
		/// <param name="...vargs">The variadic arguments of the function.</param>
		/// <returns>The value returned from the function.</returns>
		template<typename ...B>
		RT original(A... args, B... vargs) requires std::is_same_v<types::variadic_t, T3> || std::is_same_v<types::variadic_t, T2>
		{
			return mutable_ptr(args..., vargs...);
		}
		using base = extern_ptr<typename function_signature<RT(A...), typename type_traits::SelectCallingConvention<T2, T3>::type, typename type_traits::SelectVariadic<T2, T3>::type>::type>;

private:

base::element_type* mutable_ptr = 0;

void reset_internal(base::element_type* new_ptr) override { this->mutable_ptr = new_ptr; }

static inline auto from_virtual(void* object, int vfti) -> void* { return (*reinterpret_cast<void***>(object))[vfti]; }
	};

}

/* Implementation of std::hash (injected into STD.)
	*/
	template<typename T>
	struct std::hash<moar::extern_ptr<T>>
	{
		[[nodiscard]] constexpr auto operator()(moar::extern_ptr<T> const& p) const noexcept { return std::hash<T*>{}(p.get()); }
	};

/* Implementation of std::hash (injected into STD.)
	*/
	template<typename T>
	struct std::hash<moar::function_ptr<T>>
	{
		std::size_t operator()(moar::function_ptr<T> const& p) const noexcept { return std::hash<T*>{}(p.get()); }
	};

int main()
{
    moar::function_ptr<void(), moar::types::stdcall_t> abc;
    moar::function_ptr<void(), moar::types::thiscall_t> def;
    return 0;
}