kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Modules/WriteCompilerDetectionHeade...

665 lines
25 KiB
CMake
Raw Normal View History

Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
#.rst:
# WriteCompilerDetectionHeader
# ----------------------------
#
# This module provides the function write_compiler_detection_header().
#
# The ``WRITE_COMPILER_DETECTION_HEADER`` function can be used to generate
# a file suitable for preprocessor inclusion which contains macros to be
# used in source code::
#
# write_compiler_detection_header(
# FILE <file>
# PREFIX <prefix>
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
# [OUTPUT_FILES_VAR <output_files_var> OUTPUT_DIR <output_dir>]
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# COMPILERS <compiler> [...]
# FEATURES <feature> [...]
# [VERSION <version>]
# [PROLOG <prolog>]
# [EPILOG <epilog>]
# )
#
# The ``write_compiler_detection_header`` function generates the
# file ``<file>`` with macros which all have the prefix ``<prefix>``.
#
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
# By default, all content is written directly to the ``<file>``. The
# ``OUTPUT_FILES_VAR`` may be specified to cause the compiler-specific
# content to be written to separate files. The separate files are then
# available in the ``<output_files_var>`` and may be consumed by the caller
# for installation for example. The ``OUTPUT_DIR`` specifies a relative
# path from the main ``<file>`` to the compiler-specific files. For example:
#
# .. code-block:: cmake
#
# write_compiler_detection_header(
# FILE climbingstats_compiler_detection.h
# PREFIX ClimbingStats
# OUTPUT_FILES_VAR support_files
# OUTPUT_DIR compilers
Features: Record for MSVC 2010-2015 Also, in WCDH add MSVC Compatibility for cxx_align{of,as}. Co-Author: Stephen Kelly <steveire@gmail.com> Co-Author: Brad King <brad.king@kitware.com>
2015-01-19 23:49:06 +03:00
# COMPILERS GNU Clang MSVC
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
# FEATURES cxx_variadic_templates
# )
# install(FILES
# ${CMAKE_CURRENT_BINARY_DIR}/climbingstats_compiler_detection.h
# DESTINATION include
# )
# install(FILES
# ${support_files}
# DESTINATION include/compilers
# )
#
#
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# ``VERSION`` may be used to specify the API version to be generated.
# Future versions of CMake may introduce alternative APIs. A given
# API is selected by any ``<version>`` value greater than or equal
# to the version of CMake that introduced the given API and less
# than the version of CMake that introduced its succeeding API.
# The value of the :variable:`CMAKE_MINIMUM_REQUIRED_VERSION`
# variable is used if no explicit version is specified.
# (As of CMake version |release| there is only one API version.)
#
# ``PROLOG`` may be specified as text content to write at the start of the
# header. ``EPILOG`` may be specified as text content to write at the end
# of the header
#
# At least one ``<compiler>`` and one ``<feature>`` must be listed. Compilers
# which are known to CMake, but not specified are detected and a preprocessor
# ``#error`` is generated for them. A preprocessor macro matching
# ``<PREFIX>_COMPILER_IS_<compiler>`` is generated for each compiler
# known to CMake to contain the value ``0`` or ``1``.
#
# Possible compiler identifiers are documented with the
# :variable:`CMAKE_<LANG>_COMPILER_ID` variable.
# Available features in this version of CMake are listed in the
Features: Extend concept to C language. Add properties and variables corresponding to CXX equivalents. Add features for c_function_prototypes (C90), c_restrict (C99), c_variadic_macros (C99) and c_static_assert (C11). This feature set can be extended later. Add a <PREFIX>_RESTRICT symbol define to WriteCompilerDetectionHeader to conditionally represent the c_restrict feature.
2013-11-04 04:15:43 +04:00
# :prop_gbl:`CMAKE_C_KNOWN_FEATURES` and
# :prop_gbl:`CMAKE_CXX_KNOWN_FEATURES` global properties.
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
#
Help: Add a manual for compiler feature control. Link to it from the documentation of related properties, variables and commands. Extend the cmake-developer(7) documentation with notes on extending feature support for compilers.
2014-03-19 02:50:18 +04:00
# See the :manual:`cmake-compile-features(7)` manual for information on
# compile features.
#
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# Feature Test Macros
# ===================
#
Features: Add compiler version support to WriteCompilerDetectionHeader.
2014-06-05 15:16:56 +04:00
# For each compiler, a preprocessor macro is generated matching
# ``<PREFIX>_COMPILER_IS_<compiler>`` which has the content either ``0``
# or ``1``, depending on the compiler in use. Preprocessor macros for
# compiler version components are generated matching
# ``<PREFIX>_COMPILER_VERSION_MAJOR`` ``<PREFIX>_COMPILER_VERSION_MINOR``
# and ``<PREFIX>_COMPILER_VERSION_PATCH`` containing decimal values
# for the corresponding compiler version components, if defined.
#
# A preprocessor test is generated based on the compiler version
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# denoting whether each feature is enabled. A preprocessor macro
# matching ``<PREFIX>_COMPILER_<FEATURE>``, where ``<FEATURE>`` is the
# upper-case ``<feature>`` name, is generated to contain the value
# ``0`` or ``1`` depending on whether the compiler in use supports the
# feature:
#
# .. code-block:: cmake
#
# write_compiler_detection_header(
# FILE climbingstats_compiler_detection.h
# PREFIX ClimbingStats
Features: Record for MSVC 2010-2015 Also, in WCDH add MSVC Compatibility for cxx_align{of,as}. Co-Author: Stephen Kelly <steveire@gmail.com> Co-Author: Brad King <brad.king@kitware.com>
2015-01-19 23:49:06 +03:00
# COMPILERS GNU Clang AppleClang MSVC
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# FEATURES cxx_variadic_templates
# )
#
# .. code-block:: c++
#
# #if ClimbingStats_COMPILER_CXX_VARIADIC_TEMPLATES
# template<typename... T>
# void someInterface(T t...) { /* ... */ }
# #else
# // Compatibility versions
# template<typename T1>
# void someInterface(T1 t1) { /* ... */ }
# template<typename T1, typename T2>
# void someInterface(T1 t1, T2 t2) { /* ... */ }
# template<typename T1, typename T2, typename T3>
# void someInterface(T1 t1, T2 t2, T3 t3) { /* ... */ }
# #endif
#
# Symbol Macros
# =============
#
# Some additional symbol-defines are created for particular features for
# use as symbols which may be conditionally defined empty:
#
# .. code-block:: c++
#
WCDH: Remove noise from generated defines. The DECL part is redundant, and the language part is not needed. The source language and context already determines the language, so there is no need to repeat it in the define name.
2014-06-13 12:46:27 +04:00
# class MyClass ClimbingStats_FINAL
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# {
WCDH: Remove noise from generated defines. The DECL part is redundant, and the language part is not needed. The source language and context already determines the language, so there is no need to repeat it in the define name.
2014-06-13 12:46:27 +04:00
# ClimbingStats_CONSTEXPR int someInterface() { return 42; }
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# };
#
WCDH: Remove noise from generated defines. The DECL part is redundant, and the language part is not needed. The source language and context already determines the language, so there is no need to repeat it in the define name.
2014-06-13 12:46:27 +04:00
# The ``ClimbingStats_FINAL`` macro will expand to ``final`` if the
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# compiler (and its flags) support the ``cxx_final`` feature, and the
WCDH: Remove noise from generated defines. The DECL part is redundant, and the language part is not needed. The source language and context already determines the language, so there is no need to repeat it in the define name.
2014-06-13 12:46:27 +04:00
# ``ClimbingStats_CONSTEXPR`` macro will expand to ``constexpr``
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# if ``cxx_constexpr`` is supported.
#
# The following features generate corresponding symbol defines:
#
# ========================== =================================== =================
# Feature Define Symbol
# ========================== =================================== =================
Features: Extend concept to C language. Add properties and variables corresponding to CXX equivalents. Add features for c_function_prototypes (C90), c_restrict (C99), c_variadic_macros (C99) and c_static_assert (C11). This feature set can be extended later. Add a <PREFIX>_RESTRICT symbol define to WriteCompilerDetectionHeader to conditionally represent the c_restrict feature.
2013-11-04 04:15:43 +04:00
# ``c_restrict`` ``<PREFIX>_RESTRICT`` ``restrict``
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# ``cxx_constexpr`` ``<PREFIX>_CONSTEXPR`` ``constexpr``
# ``cxx_deleted_functions`` ``<PREFIX>_DELETED_FUNCTION`` ``= delete``
# ``cxx_extern_templates`` ``<PREFIX>_EXTERN_TEMPLATE`` ``extern``
# ``cxx_final`` ``<PREFIX>_FINAL`` ``final``
# ``cxx_noexcept`` ``<PREFIX>_NOEXCEPT`` ``noexcept``
# ``cxx_noexcept`` ``<PREFIX>_NOEXCEPT_EXPR(X)`` ``noexcept(X)``
# ``cxx_override`` ``<PREFIX>_OVERRIDE`` ``override``
# ========================== =================================== =================
#
# Compatibility Implementation Macros
# ===================================
#
# Some features are suitable for wrapping in a macro with a backward
# compatibility implementation if the compiler does not support the feature.
#
# When the ``cxx_static_assert`` feature is not provided by the compiler,
# a compatibility implementation is available via the
# ``<PREFIX>_STATIC_ASSERT(COND)`` and
# ``<PREFIX>_STATIC_ASSERT_MSG(COND, MSG)`` function-like macros. The macros
# expand to ``static_assert`` where that compiler feature is available, and
# to a compatibility implementation otherwise. In the first form, the
# condition is stringified in the message field of ``static_assert``. In
# the second form, the message ``MSG`` is passed to the message field of
# ``static_assert``, or ignored if using the backward compatibility
# implementation.
#
WCDH: Add compatibility defines for deprecation.
2014-05-15 00:10:10 +04:00
# The ``cxx_attribute_deprecated`` feature provides a macro definition
# ``<PREFIX>_DEPRECATED``, which expands to either the standard
# ``[[deprecated]]`` attribute or a compiler-specific decorator such
# as ``__attribute__((__deprecated__))`` used by GNU compilers.
#
WCDH: Document the alignof and alignas wrapper macros.
2014-06-10 20:03:48 +04:00
# The ``cxx_alignas`` feature provides a macro definition
# ``<PREFIX>_ALIGNAS`` which expands to either the standard ``alignas``
# decorator or a compiler-specific decorator such as
# ``__attribute__ ((__aligned__))`` used by GNU compilers.
#
# The ``cxx_alignof`` feature provides a macro definition
# ``<PREFIX>_ALIGNOF`` which expands to either the standard ``alignof``
# decorator or a compiler-specific decorator such as ``__alignof__``
# used by GNU compilers.
#
WCDH: Add compatibility defines for deprecation.
2014-05-15 00:10:10 +04:00
# ============================= ================================ =====================
# Feature Define Symbol
# ============================= ================================ =====================
# ``cxx_alignas`` ``<PREFIX>_ALIGNAS`` ``alignas``
# ``cxx_alignof`` ``<PREFIX>_ALIGNOF`` ``alignof``
# ``cxx_nullptr`` ``<PREFIX>_NULLPTR`` ``nullptr``
# ``cxx_static_assert`` ``<PREFIX>_STATIC_ASSERT`` ``static_assert``
# ``cxx_static_assert`` ``<PREFIX>_STATIC_ASSERT_MSG`` ``static_assert``
# ``cxx_attribute_deprecated`` ``<PREFIX>_DEPRECATED`` ``[[deprecated]]``
# ``cxx_attribute_deprecated`` ``<PREFIX>_DEPRECATED_MSG`` ``[[deprecated]]``
WCDH: Add feature portability for thread_local. AppleClang does not support the cxx_thread_local feature, even though it is based on a Clang version which does support the feature. http://stackoverflow.com/a/23850891/2428389 A possible reason for that is that thread_local might be used as a variable in existing Apple SDK headers. Extend the WriteCompilerDetectionHeader module to generate a define for that feature with portability fallbacks. For the avoidance of making it easy to write code which looks correct but which has odd runtime behavior, don't set the define symbol at all if no equivalent keyword is known.
2015-01-01 19:56:01 +03:00
# ``cxx_thread_local`` ``<PREFIX>_THREAD_LOCAL`` ``thread_local``
WCDH: Add compatibility defines for deprecation.
2014-05-15 00:10:10 +04:00
# ============================= ================================ =====================
#
# A use-case which arises with such deprecation macros is the deprecation
# of an entire library. In that case, all public API in the library may
# be decorated with the ``<PREFIX>_DEPRECATED`` macro. This results in
# very noisy build output when building the library itself, so the macro
# may be may be defined to empty in that case when building the deprecated
# library:
#
# .. code-block:: cmake
#
# add_library(compat_support ${srcs})
# target_compile_definitions(compat_support
# PRIVATE
# CompatSupport_DEPRECATED=
# )
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
#=============================================================================
# Copyright 2014 Stephen Kelly <steveire@gmail.com>
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake)
include(${CMAKE_CURRENT_LIST_DIR}/CMakeCompilerIdDetection.cmake)
function(_load_compiler_variables CompilerId lang)
include("${CMAKE_ROOT}/Modules/Compiler/${CompilerId}-${lang}-FeatureTests.cmake" OPTIONAL)
set(_cmake_oldestSupported_${CompilerId} ${_cmake_oldestSupported} PARENT_SCOPE)
foreach(feature ${ARGN})
set(_cmake_feature_test_${CompilerId}_${feature} ${_cmake_feature_test_${feature}} PARENT_SCOPE)
endforeach()
WCDH: Find a language-specific DetermineCompiler.cmake if present. The SolarisStudio compiler module uses language specific files.
2015-01-17 16:08:47 +03:00
include("${CMAKE_ROOT}/Modules/Compiler/${CompilerId}-${lang}-DetermineCompiler.cmake" OPTIONAL
RESULT_VARIABLE determinedCompiler)
if (NOT determinedCompiler)
include("${CMAKE_ROOT}/Modules/Compiler/${CompilerId}-DetermineCompiler.cmake" OPTIONAL)
endif()
Features: Add compiler version support to WriteCompilerDetectionHeader.
2014-06-05 15:16:56 +04:00
set(_compiler_id_version_compute_${CompilerId} ${_compiler_id_version_compute} PARENT_SCOPE)
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
endfunction()
function(write_compiler_detection_header
file_keyword file_arg
prefix_keyword prefix_arg
)
if (NOT file_keyword STREQUAL FILE)
message(FATAL_ERROR "write_compiler_detection_header: FILE parameter missing.")
endif()
if (NOT prefix_keyword STREQUAL PREFIX)
message(FATAL_ERROR "write_compiler_detection_header: PREFIX parameter missing.")
endif()
set(options)
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
set(oneValueArgs VERSION EPILOG PROLOG OUTPUT_FILES_VAR OUTPUT_DIR)
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
set(multiValueArgs COMPILERS FEATURES)
cmake_parse_arguments(_WCD "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
if (NOT _WCD_COMPILERS)
message(FATAL_ERROR "Invalid arguments. write_compiler_detection_header requires at least one compiler.")
endif()
if (NOT _WCD_FEATURES)
message(FATAL_ERROR "Invalid arguments. write_compiler_detection_header requires at least one feature.")
endif()
if(_WCD_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "Unparsed arguments: ${_WCD_UNPARSED_ARGUMENTS}")
endif()
WCDH: Ensure that the prefix argument to the macro is valid. The prefix must be a C-identifier because it is written as the prefix of preprocessor macros and possibly structs.
2014-06-13 13:39:47 +04:00
if (prefix_arg STREQUAL "")
message(FATAL_ERROR "A prefix must be specified")
endif()
string(MAKE_C_IDENTIFIER ${prefix_arg} cleaned_prefix)
if (NOT prefix_arg STREQUAL cleaned_prefix)
message(FATAL_ERROR "The prefix must be a valid C identifier.")
endif()
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
if(NOT _WCD_VERSION)
set(_WCD_VERSION ${CMAKE_MINIMUM_REQUIRED_VERSION})
endif()
WCDH: Issue a better message for version compatibility.
2014-06-05 14:34:16 +04:00
set(_min_version 3.1.0) # Version which introduced this function
if (_WCD_VERSION VERSION_LESS _min_version)
set(err "VERSION compatibility for write_compiler_detection_header is set to ${_WCD_VERSION}, which is too low.")
set(err "${err} It must be set to at least ${_min_version}. ")
set(err "${err} Either set the VERSION parameter to the write_compiler_detection_header function, or update")
set(err "${err} your minimum required CMake version with the cmake_minimum_required command.")
message(FATAL_ERROR "${err}")
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
endif()
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
if(_WCD_OUTPUT_FILES_VAR)
if(NOT _WCD_OUTPUT_DIR)
message(FATAL_ERROR "If OUTPUT_FILES_VAR is specified, then OUTPUT_DIR must also be specified.")
endif()
endif()
if(_WCD_OUTPUT_DIR)
if(NOT _WCD_OUTPUT_FILES_VAR)
message(FATAL_ERROR "If OUTPUT_DIR is specified, then OUTPUT_FILES_VAR must also be specified.")
endif()
get_filename_component(main_file_dir ${file_arg} DIRECTORY)
if (NOT IS_ABSOLUTE ${main_file_dir})
set(main_file_dir "${CMAKE_CURRENT_BINARY_DIR}/${main_file_dir}")
endif()
if (NOT IS_ABSOLUTE ${_WCD_OUTPUT_DIR})
set(_WCD_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/${_WCD_OUTPUT_DIR}")
endif()
get_filename_component(out_file_dir ${_WCD_OUTPUT_DIR} ABSOLUTE)
string(FIND ${out_file_dir} ${main_file_dir} idx)
if (NOT idx EQUAL 0)
message(FATAL_ERROR "The compiler-specific output directory must be within the same directory as the main file.")
endif()
if (main_file_dir STREQUAL out_file_dir)
unset(_WCD_OUTPUT_DIR)
else()
string(REPLACE "${main_file_dir}/" "" _WCD_OUTPUT_DIR "${out_file_dir}/")
endif()
endif()
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
set(compilers
GNU
Features: Record for Clang 3.4 Clang 3.4 supports all features currently known to CMake.
2014-05-06 13:59:12 +04:00
Clang
Features: Record for AppleClang 5.1 Apple's Clang 5.1 already supports most of the C and C++ features CMake enumerates.
2014-11-13 00:48:17 +03:00
AppleClang
Features: Record for MSVC 2010-2015 Also, in WCDH add MSVC Compatibility for cxx_align{of,as}. Co-Author: Stephen Kelly <steveire@gmail.com> Co-Author: Brad King <brad.king@kitware.com>
2015-01-19 23:49:06 +03:00
MSVC
Features: Record for SolarisStudio 12.4. It has similar C++11 capabilities compared to GCC 4.8.
2015-01-16 21:26:37 +03:00
SunPro
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
)
Features: Add compiler version support to WriteCompilerDetectionHeader.
2014-06-05 15:16:56 +04:00
set(_hex_compilers ADSP Borland Embarcadero SunPro)
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
foreach(_comp ${_WCD_COMPILERS})
list(FIND compilers ${_comp} idx)
if (idx EQUAL -1)
message(FATAL_ERROR "Unsupported compiler ${_comp}.")
endif()
Features: Add compiler version support to WriteCompilerDetectionHeader.
2014-06-05 15:16:56 +04:00
if (NOT _need_hex_conversion)
list(FIND _hex_compilers ${_comp} idx)
if (NOT idx EQUAL -1)
set(_need_hex_conversion TRUE)
endif()
endif()
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
endforeach()
set(file_content "
// This is a generated file. Do not edit!
#ifndef ${prefix_arg}_COMPILER_DETECTION_H
#define ${prefix_arg}_COMPILER_DETECTION_H
")
if (_WCD_PROLOG)
set(file_content "${file_content}\n${_WCD_PROLOG}\n")
endif()
Features: Add compiler version support to WriteCompilerDetectionHeader.
2014-06-05 15:16:56 +04:00
if (_need_hex_conversion)
set(file_content "${file_content}
#define ${prefix_arg}_DEC(X) (X)
#define ${prefix_arg}_HEX(X) ( \\
((X)>>28 & 0xF) * 10000000 + \\
((X)>>24 & 0xF) * 1000000 + \\
((X)>>20 & 0xF) * 100000 + \\
((X)>>16 & 0xF) * 10000 + \\
((X)>>12 & 0xF) * 1000 + \\
((X)>>8 & 0xF) * 100 + \\
((X)>>4 & 0xF) * 10 + \\
((X) & 0xF) \\
)\n")
endif()
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
foreach(feature ${_WCD_FEATURES})
if (feature MATCHES "^cxx_")
list(APPEND _langs CXX)
list(APPEND CXX_features ${feature})
Features: Extend concept to C language. Add properties and variables corresponding to CXX equivalents. Add features for c_function_prototypes (C90), c_restrict (C99), c_variadic_macros (C99) and c_static_assert (C11). This feature set can be extended later. Add a <PREFIX>_RESTRICT symbol define to WriteCompilerDetectionHeader to conditionally represent the c_restrict feature.
2013-11-04 04:15:43 +04:00
elseif (feature MATCHES "^c_")
list(APPEND _langs C)
list(APPEND C_features ${feature})
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
else()
message(FATAL_ERROR "Unsupported feature ${feature}.")
endif()
endforeach()
list(REMOVE_DUPLICATES _langs)
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
if(_WCD_OUTPUT_FILES_VAR)
get_filename_component(main_file_name ${file_arg} NAME)
set(compiler_file_content_
"#ifndef ${prefix_arg}_COMPILER_DETECTION_H
# error This file may only be included from ${main_file_name}
#endif\n")
endif()
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
foreach(_lang ${_langs})
WCDH: Allow compilers to specify features for one language but not the other.
2015-01-17 16:10:26 +03:00
set(target_compilers)
foreach(compiler ${_WCD_COMPILERS})
_load_compiler_variables(${compiler} ${_lang} ${${_lang}_features})
if(_cmake_oldestSupported_${compiler})
list(APPEND target_compilers ${compiler})
endif()
endforeach()
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
get_property(known_features GLOBAL PROPERTY CMAKE_${_lang}_KNOWN_FEATURES)
foreach(feature ${${_lang}_features})
list(FIND known_features ${feature} idx)
if (idx EQUAL -1)
message(FATAL_ERROR "Unsupported feature ${feature}.")
endif()
endforeach()
if(_lang STREQUAL CXX)
set(file_content "${file_content}\n#ifdef __cplusplus\n")
Features: Extend concept to C language. Add properties and variables corresponding to CXX equivalents. Add features for c_function_prototypes (C90), c_restrict (C99), c_variadic_macros (C99) and c_static_assert (C11). This feature set can be extended later. Add a <PREFIX>_RESTRICT symbol define to WriteCompilerDetectionHeader to conditionally represent the c_restrict feature.
2013-11-04 04:15:43 +04:00
else()
set(file_content "${file_content}\n#ifndef __cplusplus\n")
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
endif()
compiler_id_detection(ID_CONTENT ${_lang} PREFIX ${prefix_arg}_
ID_DEFINE
)
set(file_content "${file_content}${ID_CONTENT}\n")
set(pp_if "if")
WCDH: Allow compilers to specify features for one language but not the other.
2015-01-17 16:10:26 +03:00
foreach(compiler ${target_compilers})
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
set(file_content "${file_content}\n# ${pp_if} ${prefix_arg}_COMPILER_IS_${compiler}\n")
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
if(_WCD_OUTPUT_FILES_VAR)
WCDH: Generate per-language files in multi-file mode. Otherwise we generate defines for C/CXX features unguarded by the presence of the __cplusplus macro and available to the wrong compiler.
2015-01-17 16:42:08 +03:00
set(compile_file_name "${_WCD_OUTPUT_DIR}${prefix_arg}_COMPILER_INFO_${compiler}_${_lang}.h")
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
set(file_content "${file_content}\n# include \"${compile_file_name}\"\n")
endif()
if(_WCD_OUTPUT_FILES_VAR)
WCDH: Generate per-language files in multi-file mode. Otherwise we generate defines for C/CXX features unguarded by the presence of the __cplusplus macro and available to the wrong compiler.
2015-01-17 16:42:08 +03:00
set(compiler_file_content compiler_file_content_${compiler}_${_lang})
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
else()
set(compiler_file_content file_content)
endif()
set(${compiler_file_content} "${${compiler_file_content}}
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# if !(${_cmake_oldestSupported_${compiler}})
# error Unsupported compiler version
# endif\n")
Features: Add compiler version support to WriteCompilerDetectionHeader.
2014-06-05 15:16:56 +04:00
set(PREFIX ${prefix_arg}_)
if (_need_hex_conversion)
set(MACRO_DEC ${prefix_arg}_DEC)
set(MACRO_HEX ${prefix_arg}_HEX)
else()
set(MACRO_DEC)
set(MACRO_HEX)
endif()
string(CONFIGURE "${_compiler_id_version_compute_${compiler}}" VERSION_BLOCK @ONLY)
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
set(${compiler_file_content} "${${compiler_file_content}}${VERSION_BLOCK}\n")
Features: Add compiler version support to WriteCompilerDetectionHeader.
2014-06-05 15:16:56 +04:00
set(PREFIX)
set(MACRO_DEC)
set(MACRO_HEX)
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
set(pp_if "elif")
foreach(feature ${${_lang}_features})
string(TOUPPER ${feature} feature_upper)
set(feature_PP "COMPILER_${feature_upper}")
set(_define_item "\n# define ${prefix_arg}_${feature_PP} 0\n")
if (_cmake_feature_test_${compiler}_${feature} STREQUAL "1")
set(_define_item "\n# define ${prefix_arg}_${feature_PP} 1\n")
elseif (_cmake_feature_test_${compiler}_${feature})
set(_define_item "\n# define ${prefix_arg}_${feature_PP} 0\n")
set(_define_item "\n# if ${_cmake_feature_test_${compiler}_${feature}}\n# define ${prefix_arg}_${feature_PP} 1\n# else${_define_item}# endif\n")
endif()
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
set(${compiler_file_content} "${${compiler_file_content}}${_define_item}")
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
endforeach()
endforeach()
if(pp_if STREQUAL "elif")
set(file_content "${file_content}
# else
# error Unsupported compiler
# endif\n")
endif()
foreach(feature ${${_lang}_features})
string(TOUPPER ${feature} feature_upper)
set(feature_PP "COMPILER_${feature_upper}")
set(def_name ${prefix_arg}_${feature_PP})
Features: Extend concept to C language. Add properties and variables corresponding to CXX equivalents. Add features for c_function_prototypes (C90), c_restrict (C99), c_variadic_macros (C99) and c_static_assert (C11). This feature set can be extended later. Add a <PREFIX>_RESTRICT symbol define to WriteCompilerDetectionHeader to conditionally represent the c_restrict feature.
2013-11-04 04:15:43 +04:00
if (feature STREQUAL c_restrict)
set(def_value "${prefix_arg}_RESTRICT")
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} restrict
# else
# define ${def_value}
# endif
\n")
endif()
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
if (feature STREQUAL cxx_constexpr)
WCDH: Remove noise from generated defines. The DECL part is redundant, and the language part is not needed. The source language and context already determines the language, so there is no need to repeat it in the define name.
2014-06-13 12:46:27 +04:00
set(def_value "${prefix_arg}_CONSTEXPR")
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} constexpr
# else
# define ${def_value}
# endif
\n")
endif()
if (feature STREQUAL cxx_final)
WCDH: Remove noise from generated defines. The DECL part is redundant, and the language part is not needed. The source language and context already determines the language, so there is no need to repeat it in the define name.
2014-06-13 12:46:27 +04:00
set(def_value "${prefix_arg}_FINAL")
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} final
# else
# define ${def_value}
# endif
\n")
endif()
if (feature STREQUAL cxx_override)
WCDH: Remove noise from generated defines. The DECL part is redundant, and the language part is not needed. The source language and context already determines the language, so there is no need to repeat it in the define name.
2014-06-13 12:46:27 +04:00
set(def_value "${prefix_arg}_OVERRIDE")
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} override
# else
# define ${def_value}
# endif
\n")
endif()
if (feature STREQUAL cxx_static_assert)
set(def_value "${prefix_arg}_STATIC_ASSERT(X)")
set(def_value_msg "${prefix_arg}_STATIC_ASSERT_MSG(X, MSG)")
set(static_assert_struct "template<bool> struct ${prefix_arg}StaticAssert;\ntemplate<> struct ${prefix_arg}StaticAssert<true>{};\n")
set(def_standard "# define ${def_value} static_assert(X, #X)\n# define ${def_value_msg} static_assert(X, MSG)")
set(def_alternative "${static_assert_struct}# define ${def_value} sizeof(${prefix_arg}StaticAssert<X>)\n# define ${def_value_msg} sizeof(${prefix_arg}StaticAssert<X>)")
set(file_content "${file_content}# if ${def_name}\n${def_standard}\n# else\n${def_alternative}\n# endif\n\n")
endif()
if (feature STREQUAL cxx_alignas)
set(def_value "${prefix_arg}_ALIGNAS(X)")
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} alignas(X)
Features: Record for AppleClang 5.1 Apple's Clang 5.1 already supports most of the C and C++ features CMake enumerates.
2014-11-13 00:48:17 +03:00
# elif ${prefix_arg}_COMPILER_IS_GNU || ${prefix_arg}_COMPILER_IS_Clang || ${prefix_arg}_COMPILER_IS_AppleClang
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# define ${def_value} __attribute__ ((__aligned__(X)))
Features: Record for MSVC 2010-2015 Also, in WCDH add MSVC Compatibility for cxx_align{of,as}. Co-Author: Stephen Kelly <steveire@gmail.com> Co-Author: Brad King <brad.king@kitware.com>
2015-01-19 23:49:06 +03:00
# elif ${prefix_arg}_COMPILER_IS_MSVC
# define ${def_value} __declspec(align(X))
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# else
# define ${def_value}
# endif
\n")
endif()
if (feature STREQUAL cxx_alignof)
set(def_value "${prefix_arg}_ALIGNOF(X)")
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} alignof(X)
Features: Record for AppleClang 5.1 Apple's Clang 5.1 already supports most of the C and C++ features CMake enumerates.
2014-11-13 00:48:17 +03:00
# elif ${prefix_arg}_COMPILER_IS_GNU || ${prefix_arg}_COMPILER_IS_Clang || ${prefix_arg}_COMPILER_IS_AppleClang
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# define ${def_value} __alignof__(X)
Features: Record for MSVC 2010-2015 Also, in WCDH add MSVC Compatibility for cxx_align{of,as}. Co-Author: Stephen Kelly <steveire@gmail.com> Co-Author: Brad King <brad.king@kitware.com>
2015-01-19 23:49:06 +03:00
# elif ${prefix_arg}_COMPILER_IS_MSVC
# define ${def_value} __alignof(X)
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# endif
\n")
endif()
if (feature STREQUAL cxx_deleted_functions)
set(def_value "${prefix_arg}_DELETED_FUNCTION")
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} = delete
# else
# define ${def_value}
# endif
\n")
endif()
if (feature STREQUAL cxx_extern_templates)
set(def_value "${prefix_arg}_EXTERN_TEMPLATE")
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} extern
# else
# define ${def_value}
# endif
\n")
endif()
if (feature STREQUAL cxx_noexcept)
set(def_value "${prefix_arg}_NOEXCEPT")
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} noexcept
# define ${def_value}_EXPR(X) noexcept(X)
# else
# define ${def_value}
# define ${def_value}_EXPR(X)
# endif
\n")
endif()
if (feature STREQUAL cxx_nullptr)
set(def_value "${prefix_arg}_NULLPTR")
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} nullptr
# else
WCDH: Fix cxx_nullptr workaround for pre-C++11 compilers Use just '0' instead of 'static_cast<void*>(0)' because the latter will not automatically convert to pointers to other types.
2015-03-13 11:18:19 +03:00
# define ${def_value} 0
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
# endif
WCDH: Add feature portability for thread_local. AppleClang does not support the cxx_thread_local feature, even though it is based on a Clang version which does support the feature. http://stackoverflow.com/a/23850891/2428389 A possible reason for that is that thread_local might be used as a variable in existing Apple SDK headers. Extend the WriteCompilerDetectionHeader module to generate a define for that feature with portability fallbacks. For the avoidance of making it easy to write code which looks correct but which has odd runtime behavior, don't set the define symbol at all if no equivalent keyword is known.
2015-01-01 19:56:01 +03:00
\n")
endif()
if (feature STREQUAL cxx_thread_local)
set(def_value "${prefix_arg}_THREAD_LOCAL")
set(file_content "${file_content}
# if ${def_name}
# define ${def_value} thread_local
# elif ${prefix_arg}_COMPILER_IS_GNU || ${prefix_arg}_COMPILER_IS_Clang || ${prefix_arg}_COMPILER_IS_AppleClang
# define ${def_value} __thread
# elif ${prefix_arg}_COMPILER_IS_MSVC
# define ${def_value} __declspec(thread)
# else
// ${def_value} not defined for this configuration.
# endif
WCDH: Add compatibility defines for deprecation.
2014-05-15 00:10:10 +04:00
\n")
endif()
if (feature STREQUAL cxx_attribute_deprecated)
set(def_name ${prefix_arg}_${feature_PP})
set(def_value "${prefix_arg}_DEPRECATED")
set(file_content "${file_content}
# ifndef ${def_value}
# if ${def_name}
# define ${def_value} [[deprecated]]
# define ${def_value}_MSG(MSG) [[deprecated(MSG)]]
WCDH: Fix compiler id test for compatibility macros. Enable the alignment features for Clang.
2014-06-13 13:08:34 +04:00
# elif ${prefix_arg}_COMPILER_IS_GNU || ${prefix_arg}_COMPILER_IS_Clang
WCDH: Add compatibility defines for deprecation.
2014-05-15 00:10:10 +04:00
# define ${def_value} __attribute__((__deprecated__))
# define ${def_value}_MSG(MSG) __attribute__((__deprecated__(MSG)))
WCDH: Fix compiler id test for compatibility macros. Enable the alignment features for Clang.
2014-06-13 13:08:34 +04:00
# elif ${prefix_arg}_COMPILER_IS_MSVC
WCDH: Add compatibility defines for deprecation.
2014-05-15 00:10:10 +04:00
# define ${def_value} __declspec(deprecated)
# define ${def_value}_MSG(MSG) __declspec(deprecated(MSG))
# else
# define ${def_value}
# define ${def_value}_MSG(MSG)
# endif
# endif
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
\n")
endif()
endforeach()
Features: Extend concept to C language. Add properties and variables corresponding to CXX equivalents. Add features for c_function_prototypes (C90), c_restrict (C99), c_variadic_macros (C99) and c_static_assert (C11). This feature set can be extended later. Add a <PREFIX>_RESTRICT symbol define to WriteCompilerDetectionHeader to conditionally represent the c_restrict feature.
2013-11-04 04:15:43 +04:00
set(file_content "${file_content}#endif\n")
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
endforeach()
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
if(_WCD_OUTPUT_FILES_VAR)
foreach(compiler ${_WCD_COMPILERS})
WCDH: Generate per-language files in multi-file mode. Otherwise we generate defines for C/CXX features unguarded by the presence of the __cplusplus macro and available to the wrong compiler.
2015-01-17 16:42:08 +03:00
foreach(_lang ${_langs})
if(compiler_file_content_${compiler}_${_lang})
set(CMAKE_CONFIGURABLE_FILE_CONTENT "${compiler_file_content_}")
set(CMAKE_CONFIGURABLE_FILE_CONTENT "${CMAKE_CONFIGURABLE_FILE_CONTENT}${compiler_file_content_${compiler}_${_lang}}")
set(compile_file_name "${_WCD_OUTPUT_DIR}${prefix_arg}_COMPILER_INFO_${compiler}_${_lang}.h")
set(full_path "${main_file_dir}/${compile_file_name}")
list(APPEND ${_WCD_OUTPUT_FILES_VAR} ${full_path})
configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
"${full_path}"
@ONLY
)
endif()
endforeach()
WCDH: Make it possible to generate multiple files. Extend the write_compiler_detection_header interface to allow specifying a location for supplementary files, and getting the list of resulting files as a variable.
2014-10-31 02:41:53 +03:00
endforeach()
set(${_WCD_OUTPUT_FILES_VAR} ${${_WCD_OUTPUT_FILES_VAR}} PARENT_SCOPE)
endif()
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
if (_WCD_EPILOG)
set(file_content "${file_content}\n${_WCD_EPILOG}\n")
endif()
set(file_content "${file_content}\n#endif")
set(CMAKE_CONFIGURABLE_FILE_CONTENT ${file_content})
configure_file("${CMAKE_ROOT}/Modules/CMakeConfigurableFile.in"
"${file_arg}"
@ONLY
)
endfunction()