Compiler.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#if defined(SC_COMPILER_ENABLE_CONFIG)
#include "SCConfig.h"
#endif
 
 
#if __clang__
#define SC_COMPILER_CLANG 1 
#define SC_COMPILER_GCC   0 
#define SC_COMPILER_MSVC  0 
 
#if _MSC_VER
#define SC_COMPILER_CLANG_CL 1 
#else
#define SC_COMPILER_CLANG_CL 0 
#endif
 
#elif _MSC_VER
#define SC_COMPILER_CLANG    0 
#define SC_COMPILER_GCC      0 
#define SC_COMPILER_MSVC     1 
#define SC_COMPILER_CLANG_CL 0 
 
#else
#define SC_COMPILER_CLANG    0 
#define SC_COMPILER_GCC      1 
#define SC_COMPILER_MSVC     0 
#define SC_COMPILER_CLANG_CL 0 
#endif
 
#if defined(__FILC__)
#define SC_COMPILER_FILC 1
#else
#define SC_COMPILER_FILC 0
#endif
 
#if SC_COMPILER_MSVC
 
#define SC_COMPILER_FORCE_INLINE __forceinline  
#define SC_COMPILER_DEBUG_BREAK  __debugbreak() 
 
#else
 
#define SC_COMPILER_FORCE_INLINE __attribute__((always_inline)) inline 
#if defined(__has_builtin)
#if __has_builtin(__builtin_debugtrap)
#define SC_COMPILER_DEBUG_BREAK __builtin_debugtrap() 
#elif __has_builtin(__builtin_trap)
#define SC_COMPILER_DEBUG_BREAK __builtin_trap() 
#else
#error "No __builtin_trap or __builtin_debugtrap"
#endif
#else
#error "No __has_builtin"
#endif
 
#endif
 
#if SC_COMPILER_MSVC || SC_COMPILER_CLANG_CL
#define SC_COMPILER_SYMBOL_IMPORT __declspec(dllimport)
#define SC_COMPILER_SYMBOL_EXPORT __declspec(dllexport)
#define SC_COMPILER_SYMBOL_HIDDEN
#else
#define SC_COMPILER_SYMBOL_IMPORT
#define SC_COMPILER_SYMBOL_EXPORT __attribute__((visibility("default")))
#define SC_COMPILER_SYMBOL_HIDDEN __attribute__((visibility("hidden")))
#endif
 
#if defined(SC_PLUGIN_LIBRARY)
#define SC_COMPILER_EXTERN extern
#else
#define SC_COMPILER_EXTERN
#endif
 
#if defined(SC_PLUGIN_LIBRARY)
#define SC_COMPILER_LIBRARY_EXPORT_0 SC_COMPILER_SYMBOL_IMPORT
#define SC_COMPILER_LIBRARY_EXPORT_1 SC_COMPILER_SYMBOL_IMPORT
#else
#define SC_COMPILER_LIBRARY_EXPORT_0 SC_COMPILER_SYMBOL_HIDDEN
#define SC_COMPILER_LIBRARY_EXPORT_1 SC_COMPILER_SYMBOL_EXPORT
#endif
#define SC_COMPILER_LIBRARY_EXPORT(value)      SC_COMPILER_LIBRARY_EXPORT_IMPL(value)
#define SC_COMPILER_LIBRARY_EXPORT_IMPL(value) SC_COMPILER_LIBRARY_EXPORT_##value
 
#ifndef SC_EXPORT_LIBRARY_FOUNDATION
#define SC_EXPORT_LIBRARY_FOUNDATION 0
#endif
#define SC_FOUNDATION_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_FOUNDATION)
 
#define SC_COMPILER_MACRO_ESCAPE(x)     #x
#define SC_COMPILER_MACRO_TO_LITERAL(x) SC_COMPILER_MACRO_ESCAPE(x)
 
