#ifndef SLANG_CPP_PRELUDE_H #define SLANG_CPP_PRELUDE_H // Because the signiture of isnan, isfinite, and is isinf changed in C++, we use the macro // to use the version in the std namespace. // https://stackoverflow.com/questions/39130040/cmath-hides-isnan-in-math-h-in-c14-c11 #ifdef SLANG_LLVM #include "slang-llvm.h" #else // SLANG_LLVM # if SLANG_GCC_FAMILY && __GNUC__ < 6 # include # define SLANG_PRELUDE_STD std:: # else # include # define SLANG_PRELUDE_STD # endif # include # include # include # include #endif // SLANG_LLVM #if defined(_MSC_VER) # define SLANG_PRELUDE_SHARED_LIB_EXPORT __declspec(dllexport) #else # define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__((__visibility__("default"))) //# define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport)) __attribute__((__visibility__("default"))) #endif #ifdef __cplusplus # define SLANG_PRELUDE_EXTERN_C extern "C" # define SLANG_PRELUDE_EXTERN_C_START extern "C" { # define SLANG_PRELUDE_EXTERN_C_END } #else # define SLANG_PRELUDE_EXTERN_C # define SLANG_PRELUDE_EXTERN_C_START # define SLANG_PRELUDE_EXTERN_C_END #endif #define SLANG_PRELUDE_EXPORT SLANG_PRELUDE_EXTERN_C SLANG_PRELUDE_SHARED_LIB_EXPORT #define SLANG_PRELUDE_EXPORT_START SLANG_PRELUDE_EXTERN_C_START SLANG_PRELUDE_SHARED_LIB_EXPORT #define SLANG_PRELUDE_EXPORT_END SLANG_PRELUDE_EXTERN_C_END #ifndef INFINITY // Must overflow for double # define INFINITY float(1e+300 * 1e+300) #endif #ifndef SLANG_INFINITY # define SLANG_INFINITY INFINITY #endif // Detect the compiler type #ifndef SLANG_COMPILER # define SLANG_COMPILER /* Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/ NOTE that SLANG_VC holds the compiler version - not just 1 or 0 */ # if defined(_MSC_VER) # if _MSC_VER >= 1900 # define SLANG_VC 14 # elif _MSC_VER >= 1800 # define SLANG_VC 12 # elif _MSC_VER >= 1700 # define SLANG_VC 11 # elif _MSC_VER >= 1600 # define SLANG_VC 10 # elif _MSC_VER >= 1500 # define SLANG_VC 9 # else # error "unknown version of Visual C++ compiler" # endif # elif defined(__clang__) # define SLANG_CLANG 1 # elif defined(__SNC__) # define SLANG_SNC 1 # elif defined(__ghs__) # define SLANG_GHS 1 # elif defined(__GNUC__) /* note: __clang__, __SNC__, or __ghs__ imply __GNUC__ */ # define SLANG_GCC 1 # else # error "unknown compiler" # endif /* Any compilers not detected by the above logic are now now explicitly zeroed out. */ # ifndef SLANG_VC # define SLANG_VC 0 # endif # ifndef SLANG_CLANG # define SLANG_CLANG 0 # endif # ifndef SLANG_SNC # define SLANG_SNC 0 # endif # ifndef SLANG_GHS # define SLANG_GHS 0 # endif # ifndef SLANG_GCC # define SLANG_GCC 0 # endif #endif /* SLANG_COMPILER */ /* The following section attempts to detect the target platform being compiled for. If an application defines `SLANG_PLATFORM` before including this header, they take responsibility for setting any compiler-dependent macros used later in the file. Most applications should not need to touch this section. */ #ifndef SLANG_PLATFORM # define SLANG_PLATFORM /** Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/ */ # if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_PARTITION_APP # define SLANG_WINRT 1 /* Windows Runtime, either on Windows RT or Windows 8 */ # elif defined(XBOXONE) # define SLANG_XBOXONE 1 # elif defined(_WIN64) /* note: XBOXONE implies _WIN64 */ # define SLANG_WIN64 1 # elif defined(_M_PPC) # define SLANG_X360 1 # elif defined(_WIN32) /* note: _M_PPC implies _WIN32 */ # define SLANG_WIN32 1 # elif defined(__ANDROID__) # define SLANG_ANDROID 1 # elif defined(__linux__) || defined(__CYGWIN__) /* note: __ANDROID__ implies __linux__ */ # define SLANG_LINUX 1 # elif defined(__APPLE__) && !defined(SLANG_LLVM) # include "TargetConditionals.h" # if TARGET_OS_MAC # define SLANG_OSX 1 # else # define SLANG_IOS 1 # endif # elif defined(__APPLE__) // On `slang-llvm` we can't inclue "TargetConditionals.h" in general, so for now assume its OSX. # define SLANG_OSX 1 # elif defined(__CELLOS_LV2__) # define SLANG_PS3 1 # elif defined(__ORBIS__) # define SLANG_PS4 1 # elif defined(__SNC__) && defined(__arm__) # define SLANG_PSP2 1 # elif defined(__ghs__) # define SLANG_WIIU 1 # else # error "unknown target platform" # endif /* Any platforms not detected by the above logic are now now explicitly zeroed out. */ # ifndef SLANG_WINRT # define SLANG_WINRT 0 # endif # ifndef SLANG_XBOXONE # define SLANG_XBOXONE 0 # endif # ifndef SLANG_WIN64 # define SLANG_WIN64 0 # endif # ifndef SLANG_X360 # define SLANG_X360 0 # endif # ifndef SLANG_WIN32 # define SLANG_WIN32 0 # endif # ifndef SLANG_ANDROID # define SLANG_ANDROID 0 # endif # ifndef SLANG_LINUX # define SLANG_LINUX 0 # endif # ifndef SLANG_IOS # define SLANG_IOS 0 # endif # ifndef SLANG_OSX # define SLANG_OSX 0 # endif # ifndef SLANG_PS3 # define SLANG_PS3 0 # endif # ifndef SLANG_PS4 # define SLANG_PS4 0 # endif # ifndef SLANG_PSP2 # define SLANG_PSP2 0 # endif # ifndef SLANG_WIIU # define SLANG_WIIU 0 # endif #endif /* SLANG_PLATFORM */ /* Shorthands for "families" of compilers/platforms */ #define SLANG_GCC_FAMILY (SLANG_CLANG || SLANG_SNC || SLANG_GHS || SLANG_GCC) #define SLANG_WINDOWS_FAMILY (SLANG_WINRT || SLANG_WIN32 || SLANG_WIN64) #define SLANG_MICROSOFT_FAMILY (SLANG_XBOXONE || SLANG_X360 || SLANG_WINDOWS_FAMILY) #define SLANG_LINUX_FAMILY (SLANG_LINUX || SLANG_ANDROID) #define SLANG_APPLE_FAMILY (SLANG_IOS || SLANG_OSX) /* equivalent to #if __APPLE__ */ #define SLANG_UNIX_FAMILY (SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */ // GCC Specific #if SLANG_GCC_FAMILY # define SLANG_ALIGN_OF(T) __alignof__(T) # define SLANG_BREAKPOINT(id) __builtin_trap() // Use this macro instead of offsetof, because gcc produces warning if offsetof is used on a // non POD type, even though it produces the correct result # define SLANG_OFFSET_OF(T, ELEMENT) (size_t(&((T*)1)->ELEMENT) - 1) #endif // SLANG_GCC_FAMILY // Microsoft VC specific #if SLANG_VC # define SLANG_ALIGN_OF(T) __alignof(T) # define SLANG_BREAKPOINT(id) __debugbreak(); #endif // SLANG_VC // Default impls #ifndef SLANG_OFFSET_OF # define SLANG_OFFSET_OF(X, Y) offsetof(X, Y) #endif #ifndef SLANG_BREAKPOINT // Make it crash with a write to 0! # define SLANG_BREAKPOINT(id) (*((int*)0) = int(id)); #endif // If slang.h has been included we don't need any of these definitions #ifndef SLANG_H /* Macro for declaring if a method is no throw. Should be set before the return parameter. */ #ifndef SLANG_NO_THROW # if SLANG_WINDOWS_FAMILY && !defined(SLANG_DISABLE_EXCEPTIONS) # define SLANG_NO_THROW __declspec(nothrow) # endif #endif #ifndef SLANG_NO_THROW # define SLANG_NO_THROW #endif /* The `SLANG_STDCALL` and `SLANG_MCALL` defines are used to set the calling convention for interface methods. */ #ifndef SLANG_STDCALL # if SLANG_MICROSOFT_FAMILY # define SLANG_STDCALL __stdcall # else # define SLANG_STDCALL # endif #endif #ifndef SLANG_MCALL # define SLANG_MCALL SLANG_STDCALL #endif #ifndef SLANG_FORCE_INLINE # define SLANG_FORCE_INLINE inline #endif // TODO(JS): Should these be in slang-cpp-types.h? // They are more likely to clash with slang.h struct SlangUUID { uint32_t data1; uint16_t data2; uint16_t data3; uint8_t data4[8]; }; typedef int32_t SlangResult; struct ISlangUnknown { virtual SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) = 0; virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() = 0; virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() = 0; }; #define SLANG_COM_INTERFACE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \ public: \ SLANG_FORCE_INLINE static const SlangUUID& getTypeGuid() \ { \ static const SlangUUID guid = { a, b, c, d0, d1, d2, d3, d4, d5, d6, d7 }; \ return guid; \ } #endif // SLANG_H // Includes #include "slang-cpp-scalar-intrinsics.h" #include "slang-cpp-types.h" // TODO(JS): Hack! Output C++ code from slang can copy uninitialized variables. #if defined(_MSC_VER) # pragma warning(disable : 4700) #endif #ifndef SLANG_UNROLL # define SLANG_UNROLL #endif #endif