kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Tests/Preprocess/CMakeLists.txt

285 lines
9.9 KiB
CMake
Raw Normal View History

BUG: Convert cmake_policy(VERSION) to cmake_minimum_required(VERSION) in Tests/MakeClean/ToClean/CMakeLists.txt and Tests/Preprocess/CMakeLists.txt. CMP0000 now requires the cmake_minimum_required command.
2008-03-21 01:25:33 +03:00
cmake_minimum_required(VERSION 2.6)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
project(Preprocess)
# This test is meant both as a test and as a reference for supported
# syntax on native tool command lines.
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
# Determine the build tool being used. Not all characters can be
# escaped for all build tools. This test checks all characters known
# to work with each tool and documents those known to not work.
BUG: Fix typo XCode -> Xcode in Preprocess test.
2008-03-01 18:56:03 +03:00
if("${CMAKE_GENERATOR}" MATCHES "Xcode")
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
set(PP_XCODE 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 6")
set(PP_VS6 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles")
set(PP_UMAKE 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if("${CMAKE_GENERATOR}" MATCHES "NMake Makefiles")
set(PP_NMAKE 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if("${CMAKE_GENERATOR}" MATCHES "MinGW Makefiles")
set(PP_MINGW 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if("${CMAKE_GENERATOR}" MATCHES "Borland Makefiles")
set(PP_BORLAND 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if("${CMAKE_GENERATOR}" MATCHES "Watcom WMake")
set(PP_WATCOM 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 7$")
set(PP_VS70 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
set(PP_VS 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: almost all tests passing in vs 10, commit fixes preprocess and starts vs external project
2009-07-14 00:58:24 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 10")
set(PP_VS100 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Teach our tests about special cases for VS 11 Teach the CheckCompilerRelatedVariables test to verify MSVC11. Update the special cases already in the Preprocess and VSExternalInclude tests for VS 10 to work for VS 11 too.
2011-09-23 19:04:15 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 11")
set(PP_VS110 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
VS12: Add Visual Studio 12 generator (#14251) Copy cmGlobalVisualStudio11Generator to cmGlobalVisualStudio12Generator and update version numbers accordingly. Add the VS12 enumeration value. Add module CMakeVS12FindMake to find MSBuild. Look for MSBuild in its now-dedicated Windows Registry entry. Teach the platform module Windows-MSVC to set MSVC12 and document the variable. Teach module InstallRequiredSystemLibraries to look for the VS 12 runtime libraries. Teach tests CheckCompilerRelatedVariables, Preprocess, VSExternalInclude, and RunCMake.GeneratorToolset to treat VS 12 as they do VS 10 and 11. Inspired-by: Minmin Gong <minmin.gong@gmail.com>
2013-06-29 00:12:08 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio 12")
set(PP_VS120 1)
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
# Some tests below check the PP_* variables set above. They are meant
# to test the case that the build tool is at fault. Other tests below
# check the compiler that will be used when the compiler is at fault
# (does not work even from a command shell).
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
#-----------------------------------------------------------------------------
# Construct a C-string literal to test passing through a definition on
# the command line. We configure the value into a header so it can be
# checked in the executable at runtime. The semicolon is handled
# specially because it needs to be escaped in the COMPILE_DEFINITIONS
# property value to avoid separating definitions but the string value
# must not have it escaped inside the configured header.
set(STRING_EXTRA "")
VS 10: Escape ; as %3B in preprocessor definitions (#14073) Use the suggestion from http://support.microsoft.com/kb/2262855 to escape semicolons in preprocessor definitions for VS >= 10. Update the COMPILE_DEFINITIONS documentation disclaimer list of known limitations accordingly. Update our "Preprocess" test to cover the case. Suggested-by: Jean-Christophe Fillion-Robin <jchris.fillionr@kitware.com>
2013-04-11 19:34:17 +04:00
if(NOT BORLAND AND NOT PP_VS70)
BUG: Disable semicolon test on VS 7.0.
2008-01-14 19:21:06 +03:00
# Borland, VS70 IDE: ;
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# The Borland compiler will simply not accept a non-escaped semicolon
# on the command line. If it is escaped \; then the escape character
# shows up in the preprocessing output too.
BUG: Disable semicolon test on VS 7.0.
2008-01-14 19:21:06 +03:00
#
# The VS 7.0 IDE separates definitions on semicolons and commas with
# no regard for quotes. Fortunately VS 7.1 and above are okay.
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
set(SEMICOLON "\;")
ENH: almost all tests passing in vs 10, commit fixes preprocess and starts vs external project
2009-07-14 00:58:24 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
ENH: Support preprocessor def values in VS6 The add_definitions() command and COMPILE_DEFINITIONS dir/tgt/src properties support preprocessor definitions with values. Previously values were not supported in the VS6 generator even though the native tool supports them. It is only values with spaces that VS6 does not support. This enables support and instead complains only for values with spaces. See issue #8779.
2009-03-23 21:48:09 +03:00
if(NOT PP_VS6)
ENH: Support more preprocessor values in VS6 Previously we rejected all preprocessor definition values containing spaces for the VS6 IDE generator. In fact VS6 does support spaces but not in combination with '"', '$', or ';', and only if we use the sytnax '-DNAME="value with spaces"' instead of '-D"NAME=value with spaces"'. Now we support all definition values that do not have one of these invalid pairs. See issue #8779.
2009-04-24 19:18:06 +04:00
# VS 6 IDE: spaces and '"', '$', or ';'
# The project parser cannot handle spaces if there are quotes.
# Since we test passing in a quoted string, we cannot have spaces.
ENH: Support preprocessor def values in VS6 The add_definitions() command and COMPILE_DEFINITIONS dir/tgt/src properties support preprocessor definitions with values. Previously values were not supported in the VS6 generator even though the native tool supports them. It is only values with spaces that VS6 does not support. This enables support and instead complains only for values with spaces. See issue #8779.
2009-03-23 21:48:09 +03:00
set(STRING_EXTRA "${STRING_EXTRA} ")
if(NOT PP_BORLAND AND NOT PP_WATCOM)
# Borland, WMake: multiple spaces
# The make tool seems to remove extra whitespace from inside
# quoted strings when passing to the compiler. It does not have
# trouble passing to other tools, and the compiler may be directly
# invoked from the command line.
set(STRING_EXTRA "${STRING_EXTRA} ")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if(NOT PP_VS)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# VS: ,
# Visual Studio will not accept a comma in the value of a definition.
# The comma-separated list of PreprocessorDefinitions in the project
# file seems to be parsed before the content of entries is examined.
set(STRING_EXTRA "${STRING_EXTRA},")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if(NOT PP_MINGW)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# MinGW: &
# When inside -D"FOO=\"a & b\"" MinGW make wants -D"FOO=\"a "&" b\""
# but it does not like quoted ampersand elsewhere.
set(STRING_EXTRA "${STRING_EXTRA}&")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if(NOT PP_MINGW)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# MinGW: |
# When inside -D"FOO=\"a | b\"" MinGW make wants -D"FOO=\"a "|" b\""
# but it does not like quoted pipe elsewhere.
set(STRING_EXTRA "${STRING_EXTRA}|")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if(NOT PP_BORLAND AND NOT PP_MINGW AND NOT PP_NMAKE)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# Borland, NMake, MinGW: ^
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
# When inside -D"FOO=\"a ^ b\"" the make tools want -D"FOO=\"a "^" b\""
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# but do not like quoted carrot elsewhere. In NMake the non-quoted
# syntax works when the flags are not in a make variable.
set(STRING_EXTRA "${STRING_EXTRA}^")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if(NOT PP_BORLAND AND NOT PP_MINGW AND NOT PP_NMAKE)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# Borland, MinGW: < >
# Angle-brackets have funny behavior that is hard to escape.
set(STRING_EXTRA "${STRING_EXTRA}<>")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
set(EXPR_OP1 "/")
Fix Preprocess test for Intel on Windows We need to leave out the '%' character from tests with the Intel compiler. Since '%' needs to be written '%%' in NMake when not using a response file but just '%' when using a response file, we just skip the character for now. It works with MSVC in NMake only because that compiler expects '%%' inside response files, which do get used.
2009-10-05 22:39:28 +04:00
if((NOT MSVC OR PP_NMAKE) AND
NOT "${CMAKE_C_COMPILER_ID}" MATCHES "^(Intel)$")
# MSVC cl, Intel icl: %
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
# When the cl compiler is invoked from the command line then % must
# be written %% (to distinguish from %ENV% syntax). However cl does
# not seem to accept the syntax when it is invoked from inside a
# make tool (nmake, mingw32-make, etc.). Instead the argument must
# be placed inside a response file. Then cl accepts it because it
# parses the response file as it would the normal windows command
# line. Currently only NMake supports running cl with a response
# file. Supporting other make tools would require CMake to generate
# response files explicitly for each object file.
Fix Preprocess test for Intel on Windows We need to leave out the '%' character from tests with the Intel compiler. Since '%' needs to be written '%%' in NMake when not using a response file but just '%' when using a response file, we just skip the character for now. It works with MSVC in NMake only because that compiler expects '%%' inside response files, which do get used.
2009-10-05 22:39:28 +04:00
#
# When the icl compiler is invoked from the command line then % must
# be written just '%'. However nmake requires '%%' except when using
# response files. Currently we have no way to affect escaping based
# on whether flags go in a response file, so we just have to skip it.
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
set(STRING_EXTRA "${STRING_EXTRA}%")
set(EXPR_OP1 "%")
Fix Preprocess test for Intel on Windows We need to leave out the '%' character from tests with the Intel compiler. Since '%' needs to be written '%%' in NMake when not using a response file but just '%' when using a response file, we just skip the character for now. It works with MSVC in NMake only because that compiler expects '%%' inside response files, which do get used.
2009-10-05 22:39:28 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# General: \"
# Make tools do not reliably accept \\\" syntax:
# - MinGW and MSYS make tools crash with \\\"
# - Borland make actually wants a mis-matched quote \\"
# or $(BACKSLASH)\" where BACKSLASH is a variable set to \\
# - VS IDE gets confused about the bounds of the definition value \\\"
# - NMake is okay with just \\\"
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if(PP_NMAKE OR PP_UMAKE)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
set(STRING_EXTRA "${STRING_EXTRA}\\\"")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# General: #
# MSVC will not accept a # in the value of a string definition on the
# command line. The character seems to be simply replaced by an
# equals =. According to "cl -help" definitions may be specified by
# -DMACRO#VALUE as well as -DMACRO=VALUE. It must be implemented by a
# simple search-and-replace.
#
# The Borland compiler will parse both # and \# as just # but the make
# tool seems to want \# sometimes and not others.
#
# Unix make does not like # in variable settings without extra
# escaping. This could probably be fixed but since MSVC does not
# support it and it is not an operator it is not worthwhile.
# Compose the final test string.
ENH: Support preprocessor def values in VS6 The add_definitions() command and COMPILE_DEFINITIONS dir/tgt/src properties support preprocessor definitions with values. Previously values were not supported in the VS6 generator even though the native tool supports them. It is only values with spaces that VS6 does not support. This enables support and instead complains only for values with spaces. See issue #8779.
2009-03-23 21:48:09 +03:00
set(STRING_VALUE "hello`~!@$*)(_+-=}{][:'.?/${STRING_EXTRA}world")
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
#-----------------------------------------------------------------------------
# Function-style macro command-line support:
# - Borland does not support
# - MSVC does not support
# - Watcom does not support
# - GCC supports
# Too few platforms support this to bother implementing.
# People can just configure headers with the macros.
#-----------------------------------------------------------------------------
# Construct a sample expression to pass as a macro definition.
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
set(EXPR "x*y+!(x==(y+1*2))*f(x${EXPR_OP1}2)")
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
if(NOT WATCOM)
# Watcom does not support - or / because it parses them as options.
ENH: Test spaces in non-string preprocessor values This extends the Preprocessor test to put spaces in the value of a definition that is not a quoted string. In particular this tests that VS6 supports values with spaces if they do not have '"', '$', or ';'. See issue #8779.
2009-04-24 19:21:09 +04:00
set(EXPR "${EXPR} + y/x-x")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
#-----------------------------------------------------------------------------
# Inform the test if the debug configuration is getting built.
# The NDEBUG definition takes care of this for release.
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DPREPROCESS_DEBUG")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DPREPROCESS_DEBUG")
# Inform the test if it built from Xcode or VS6 IDE.
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if(PP_XCODE)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
set(PREPROCESS_XCODE 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Update Preprocess test to distinguish between the make tool or compiler tool that is at fault for not supporting a particular character in definitions. Make it skip the % character when the compiler is MSVC and it is a non-nmake tool.
2008-03-01 17:08:59 +03:00
if(PP_VS6)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
set(PREPROCESS_VS6 1)
set(VS6 _vs6)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# Test old-style definitions.
add_definitions(-DOLD_DEF -DOLD_EXPR=2)
ENH: Converted cmMakefile DefineFlags added by ADD_DEFINITIONS command into a COMPILE_DEFINITIONS directory property.
2008-01-18 03:29:43 +03:00
# Make sure old-style definitions are converted to directory property.
ENH: Support preprocessor def values in VS6 The add_definitions() command and COMPILE_DEFINITIONS dir/tgt/src properties support preprocessor definitions with values. Previously values were not supported in the VS6 generator even though the native tool supports them. It is only values with spaces that VS6 does not support. This enables support and instead complains only for values with spaces. See issue #8779.
2009-03-23 21:48:09 +03:00
set(OLD_DEFS_EXPECTED "OLD_DEF;OLD_EXPR=2")
ENH: Converted cmMakefile DefineFlags added by ADD_DEFINITIONS command into a COMPILE_DEFINITIONS directory property.
2008-01-18 03:29:43 +03:00
get_property(OLD_DEFS DIRECTORY PROPERTY COMPILE_DEFINITIONS)
if(NOT "${OLD_DEFS}" STREQUAL "${OLD_DEFS_EXPECTED}")
message(SEND_ERROR "add_definitions not converted to directory property!")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Converted cmMakefile DefineFlags added by ADD_DEFINITIONS command into a COMPILE_DEFINITIONS directory property.
2008-01-18 03:29:43 +03:00
ENH: Use new set_property signature to set COMPILE_DEFINITIONS properties in Preprocess test.
2008-01-18 01:34:56 +03:00
add_executable(Preprocess preprocess.c preprocess${VS6}.cxx)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
set(FILE_PATH "${Preprocess_SOURCE_DIR}/file_def.h")
set(TARGET_PATH "${Preprocess_SOURCE_DIR}/target_def.h")
ENH: Use new set_property signature to set COMPILE_DEFINITIONS properties in Preprocess test.
2008-01-18 01:34:56 +03:00
# Set some definition properties.
foreach(c "" "_DEBUG" "_RELEASE")
ENH: Converted cmMakefile DefineFlags added by ADD_DEFINITIONS command into a COMPILE_DEFINITIONS directory property.
2008-01-18 03:29:43 +03:00
set_property(
DIRECTORY .
APPEND PROPERTY COMPILE_DEFINITIONS${c} "DIRECTORY_DEF${c}"
)
ENH: Use new set_property signature to set COMPILE_DEFINITIONS properties in Preprocess test.
2008-01-18 01:34:56 +03:00
set_property(
TARGET Preprocess
PROPERTY COMPILE_DEFINITIONS${c} "TARGET_DEF${c}"
)
set_property(
SOURCE preprocess.c preprocess${VS6}.cxx
PROPERTY COMPILE_DEFINITIONS${c} "FILE_DEF${c}"
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endforeach()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
ENH: Support preprocessor def values in VS6 The add_definitions() command and COMPILE_DEFINITIONS dir/tgt/src properties support preprocessor definitions with values. Previously values were not supported in the VS6 generator even though the native tool supports them. It is only values with spaces that VS6 does not support. This enables support and instead complains only for values with spaces. See issue #8779.
2009-03-23 21:48:09 +03:00
# Add definitions with values.
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
if(NOT PREPROCESS_VS6)
ENH: Support preprocessor def values in VS6 The add_definitions() command and COMPILE_DEFINITIONS dir/tgt/src properties support preprocessor definitions with values. Previously values were not supported in the VS6 generator even though the native tool supports them. It is only values with spaces that VS6 does not support. This enables support and instead complains only for values with spaces. See issue #8779.
2009-03-23 21:48:09 +03:00
# The path might have spaces, which VS6 does not support.
set(DEF_TARGET_PATH "TARGET_PATH=\"${TARGET_PATH}\"")
set(DEF_FILE_PATH "FILE_PATH=\"${FILE_PATH}\"")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Support preprocessor def values in VS6 The add_definitions() command and COMPILE_DEFINITIONS dir/tgt/src properties support preprocessor definitions with values. Previously values were not supported in the VS6 generator even though the native tool supports them. It is only values with spaces that VS6 does not support. This enables support and instead complains only for values with spaces. See issue #8779.
2009-03-23 21:48:09 +03:00
set_property(
TARGET Preprocess
APPEND PROPERTY COMPILE_DEFINITIONS
"TARGET_STRING=\"${STRING_VALUE}${SEMICOLON}\""
"TARGET_EXPR=${EXPR}"
${DEF_TARGET_PATH}
)
set_property(
SOURCE preprocess.c preprocess${VS6}.cxx
APPEND PROPERTY COMPILE_DEFINITIONS
"FILE_STRING=\"${STRING_VALUE}${SEMICOLON}\""
"FILE_EXPR=${EXPR}"
${DEF_FILE_PATH}
)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
Test COMPILE_DEFINITIONS target property get/set/get round-trip Teach the Preprocess test to get, set, and then get the same value for the COMPILE_DEFINITIONS target property and verify that the value is not changed. This ensures the internal structured storage of the property value can reproduce the original string value.
2013-07-24 21:25:11 +04:00
# Try reading and writing the property value to ensure the string is
# preserved.
get_property(defs1 TARGET Preprocess PROPERTY COMPILE_DEFINITIONS)
set_property(TARGET Preprocess PROPERTY COMPILE_DEFINITIONS "${defs1}")
get_property(defs2 TARGET Preprocess PROPERTY COMPILE_DEFINITIONS)
if(NOT "x${defs1}" STREQUAL "x${defs2}")
message(FATAL_ERROR "get/set/get COMPILE_DEFINITIONS round trip failed. "
"First get:\n"
" ${defs1}\n"
"Second get:\n"
" ${defs2}")
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
# Helper target for running test manually in build tree.
add_custom_target(drive COMMAND Preprocess)
# Configure the header file with the desired string value.
if(SEMICOLON)
set(STRING_VALUE "${STRING_VALUE};")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
configure_file(${Preprocess_SOURCE_DIR}/preprocess.h.in
${Preprocess_BINARY_DIR}/preprocess.h)
include_directories(${Preprocess_BINARY_DIR})