#if defined(SC_LIBRARY_ROOT)
#define SC_COMPILER_LIBRARY_PATH SC_COMPILER_MACRO_TO_LITERAL(SC_LIBRARY_ROOT)
#else
#define SC_COMPILER_LIBRARY_PATH ""
#endif
 
#define WIDEN2(x) L##x
#define WIDEN(x)  WIDEN2(x)
 
#if defined(__SANITIZE_ADDRESS__)
#define SC_COMPILER_ASAN 1 
#else
#define SC_COMPILER_ASAN 0 
#endif
 
#if defined(__clang__)
#define SC_COMPILER_WARNING_POP _Pragma("clang diagnostic pop")
#elif defined(__GNUC__)
#define SC_COMPILER_WARNING_POP _Pragma("GCC diagnostic pop")
#else
#define SC_COMPILER_WARNING_POP _Pragma("warning(pop)")
#endif
 
#define SC_COMPILER_OFFSETOF(Class, Field) __builtin_offsetof(Class, Field)
 
// clang-format off
namespace SC
{
template <int offset, typename T, typename R> T& fieldOffset(R& object) { return *reinterpret_cast<T*>(reinterpret_cast<char*>(&object) - offset); }
} // namespace SC
#define SC_COMPILER_FIELD_OFFSET(Class, Field, Value)  SC::fieldOffset<SC_COMPILER_OFFSETOF(Class, Field), Class, decltype(Class::Field)>(Value);
// clang-format on
 
#if SC_COMPILER_CLANG
#define SC_COMPILER_WARNING_PUSH_OFFSETOF                                                                              \
    _Pragma("clang diagnostic push");                                                                                  \
    _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"");
#elif SC_COMPILER_GCC
#define SC_COMPILER_WARNING_PUSH_OFFSETOF                                                                              \
    _Pragma("GCC diagnostic push");                                                                                    \
    _Pragma("GCC diagnostic ignored \"-Winvalid-offsetof\"");
#else
#define SC_COMPILER_WARNING_PUSH_OFFSETOF _Pragma("warning(push)")
#endif
 
#define SC_COMPILER_UNUSED(param) ((void)param)
 
#if SC_COMPILER_CLANG
#define SC_COMPILER_WARNING_PUSH_UNUSED_RESULT                                                                         \
    _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wunused-result\"")                           \
        _Pragma("clang diagnostic ignored \"-Wunused-value\"")
#elif SC_COMPILER_GCC
#define SC_COMPILER_WARNING_PUSH_UNUSED_RESULT                                                                         \
    _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wunused-result\"")                               \
        _Pragma("GCC diagnostic ignored \"-Wunused-value\"")
#else
#define SC_COMPILER_WARNING_PUSH_UNUSED_RESULT _Pragma("warning(push)") _Pragma("warning(disable : 4834 6031)")
#endif
 
#if defined(SC_LANGUAGE_FORCE_STANDARD_CPP)
#if SC_LANGUAGE_FORCE_STANDARD_CPP == 14
#define SC_LANGUAGE_CPP_VERSION 201402L
#elif SC_LANGUAGE_FORCE_STANDARD_CPP == 17
#define SC_LANGUAGE_CPP_VERSION 201703L
#elif SC_LANGUAGE_FORCE_STANDARD_CPP == 20
#define SC_LANGUAGE_CPP_VERSION 202002L
#else
#error "SC_LANGUAGE_FORCE_STANDARD_CPP has invalid value"
#endif
#else
 
#if SC_COMPILER_MSVC
#define SC_LANGUAGE_CPP_VERSION _MSVC_LANG
#else
#define SC_LANGUAGE_CPP_VERSION __cplusplus
#endif
 
#endif
 
#if SC_LANGUAGE_CPP_VERSION >= 202002L
 
#define SC_LANGUAGE_CPP_AT_LEAST_20 1
#define SC_LANGUAGE_CPP_AT_LEAST_17 1
#define SC_LANGUAGE_CPP_AT_LEAST_14 1
 
#elif SC_LANGUAGE_CPP_VERSION >= 201703L
 
