compiler.hpp

Go to the documentation of this file.

#pragma once
 
namespace trlc {
namespace platform {
 
enum class CompilerType : int {
    unknown = 0,    
    gcc,            
    clang,          
    msvc,           
    intel_classic,  
    intel_llvm,     
    mingw           
};
 
struct CompilerVersion {
    int major;  
    int minor;  
    int patch;  
 
    constexpr CompilerVersion(int maj, int min, int pat = 0) noexcept
        : major(maj), minor(min), patch(pat) {}
 
    constexpr CompilerVersion() noexcept : major(0), minor(0), patch(0) {}
 
    constexpr bool operator>=(const CompilerVersion& other) const noexcept {
        if (major != other.major)
            return major > other.major;
        if (minor != other.minor)
            return minor > other.minor;
        return patch >= other.patch;
    }
 
    constexpr bool operator<(const CompilerVersion& other) const noexcept {
        if (major != other.major)
            return major < other.major;
        if (minor != other.minor)
            return minor < other.minor;
        return patch < other.patch;
    }
 
    constexpr bool operator==(const CompilerVersion& other) const noexcept {
        return major == other.major && minor == other.minor && patch == other.patch;
    }
 
    constexpr bool operator!=(const CompilerVersion& other) const noexcept {
        return !(*this == other);
    }
 
    constexpr bool operator>(const CompilerVersion& other) const noexcept {
        return !(*this < other) && !(*this == other);
    }
 
