diff options
| -rw-r--r-- | Help/release/3.5.rst | 6 | ||||
| -rw-r--r-- | Modules/CTestCoverageCollectGCOV.cmake | 64 | ||||
| -rw-r--r-- | Modules/FortranCInterface.cmake | 313 | ||||
| -rw-r--r-- | Source/CMakeVersion.cmake | 2 | ||||
| -rw-r--r-- | Source/cmListFileCache.h | 3 | ||||
| -rw-r--r-- | Source/cmLocalNinjaGenerator.cxx | 17 | ||||
| -rw-r--r-- | Source/cmLocalNinjaGenerator.h | 1 |
7 files changed, 258 insertions, 148 deletions
diff --git a/Help/release/3.5.rst b/Help/release/3.5.rst index 3d1e3b4..62703b3 100644 --- a/Help/release/3.5.rst +++ b/Help/release/3.5.rst @@ -167,6 +167,12 @@ Deprecated and Removed Features may break scripts that worked around the bug with their own extra quoting or escaping. +* The :generator:`Xcode` generator was fixed to escape backslashes in + strings consistently with other generators. Projects that previously + worked around the inconsistecy with an extra level of backslashes + conditioned on the Xcode generator must be updated to remove the + workaround for CMake 3.5 and greater. + Other Changes ============= diff --git a/Modules/CTestCoverageCollectGCOV.cmake b/Modules/CTestCoverageCollectGCOV.cmake index ef3aa76..f31e432 100644 --- a/Modules/CTestCoverageCollectGCOV.cmake +++ b/Modules/CTestCoverageCollectGCOV.cmake @@ -46,6 +46,13 @@ # is run as ``gcov <options>... -o <gcov-dir> <file>.gcda``. # If not specified, the default option is just ``-b``. # +# ``GLOB`` +# Recursively search for .gcda files in build_dir rather than +# determining search locations by reading TargetDirectories.txt. +# +# ``DELETE`` +# Delete coverage files after they've been packaged into the .tar. +# # ``QUIET`` # Suppress non-error messages that otherwise would have been # printed out by this function. @@ -64,7 +71,7 @@ # License text for the above reference.) include(CMakeParseArguments) function(ctest_coverage_collect_gcov) - set(options QUIET) + set(options QUIET GLOB DELETE) set(oneValueArgs TARBALL SOURCE BUILD GCOV_COMMAND) set(multiValueArgs GCOV_OPTIONS) cmake_parse_arguments(GCOV "${options}" "${oneValueArgs}" @@ -91,22 +98,32 @@ function(ctest_coverage_collect_gcov) # run gcov on each gcda file in the binary tree set(gcda_files) set(label_files) - # look for gcda files in the target directories - # could do a glob from the top of the binary tree but - # this will be faster and only look where the files will be - file(STRINGS "${binary_dir}/CMakeFiles/TargetDirectories.txt" target_dirs - ENCODING UTF-8) - foreach(target_dir ${target_dirs}) - file(GLOB_RECURSE gfiles RELATIVE ${binary_dir} "${target_dir}/*.gcda") - list(LENGTH gfiles len) - # if we have gcda files then also grab the labels file for that target - if(${len} GREATER 0) - file(GLOB_RECURSE lfiles RELATIVE ${binary_dir} - "${target_dir}/Labels.json") - list(APPEND gcda_files ${gfiles}) - list(APPEND label_files ${lfiles}) - endif() - endforeach() + if (GCOV_GLOB) + file(GLOB_RECURSE gfiles RELATIVE ${binary_dir} "*.gcda") + list(LENGTH gfiles len) + # if we have gcda files then also grab the labels file for that target + if(${len} GREATER 0) + file(GLOB_RECURSE lfiles RELATIVE ${binary_dir} "Labels.json") + list(APPEND gcda_files ${gfiles}) + list(APPEND label_files ${lfiles}) + endif() + else() + # look for gcda files in the target directories + # this will be faster and only look where the files will be + file(STRINGS "${binary_dir}/CMakeFiles/TargetDirectories.txt" target_dirs + ENCODING UTF-8) + foreach(target_dir ${target_dirs}) + file(GLOB_RECURSE gfiles RELATIVE ${binary_dir} "${target_dir}/*.gcda") + list(LENGTH gfiles len) + # if we have gcda files then also grab the labels file for that target + if(${len} GREATER 0) + file(GLOB_RECURSE lfiles RELATIVE ${binary_dir} + "${target_dir}/Labels.json") + list(APPEND gcda_files ${gfiles}) + list(APPEND label_files ${lfiles}) + endif() + endforeach() + endif() # return early if no coverage files were found list(LENGTH gcda_files len) if(len EQUAL 0) @@ -134,6 +151,11 @@ function(ctest_coverage_collect_gcov) OUTPUT_VARIABLE out RESULT_VARIABLE res WORKING_DIRECTORY ${coverage_dir}) + + if (GCOV_DELETE) + file(REMOVE ${gcda_file}) + endif() + endforeach() if(NOT "${res}" EQUAL 0) if (NOT GCOV_QUIET) @@ -201,4 +223,12 @@ ${label_files} "--format=gnutar" --files-from=${coverage_dir}/coverage_file_list.txt WORKING_DIRECTORY ${binary_dir}) + + if (GCOV_DELETE) + string(REPLACE "\n" ";" gcov_files "${gcov_files}") + foreach(gcov_file ${gcov_files}) + file(REMOVE ${binary_dir}/${gcov_file}) + endforeach() + endif() + endfunction() diff --git a/Modules/FortranCInterface.cmake b/Modules/FortranCInterface.cmake index 70c3fd7..c12dd4c 100644 --- a/Modules/FortranCInterface.cmake +++ b/Modules/FortranCInterface.cmake @@ -1,129 +1,190 @@ -#.rst: -# FortranCInterface -# ----------------- -# -# Fortran/C Interface Detection -# -# This module automatically detects the API by which C and Fortran -# languages interact. Variables indicate if the mangling is found: -# -# :: -# -# FortranCInterface_GLOBAL_FOUND = Global subroutines and functions -# FortranCInterface_MODULE_FOUND = Module subroutines and functions -# (declared by "MODULE PROCEDURE") -# -# A function is provided to generate a C header file containing macros -# to mangle symbol names: -# -# :: -# -# FortranCInterface_HEADER(<file> -# [MACRO_NAMESPACE <macro-ns>] -# [SYMBOL_NAMESPACE <ns>] -# [SYMBOLS [<module>:]<function> ...]) -# -# It generates in <file> definitions of the following macros: -# -# :: -# -# #define FortranCInterface_GLOBAL (name,NAME) ... -# #define FortranCInterface_GLOBAL_(name,NAME) ... -# #define FortranCInterface_MODULE (mod,name, MOD,NAME) ... -# #define FortranCInterface_MODULE_(mod,name, MOD,NAME) ... -# -# These macros mangle four categories of Fortran symbols, respectively: -# -# :: -# -# - Global symbols without '_': call mysub() -# - Global symbols with '_' : call my_sub() -# - Module symbols without '_': use mymod; call mysub() -# - Module symbols with '_' : use mymod; call my_sub() -# -# If mangling for a category is not known, its macro is left undefined. -# All macros require raw names in both lower case and upper case. The -# MACRO_NAMESPACE option replaces the default "FortranCInterface_" -# prefix with a given namespace "<macro-ns>". -# -# The SYMBOLS option lists symbols to mangle automatically with C -# preprocessor definitions: -# -# :: -# -# <function> ==> #define <ns><function> ... -# <module>:<function> ==> #define <ns><module>_<function> ... -# -# If the mangling for some symbol is not known then no preprocessor -# definition is created, and a warning is displayed. The -# SYMBOL_NAMESPACE option prefixes all preprocessor definitions -# generated by the SYMBOLS option with a given namespace "<ns>". -# -# Example usage: -# -# :: -# -# include(FortranCInterface) -# FortranCInterface_HEADER(FC.h MACRO_NAMESPACE "FC_") -# -# This creates a "FC.h" header that defines mangling macros FC_GLOBAL(), -# FC_GLOBAL_(), FC_MODULE(), and FC_MODULE_(). -# -# Example usage: -# -# :: -# -# include(FortranCInterface) -# FortranCInterface_HEADER(FCMangle.h -# MACRO_NAMESPACE "FC_" -# SYMBOL_NAMESPACE "FC_" -# SYMBOLS mysub mymod:my_sub) -# -# This creates a "FCMangle.h" header that defines the same FC_*() -# mangling macros as the previous example plus preprocessor symbols -# FC_mysub and FC_mymod_my_sub. -# -# Another function is provided to verify that the Fortran and C/C++ -# compilers work together: -# -# :: -# -# FortranCInterface_VERIFY([CXX] [QUIET]) -# -# It tests whether a simple test executable using Fortran and C (and C++ -# when the CXX option is given) compiles and links successfully. The -# result is stored in the cache entry FortranCInterface_VERIFIED_C (or -# FortranCInterface_VERIFIED_CXX if CXX is given) as a boolean. If the -# check fails and QUIET is not given the function terminates with a -# FATAL_ERROR message describing the problem. The purpose of this check -# is to stop a build early for incompatible compiler combinations. The -# test is built in the Release configuration. -# -# FortranCInterface is aware of possible GLOBAL and MODULE manglings for -# many Fortran compilers, but it also provides an interface to specify -# new possible manglings. Set the variables -# -# :: -# -# FortranCInterface_GLOBAL_SYMBOLS -# FortranCInterface_MODULE_SYMBOLS -# -# before including FortranCInterface to specify manglings of the symbols -# "MySub", "My_Sub", "MyModule:MySub", and "My_Module:My_Sub". For -# example, the code: -# -# :: -# -# set(FortranCInterface_GLOBAL_SYMBOLS mysub_ my_sub__ MYSUB_) -# # ^^^^^ ^^^^^^ ^^^^^ -# set(FortranCInterface_MODULE_SYMBOLS -# __mymodule_MOD_mysub __my_module_MOD_my_sub) -# # ^^^^^^^^ ^^^^^ ^^^^^^^^^ ^^^^^^ -# include(FortranCInterface) -# -# tells FortranCInterface to try given GLOBAL and MODULE manglings. -# (The carets point at raw symbol names for clarity in this example but -# are not needed.) +#[=======================================================================[.rst: +FortranCInterface +----------------- + +Fortran/C Interface Detection + +This module automatically detects the API by which C and Fortran +languages interact. + +Module Variables +^^^^^^^^^^^^^^^^ + +Variables that indicate if the mangling is found: + +``FortranCInterface_GLOBAL_FOUND`` + Global subroutines and functions. + +``FortranCInterface_MODULE_FOUND`` + Module subroutines and functions (declared by "MODULE PROCEDURE"). + +This module also provides the following variables to specify +the detected mangling, though a typical use case does not need +to reference them and can use the `Module Functions`_ below. + +``FortranCInterface_GLOBAL_PREFIX`` + Prefix for a global symbol without an underscore. + +``FortranCInterface_GLOBAL_SUFFIX`` + Suffix for a global symbol without an underscore. + +``FortranCInterface_GLOBAL_CASE`` + The case for a global symbol without an underscore, + either ``UPPER`` or ``LOWER``. + +``FortranCInterface_GLOBAL__PREFIX`` + Prefix for a global symbol with an underscore. + +``FortranCInterface_GLOBAL__SUFFIX`` + Suffix for a global symbol with an underscore. + +``FortranCInterface_GLOBAL__CASE`` + The case for a global symbol with an underscore, + either ``UPPER`` or ``LOWER``. + +``FortranCInterface_MODULE_PREFIX`` + Prefix for a module symbol without an underscore. + +``FortranCInterface_MODULE_MIDDLE`` + Middle of a module symbol without an underscore that appears + between the name of the module and the name of the symbol. + +``FortranCInterface_MODULE_SUFFIX`` + Suffix for a module symbol without an underscore. + +``FortranCInterface_MODULE_CASE`` + The case for a module symbol without an underscore, + either ``UPPER`` or ``LOWER``. + +``FortranCInterface_MODULE__PREFIX`` + Prefix for a module symbol with an underscore. + +``FortranCInterface_MODULE__MIDDLE`` + Middle of a module symbol with an underscore that appears + between the name of the module and the name of the symbol. + +``FortranCInterface_MODULE__SUFFIX`` + Suffix for a module symbol with an underscore. + +``FortranCInterface_MODULE__CASE`` + The case for a module symbol with an underscore, + either ``UPPER`` or ``LOWER``. + +Module Functions +^^^^^^^^^^^^^^^^ + +.. command:: FortranCInterface_HEADER + + The ``FortranCInterface_HEADER`` function is provided to generate a + C header file containing macros to mangle symbol names:: + + FortranCInterface_HEADER(<file> + [MACRO_NAMESPACE <macro-ns>] + [SYMBOL_NAMESPACE <ns>] + [SYMBOLS [<module>:]<function> ...]) + + It generates in ``<file>`` definitions of the following macros:: + + #define FortranCInterface_GLOBAL (name,NAME) ... + #define FortranCInterface_GLOBAL_(name,NAME) ... + #define FortranCInterface_MODULE (mod,name, MOD,NAME) ... + #define FortranCInterface_MODULE_(mod,name, MOD,NAME) ... + + These macros mangle four categories of Fortran symbols, respectively: + + * Global symbols without '_': ``call mysub()`` + * Global symbols with '_' : ``call my_sub()`` + * Module symbols without '_': ``use mymod; call mysub()`` + * Module symbols with '_' : ``use mymod; call my_sub()`` + + If mangling for a category is not known, its macro is left undefined. + All macros require raw names in both lower case and upper case. + + The options are: + + ``MACRO_NAMESPACE`` + Replace the default ``FortranCInterface_`` prefix with a given + namespace ``<macro-ns>``. + + ``SYMBOLS`` + List symbols to mangle automatically with C preprocessor definitions:: + + <function> ==> #define <ns><function> ... + <module>:<function> ==> #define <ns><module>_<function> ... + + If the mangling for some symbol is not known then no preprocessor + definition is created, and a warning is displayed. + + ``SYMBOL_NAMESPACE`` + Prefix all preprocessor definitions generated by the ``SYMBOLS`` + option with a given namespace ``<ns>``. + +.. command:: FortranCInterface_VERIFY + + The ``FortranCInterface_VERIFY`` function is provided to verify + that the Fortran and C/C++ compilers work together:: + + FortranCInterface_VERIFY([CXX] [QUIET]) + + It tests whether a simple test executable using Fortran and C (and C++ + when the CXX option is given) compiles and links successfully. The + result is stored in the cache entry ``FortranCInterface_VERIFIED_C`` + (or ``FortranCInterface_VERIFIED_CXX`` if ``CXX`` is given) as a boolean. + If the check fails and ``QUIET`` is not given the function terminates with a + fatal error message describing the problem. The purpose of this check + is to stop a build early for incompatible compiler combinations. The + test is built in the ``Release`` configuration. + +Example Usage +^^^^^^^^^^^^^ + +.. code-block:: cmake + + include(FortranCInterface) + FortranCInterface_HEADER(FC.h MACRO_NAMESPACE "FC_") + +This creates a "FC.h" header that defines mangling macros ``FC_GLOBAL()``, +``FC_GLOBAL_()``, ``FC_MODULE()``, and ``FC_MODULE_()``. + +.. code-block:: cmake + + include(FortranCInterface) + FortranCInterface_HEADER(FCMangle.h + MACRO_NAMESPACE "FC_" + SYMBOL_NAMESPACE "FC_" + SYMBOLS mysub mymod:my_sub) + +This creates a "FCMangle.h" header that defines the same ``FC_*()`` +mangling macros as the previous example plus preprocessor symbols +``FC_mysub`` and ``FC_mymod_my_sub``. + +Additional Manglings +^^^^^^^^^^^^^^^^^^^^ + +FortranCInterface is aware of possible ``GLOBAL`` and ``MODULE`` manglings +for many Fortran compilers, but it also provides an interface to specify +new possible manglings. Set the variables:: + + FortranCInterface_GLOBAL_SYMBOLS + FortranCInterface_MODULE_SYMBOLS + +before including FortranCInterface to specify manglings of the symbols +``MySub``, ``My_Sub``, ``MyModule:MySub``, and ``My_Module:My_Sub``. +For example, the code: + +.. code-block:: cmake + + set(FortranCInterface_GLOBAL_SYMBOLS mysub_ my_sub__ MYSUB_) + # ^^^^^ ^^^^^^ ^^^^^ + set(FortranCInterface_MODULE_SYMBOLS + __mymodule_MOD_mysub __my_module_MOD_my_sub) + # ^^^^^^^^ ^^^^^ ^^^^^^^^^ ^^^^^^ + include(FortranCInterface) + +tells FortranCInterface to try given ``GLOBAL`` and ``MODULE`` manglings. +(The carets point at raw symbol names for clarity in this example but +are not needed.) +#]=======================================================================] #============================================================================= # Copyright 2008-2009 Kitware, Inc. diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index 9f3731d..df07c51 100644 --- a/Source/CMakeVersion.cmake +++ b/Source/CMakeVersion.cmake @@ -1,5 +1,5 @@ # CMake version number components. set(CMake_VERSION_MAJOR 3) set(CMake_VERSION_MINOR 5) -set(CMake_VERSION_PATCH 20160211) +set(CMake_VERSION_PATCH 20160212) #set(CMake_VERSION_RC 1) diff --git a/Source/cmListFileCache.h b/Source/cmListFileCache.h index 03e0abe..4d3055f 100644 --- a/Source/cmListFileCache.h +++ b/Source/cmListFileCache.h @@ -58,8 +58,9 @@ struct cmListFileArgument long Line; }; -struct cmListFileContext +class cmListFileContext { +public: std::string Name; std::string FilePath; long Line; diff --git a/Source/cmLocalNinjaGenerator.cxx b/Source/cmLocalNinjaGenerator.cxx index b2927a9..8a68af6 100644 --- a/Source/cmLocalNinjaGenerator.cxx +++ b/Source/cmLocalNinjaGenerator.cxx @@ -454,13 +454,24 @@ cmLocalNinjaGenerator::WriteCustomCommandBuildStatement( void cmLocalNinjaGenerator::AddCustomCommandTarget(cmCustomCommand const* cc, cmGeneratorTarget* target) { - this->CustomCommandTargets[cc].insert(target); + CustomCommandTargetMap::value_type v(cc, std::set<cmGeneratorTarget*>()); + std::pair<CustomCommandTargetMap::iterator, bool> + ins = this->CustomCommandTargets.insert(v); + if (ins.second) + { + this->CustomCommands.push_back(cc); + } + ins.first->second.insert(target); } void cmLocalNinjaGenerator::WriteCustomCommandBuildStatements() { - for (CustomCommandTargetMap::iterator i = this->CustomCommandTargets.begin(); - i != this->CustomCommandTargets.end(); ++i) { + for (std::vector<cmCustomCommand const*>::iterator vi = + this->CustomCommands.begin(); vi != this->CustomCommands.end(); ++vi) + { + CustomCommandTargetMap::iterator i = this->CustomCommandTargets.find(*vi); + assert(i != this->CustomCommandTargets.end()); + // A custom command may appear on multiple targets. However, some build // systems exist where the target dependencies on some of the targets are // overspecified, leading to a dependency cycle. If we assume all target diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h index b6987ef..5e1d6f2 100644 --- a/Source/cmLocalNinjaGenerator.h +++ b/Source/cmLocalNinjaGenerator.h @@ -106,6 +106,7 @@ private: typedef std::map<cmCustomCommand const*, std::set<cmGeneratorTarget*> > CustomCommandTargetMap; CustomCommandTargetMap CustomCommandTargets; + std::vector<cmCustomCommand const*> CustomCommands; }; #endif // ! cmLocalNinjaGenerator_h |