#define SC_LANGUAGE_CPP_AT_LEAST_20 0
#define SC_LANGUAGE_CPP_AT_LEAST_17 1
#define SC_LANGUAGE_CPP_AT_LEAST_14 1
 
#elif SC_LANGUAGE_CPP_VERSION >= 201402L
 
#define SC_LANGUAGE_CPP_AT_LEAST_20 0
#define SC_LANGUAGE_CPP_AT_LEAST_17 0
#define SC_LANGUAGE_CPP_AT_LEAST_14 1
 
#else
 
#define SC_LANGUAGE_CPP_AT_LEAST_20 0 
#define SC_LANGUAGE_CPP_AT_LEAST_17 0 
#define SC_LANGUAGE_CPP_AT_LEAST_14 0 
 
#endif
 
#undef SC_LANGUAGE_CPP_VERSION
 
#if SC_LANGUAGE_CPP_AT_LEAST_20
#define SC_LANGUAGE_LIKELY   [[likely]]   
#define SC_LANGUAGE_UNLIKELY [[unlikely]] 
#else
#define SC_LANGUAGE_LIKELY
#define SC_LANGUAGE_UNLIKELY
#endif
 
#if SC_LANGUAGE_CPP_AT_LEAST_17
#define SC_LANGUAGE_IF_CONSTEXPR constexpr
#else
#define SC_LANGUAGE_IF_CONSTEXPR
#endif
 
#if __cpp_exceptions == 199711 || _EXCEPTIONS
#define SC_LANGUAGE_EXCEPTIONS 1
#else
#define SC_LANGUAGE_EXCEPTIONS 0
#endif
 
#ifndef __has_cpp_attribute
#define SC_LANGUAGE_LIFETIME_BOUND
#elif __has_cpp_attribute(msvc::lifetimebound)
#define SC_LANGUAGE_LIFETIME_BOUND [[msvc::lifetimebound]]
#elif __has_cpp_attribute(clang::lifetimebound)
#define SC_LANGUAGE_LIFETIME_BOUND [[clang::lifetimebound]]
#elif __has_cpp_attribute(lifetimebound)
#define SC_LANGUAGE_LIFETIME_BOUND [[lifetimebound]]
#else
#define SC_LANGUAGE_LIFETIME_BOUND
#endif
 
// clang-format off
namespace SC
{
namespace TypeTraits
{
 
template <class T> struct RemoveReference       { using type = T; };
template <class T> struct RemoveReference<T&>   { using type = T; };
template <class T> struct RemoveReference<T&&>  { using type = T; };
template <class T> struct IsLValueReference     { static constexpr bool value = false; };
template <class T> struct IsLValueReference<T&> { static constexpr bool value = true; };
template <class T> struct IsRValueReference     { static constexpr bool value = false; };
template <class T> struct IsRValueReference<T&&>{ static constexpr bool value = true; };
 
}
 
 
template <typename T> constexpr T&& move(T& value) { return static_cast<T&&>(value); }
 
template <typename T> constexpr T&& forward(typename TypeTraits::RemoveReference<T>::type& value) { return static_cast<T&&>(value); }
 
template <typename T> constexpr T&& forward(typename TypeTraits::RemoveReference<T>::type&& value)
{
    static_assert(!TypeTraits::IsLValueReference<T>::value, "Forward an rvalue as an lvalue is not allowed");
    return static_cast<T&&>(value);
}
 
template <typename T> constexpr inline void swap(T& t1, T& t2) { T temp = move(t1); t1 = move(t2); t2 = move(temp); }
 
#ifdef max
#undef max
#endif
#ifdef min
#undef min
#endif
 
template <typename T> constexpr const T& min(const T& t1, const T& t2) { return t1 < t2 ? t1 : t2; }
template <typename T> constexpr const T& max(const T& t1, const T& t2) { return t1 > t2 ? t1 : t2; }
 
 
} // namespace SC
// clang-format on