    constexpr bool operator<=(const CompilerVersion& other) const noexcept {
        return (*this < other) || (*this == other);
    }
};
 
constexpr CompilerType getCompilerType() noexcept {
// Check for Intel compilers first (they may also define GCC/Clang macros)
#if defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC)
    #if defined(__clang__)
    return CompilerType::intel_llvm;  // Intel C++ Compiler based on LLVM
    #else
    return CompilerType::intel_classic;  // Legacy Intel C++ Compiler
    #endif
// Check for Clang (must be before GCC since Clang may define __GNUC__)
#elif defined(__clang__)
    return CompilerType::clang;
// Check for GCC
#elif defined(__GNUC__)
    #if defined(__MINGW32__) || defined(__MINGW64__)
    return CompilerType::mingw;
    #else
    return CompilerType::gcc;
    #endif
// Check for MSVC
#elif defined(_MSC_VER)
    return CompilerType::msvc;
#else
    return CompilerType::unknown;
#endif
}
 
constexpr CompilerVersion getCompilerVersion() noexcept {
#if defined(__INTEL_COMPILER)
    // Intel compiler version format: VVRR (VV = major, RR = minor)
    return CompilerVersion(
        __INTEL_COMPILER / 100, (__INTEL_COMPILER % 100) / 10, __INTEL_COMPILER % 10);
#elif defined(__clang__)
    return CompilerVersion(__clang_major__, __clang_minor__, __clang_patchlevel__);
#elif defined(__GNUC__)
    #if defined(__GNUC_PATCHLEVEL__)
    return CompilerVersion(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
    #else
    return CompilerVersion(__GNUC__, __GNUC_MINOR__, 0);
    #endif
#elif defined(_MSC_VER)
    // MSVC version mapping (simplified)
    #if _MSC_VER >= 1940    // Visual Studio 2022 17.10+
    return CompilerVersion(19, 4, (_MSC_VER - 1940));
    #elif _MSC_VER >= 1930  // Visual Studio 2022 17.0-17.9
    return CompilerVersion(19, 3, (_MSC_VER - 1930));
    #elif _MSC_VER >= 1920  // Visual Studio 2019
    return CompilerVersion(19, 2, (_MSC_VER - 1920));
    #elif _MSC_VER >= 1910  // Visual Studio 2017
    return CompilerVersion(19, 1, (_MSC_VER - 1910));
    #elif _MSC_VER >= 1900  // Visual Studio 2015
    return CompilerVersion(19, 0, (_MSC_VER - 1900));
    #else
    return CompilerVersion(_MSC_VER / 100, (_MSC_VER % 100) / 10, _MSC_VER % 10);
    #endif
#else
    return CompilerVersion(0, 0, 0);
#endif
}
 
constexpr const char* getCompilerName() noexcept {
    switch (getCompilerType()) {
        case CompilerType::gcc:
            return "gcc";
        case CompilerType::clang:
            return "clang";
        case CompilerType::msvc:
            return "msvc";
        case CompilerType::intel_classic:
            return "intel_classic";
        case CompilerType::intel_llvm:
            return "intel_llvm";
        case CompilerType::mingw:
            return "mingw";
        case CompilerType::unknown:
        default:
            return "unknown";
    }
}
 
constexpr bool hasBuiltinAttribute([[maybe_unused]] const char* attribute_name) noexcept {
    constexpr auto compiler = getCompilerType();
    return compiler == CompilerType::gcc || compiler == CompilerType::clang ||
           compiler == CompilerType::mingw || compiler == CompilerType::intel_llvm;
}
 
constexpr bool supportsInlineAssembly() noexcept {
    constexpr auto compiler = getCompilerType();
    // MSVC has different inline assembly syntax and limitations
    return compiler == CompilerType::gcc || compiler == CompilerType::clang ||
           compiler == CompilerType::mingw || compiler == CompilerType::intel_classic ||
           compiler == CompilerType::intel_llvm;
}
 
constexpr bool hasColorDiagnostics() noexcept {
    constexpr auto compiler = getCompilerType();
    return compiler == CompilerType::gcc || compiler == CompilerType::clang ||
           compiler == CompilerType::mingw || compiler == CompilerType::intel_llvm;
}
 
//==============================================================================
// Consolidated Compiler Information
//==============================================================================
 
struct CompilerInfo {
    CompilerType type;           
    CompilerVersion version;     
    const char* name;            
    bool has_builtin_attribute;  
    bool has_inline_assembly;    
    bool has_color_diagnostics;  
 
    constexpr bool isAtLeast(const CompilerVersion& min_version) const noexcept {
        return version >= min_version;
    }
 
    constexpr bool isGccCompatible() const noexcept {
        return type == CompilerType::gcc || type == CompilerType::mingw ||
               type == CompilerType::intel_classic;
    }
 
    constexpr bool isClangCompatible() const noexcept {
        return type == CompilerType::clang || type == CompilerType::intel_llvm;
    }
};
 
constexpr CompilerInfo getCompilerInfo() noexcept {
    return CompilerInfo{getCompilerType(),
                        getCompilerVersion(),
                        getCompilerName(),
                        hasBuiltinAttribute(""),  // Generic builtin support check
                        supportsInlineAssembly(),
                        hasColorDiagnostics()};
}
 
}  // namespace platform
}  // namespace trlc
 
// Convenience macros for conditional compilation
 
#if defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC)
    #define TRLC_COMPILER_GCC 0
#elif defined(__clang__)
    #define TRLC_COMPILER_GCC 0
#elif defined(__GNUC__)
    #if defined(__MINGW32__) || defined(__MINGW64__)
        #define TRLC_COMPILER_GCC 0  // MinGW is separate
    #else
        #define TRLC_COMPILER_GCC 1
    #endif
#else
    #define TRLC_COMPILER_GCC 0
#endif
 
#if defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC)
    #if defined(__clang__)
        #define TRLC_COMPILER_CLANG 0  // Intel LLVM-based, not pure Clang
    #else
        #define TRLC_COMPILER_CLANG 0
    #endif
#elif defined(__clang__)
    #define TRLC_COMPILER_CLANG 1
#else
    #define TRLC_COMPILER_CLANG 0
#endif
 
#if defined(_MSC_VER) && !defined(__clang__) && !defined(__INTEL_COMPILER)
    #define TRLC_COMPILER_MSVC 1
#else
    #define TRLC_COMPILER_MSVC 0
#endif
 
#if defined(__INTEL_COMPILER) && !defined(__clang__)
    #define TRLC_COMPILER_INTEL 1
#else
    #define TRLC_COMPILER_INTEL 0
#endif
 
#if (defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC)) && defined(__clang__)
    #define TRLC_COMPILER_INTEL_LLVM 1
#else
    #define TRLC_COMPILER_INTEL_LLVM 0
#endif
 
#if defined(__GNUC__) && (defined(__MINGW32__) || defined(__MINGW64__))
    #define TRLC_COMPILER_MINGW 1
#else
    #define TRLC_COMPILER_MINGW 0
#endif
 
#if defined(__INTEL_COMPILER)
    #define TRLC_COMPILER_VERSION_MAJOR (__INTEL_COMPILER / 100)
    #define TRLC_COMPILER_VERSION_MINOR ((__INTEL_COMPILER % 100) / 10)
    #define TRLC_COMPILER_VERSION_PATCH (__INTEL_COMPILER % 10)
#elif defined(__clang__)
    #define TRLC_COMPILER_VERSION_MAJOR __clang_major__
    #define TRLC_COMPILER_VERSION_MINOR __clang_minor__
    #define TRLC_COMPILER_VERSION_PATCH __clang_patchlevel__
#elif defined(__GNUC__)
    #define TRLC_COMPILER_VERSION_MAJOR __GNUC__
    #define TRLC_COMPILER_VERSION_MINOR __GNUC_MINOR__
    #ifdef __GNUC_PATCHLEVEL__
        #define TRLC_COMPILER_VERSION_PATCH __GNUC_PATCHLEVEL__
    #else
        #define TRLC_COMPILER_VERSION_PATCH 0
    #endif
#elif defined(_MSC_VER)
    #if _MSC_VER >= 1940
        #define TRLC_COMPILER_VERSION_MAJOR 19
        #define TRLC_COMPILER_VERSION_MINOR 4
        #define TRLC_COMPILER_VERSION_PATCH (_MSC_VER - 1940)
    #elif _MSC_VER >= 1930
        #define TRLC_COMPILER_VERSION_MAJOR 19
        #define TRLC_COMPILER_VERSION_MINOR 3
        #define TRLC_COMPILER_VERSION_PATCH (_MSC_VER - 1930)
    #elif _MSC_VER >= 1920
        #define TRLC_COMPILER_VERSION_MAJOR 19
        #define TRLC_COMPILER_VERSION_MINOR 2
        #define TRLC_COMPILER_VERSION_PATCH (_MSC_VER - 1920)
    #elif _MSC_VER >= 1910
        #define TRLC_COMPILER_VERSION_MAJOR 19
        #define TRLC_COMPILER_VERSION_MINOR 1
        #define TRLC_COMPILER_VERSION_PATCH (_MSC_VER - 1910)
    #elif _MSC_VER >= 1900
        #define TRLC_COMPILER_VERSION_MAJOR 19
        #define TRLC_COMPILER_VERSION_MINOR 0
        #define TRLC_COMPILER_VERSION_PATCH (_MSC_VER - 1900)
    #else
        #define TRLC_COMPILER_VERSION_MAJOR (_MSC_VER / 100)
        #define TRLC_COMPILER_VERSION_MINOR ((_MSC_VER % 100) / 10)
        #define TRLC_COMPILER_VERSION_PATCH (_MSC_VER % 10)
    #endif
#else
    #define TRLC_COMPILER_VERSION_MAJOR 0
    #define TRLC_COMPILER_VERSION_MINOR 0
    #define TRLC_COMPILER_VERSION_PATCH 0
#endif
 
#define TRLC_COMPILER_VERSION_ATLEAST(major, minor, patch)                                \
    ((TRLC_COMPILER_VERSION_MAJOR > (major)) ||                                           \
     (TRLC_COMPILER_VERSION_MAJOR == (major) && TRLC_COMPILER_VERSION_MINOR > (minor)) || \
     (TRLC_COMPILER_VERSION_MAJOR == (major) && TRLC_COMPILER_VERSION_MINOR == (minor) && \
      TRLC_COMPILER_VERSION_PATCH >= (patch)))
 
#define TRLC_COMPILER_VERSION (trlc::platform::getCompilerVersion())
 
#define TRLC_COMPILER_NAME (trlc::platform::getCompilerName())