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

583 lines
15 KiB
CMake
Raw Normal View History

Convert CMake to OSI-approved BSD License This converts the CMake license to a pure 3-clause OSI-approved BSD License. We drop the previous license clause requiring modified versions to be plainly marked. We also update the CMake copyright to cover the full development time range.
2009-09-28 19:43:28 +04:00
#=============================================================================
# CMake - Cross Platform Makefile Generator
# Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
#
# 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.
#=============================================================================
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
include(CheckIncludeFile)
ENH: Add ELF file parsing - Enabled when system provides elf.h - Introduce cmELF class to parse ELF files - Use in cmSystemTools::GuessLibrarySOName to really get soname
2008-02-28 00:26:35 +03:00
# Check if we can build support for ELF parsing.
CHECK_INCLUDE_FILE("elf.h" HAVE_ELF_H)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(HAVE_ELF_H)
set(CMAKE_USE_ELF_PARSER 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
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_USE_ELF_PARSER)
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: Add ELF file parsing - Enabled when system provides elf.h - Introduce cmELF class to parse ELF files - Use in cmSystemTools::GuessLibrarySOName to really get soname
2008-02-28 00:26:35 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(EXECUTABLE_OUTPUT_PATH ${CMake_BIN_DIR})
Clean up CMake build tree 'bin' directory We re-arrange EXECUTABLE_OUTPUT_PATH settings to avoid putting utility and test executables in the 'bin' directory of the build tree. This makes the directory look like that in the installation tree, except that on multi-configuration generators we still use a per-config subdirectory.
2009-12-08 19:44:28 +03:00
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
# configure the .h file
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
ENH: More cleanups and start linking ctest to XML-RPC
2005-03-04 22:27:32 +03:00
"${CMake_SOURCE_DIR}/Source/cmConfigure.cmake.h.in"
"${CMake_BINARY_DIR}/Source/cmConfigure.h"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
ENH: Overhaul CMake version numbering This moves the version numbers into an isolated configured header so that not all of CMake needs to rebuild when the version changes. Previously we had spaces, dashes and/or the word 'patch' randomly chosen before the patch number. Now we always report version numbers in the traditional format "<major>.<minor>.<patch>[-rc<rc>]". We still use odd minor numbers for development versions. Now we also use the CCYYMMDD date as the patch number of development versions, thus allowing tests for exact CMake versions.
2009-03-05 23:17:07 +03:00
"${CMake_SOURCE_DIR}/Source/cmVersionConfig.h.in"
"${CMake_BINARY_DIR}/Source/cmVersionConfig.h"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
ENH: Merge from cpack branch
2006-01-02 07:31:17 +03:00
"${CMake_SOURCE_DIR}/Source/CPack/cmCPackConfigure.h.in"
"${CMake_BINARY_DIR}/Source/CPack/cmCPackConfigure.h"
)
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
ENH: Cleanup
2006-04-21 22:26:11 +04:00
# add the include path to find the .h
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
include_directories(
ENH: More cleanups and start linking ctest to XML-RPC
2005-03-04 22:27:32 +03:00
"${CMake_BINARY_DIR}/Source"
"${CMake_SOURCE_DIR}/Source"
ENH: Make sure to use internal zlib
2005-03-16 20:54:35 +03:00
${CMAKE_ZLIB_INCLUDES}
${CMAKE_EXPAT_INCLUDES}
COMP: Link tar library to cmake
2005-12-29 00:30:28 +03:00
${CMAKE_TAR_INCLUDES}
ENH: Implement TarCompress generator using compress library
2006-08-21 20:37:40 +04:00
${CMAKE_COMPRESS_INCLUDES}
ENH: More cleanups and start linking ctest to XML-RPC
2005-03-04 22:27:32 +03:00
)
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
# let cmake know it is supposed to use it
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_definitions(-DCMAKE_BUILD_WITH_CMAKE)
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
option(CMAKE_REGENERATE_YACCLEX
ENH: Use the new parser that supports nested variables
2005-06-13 19:00:29 +04:00
"Regenerate YACC and LEXX files" OFF)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
mark_as_advanced(CMAKE_REGENERATE_YACCLEX)
if(CMAKE_REGENERATE_YACCLEX)
set(parsersLexers cmDependsFortran cmCommandArgument cmExpr)
find_program(YACC_EXECUTABLE
ENH: Use the new parser that supports nested variables
2005-06-13 19:00:29 +04:00
NAMES yacc bison
PATHS /usr/bin
DOC "Yacc or Bison executable")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
find_program(FLEX_EXECUTABLE
ENH: Use the new parser that supports nested variables
2005-06-13 19:00:29 +04:00
NAMES flex
PATHS /usr/bin
DOC "Flex executable")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
mark_as_advanced(YACC_EXECUTABLE FLEX_EXECUTABLE)
if(YACC_EXECUTABLE)
set(BISON_FLAGS)
if(YACC_EXECUTABLE MATCHES "bison")
set(BISON_FLAGS "--yacc")
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()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(yacc_files)
foreach(name ${parsersLexers})
set(src "${CMAKE_CURRENT_SOURCE_DIR}/${name}Parser.y")
set(dst "${CMAKE_CURRENT_BINARY_DIR}/${name}Parser.cxx")
set(hdr "${CMAKE_CURRENT_BINARY_DIR}/${name}ParserTokens.h")
add_custom_command(
ENH: Use the new parser that supports nested variables
2005-06-13 19:00:29 +04:00
OUTPUT "${dst}"
DEPENDS "${src}"
ENH: Updated CMAKE_REGENERATE_YACCLEX option to support cmDependsFortran. Fixed to work with spaces in path.
2007-10-03 23:23:54 +04:00
COMMAND
${YACC_EXECUTABLE}
--name-prefix=${name}_yy --defines=${hdr} -o${dst} ${src}
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(yacc_files ${yacc_files} "${dst}")
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()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_custom_target(RerunYacc DEPENDS ${yacc_files})
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()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(FLEX_EXECUTABLE)
set(lex_files)
foreach(name ${parsersLexers})
set(src "${CMAKE_CURRENT_SOURCE_DIR}/${name}Lexer.in.l")
set(dst "${CMAKE_CURRENT_BINARY_DIR}/${name}Lexer.cxx")
set(hdr "${CMAKE_CURRENT_BINARY_DIR}/${name}Lexer.h")
add_custom_command(
ENH: Use the new parser that supports nested variables
2005-06-13 19:00:29 +04:00
OUTPUT "${dst}"
DEPENDS "${src}"
ENH: Updated CMAKE_REGENERATE_YACCLEX option to support cmDependsFortran. Fixed to work with spaces in path.
2007-10-03 23:23:54 +04:00
COMMAND
${FLEX_EXECUTABLE}
--prefix=${name}_yy --header-file=${hdr} -o${dst} ${src}
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(lex_files ${lex_files} "${dst}")
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()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_custom_target(RerunLex DEPENDS ${lex_files})
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: Use the new parser that supports nested variables
2005-06-13 19:00:29 +04:00
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: Add ELF file parsing - Enabled when system provides elf.h - Introduce cmELF class to parse ELF files - Use in cmSystemTools::GuessLibrarySOName to really get soname
2008-02-28 00:26:35 +03:00
# Check if we can build the ELF parser.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_USE_ELF_PARSER)
set(ELF_SRCS cmELF.h cmELF.cxx)
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: Add ELF file parsing - Enabled when system provides elf.h - Introduce cmELF class to parse ELF files - Use in cmSystemTools::GuessLibrarySOName to really get soname
2008-02-28 00:26:35 +03:00
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
#
# Sources for CMakeLib
#
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(SRCS
Tru64: Place cmOStringStream vtable uniquely (#10541) GCC places the vtable in the object implementing the first non-pure, non-inline virtual method. Since the symbol is not weak on Tru64, make the location unique by putting the destructor in a single object file.
2010-06-10 23:18:21 +04:00
cmStandardIncludes.cxx
Create class cmArchiveWrite to wrap libarchive (#11020)
2010-08-06 19:38:05 +04:00
cmArchiveWrite.cxx
ENH: Enable java dependency
2005-01-29 01:14:49 +03:00
cmBootstrapCommands.cxx
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmCacheManager.cxx
cmCacheManager.h
cmCommands.cxx
cmCommands.h
ENH: Use the new parser that supports nested variables
2005-06-13 19:00:29 +04:00
cmCommandArgumentLexer.cxx
cmCommandArgumentParser.cxx
cmCommandArgumentParserHelper.cxx
ENH: Improve link line generation for static library cycles. - Move Tarjan algorithm from cmComputeTargetDepends into its own class cmComputeComponentGraph - Use cmComputeComponentGraph to identify the component DAG of link dependencies in cmComputeLinkDepends - Emit non-trivial component members more than once but always in a contiguous group on the link line
2008-02-08 00:14:05 +03:00
cmComputeComponentGraph.cxx
cmComputeComponentGraph.h
ENH: Created cmComputeLinkDepends to compute link dependencies. - This will be useful for imported library dependencies - Replaces old cmTarget analyze-lib-depends stuff for linking - Formalizes graph construction and dump - Explicitly represents dependency inferral sets - Use BFS of initial dependencies to preserve order
2008-01-27 21:42:49 +03:00
cmComputeLinkDepends.cxx
cmComputeLinkDepends.h
ENH: Implement linking with paths to library files instead of -L and -l separation. See bug #3832 - This is purely an implementation improvement. No interface has changed. - Create cmComputeLinkInformation class - Move and re-implement logic from: cmLocalGenerator::ComputeLinkInformation cmOrderLinkDirectories - Link libraries to targets with their full path (if it is known) - Dirs specified with link_directories command still added with -L - Make link type specific to library names without paths (name libfoo.a without path becomes -Wl,-Bstatic -lfoo) - Make directory ordering specific to a runtime path computation feature (look for conflicting SONAMEs instead of library names) - Implement proper rpath support on HP-UX and AIX.
2008-01-22 17:13:04 +03:00
cmComputeLinkInformation.cxx
cmComputeLinkInformation.h
ENH: Analyze inter-target dependencies to safely fix cycles - Cycles may be formed among static libraries - Native build system should not have cycles in target deps - Create cmComputeTargetDepends to analyze dependencies - Identify conneced components and use them to fix deps - Diagnose cycles containing non-STATIC targets - Add debug mode property GLOBAL_DEPENDS_DEBUG_MODE - Use results in cmGlobalGenerator as target direct depends
2008-02-06 07:10:41 +03:00
cmComputeTargetDepends.h
cmComputeTargetDepends.cxx
Factor Compute(File|String)MD5 into cmCryptoHash helper Define an abstract API around the backend hash algorithm. Expose ifstream errors to HashFile callers. Always try opening the file. Succeed only if the end of file is reached without error.
2011-11-16 04:37:38 +04:00
cmCryptoHash.cxx
cmCryptoHash.h
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmCustomCommand.cxx
cmCustomCommand.h
Factor out common custom command generator The Makefile, VS, and Xcode generators previously duplicated some custom command line generation code. Factor this out into a separate class cmCustomCommandGenerator shared by all generators.
2010-12-08 00:23:38 +03:00
cmCustomCommandGenerator.cxx
cmCustomCommandGenerator.h
ENH: Improve dynamic variable scope implementation Previously each new variable scope (subdirectory or function call) in the CMake language created a complete copy of the key->value definition map. This avoids the copy using transitive lookups up the scope stack. Results of queries answered by parents are stored locally to maintain locality of reference. The class cmDefinitions replaces cmMakefile::DefinitionsMap, and is aware of its enclosing scope. Each scope stores only the definitions set (or unset!) inside it relative to the enclosing scope.
2009-07-22 22:22:45 +04:00
cmDefinitions.cxx
cmDefinitions.h
ENH: Enable java dependency
2005-01-29 01:14:49 +03:00
cmDepends.cxx
cmDepends.h
cmDependsC.cxx
cmDependsC.h
cmDependsFortran.cxx
cmDependsFortran.h
ENH: Changed over to using C++ for building flex/bison generated files. It reduces the number of changes that need to be made after generation.
2005-02-01 18:42:52 +03:00
cmDependsFortranLexer.cxx
cmDependsFortranParser.cxx
ENH: Enable java dependency
2005-01-29 01:14:49 +03:00
cmDependsFortranParser.h
ENH: Framework for java dependency scanner. Right now it does nothing but always reports success. This is enough to get the Java test to pass with the new generator because the old implementation did not do dependencies anyway.
2005-03-01 20:21:34 +03:00
cmDependsJava.cxx
cmDependsJava.h
ENH: Enable java dependency
2005-01-29 01:14:49 +03:00
cmDependsJavaLexer.cxx
cmDependsJavaParser.cxx
cmDependsJavaParserHelper.cxx
cmDependsJavaParserHelper.h
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmDocumentation.cxx
STYLE: move the code for the different formats of the generated help into their own classes, making cmDocumentation smaller and also making it easier to eventually add another format Alex
2007-09-19 17:05:28 +04:00
cmDocumentationFormatter.cxx
cmDocumentationFormatterHTML.cxx
ENH: add support for creating the documentation in docbook format (http://www.oasis-open.org/docbook/xml/4.2/), which users can then convert to other formats. Tested with meinproc from KDE, which generates HTML pages which look good. Alex
2008-02-19 22:33:43 +03:00
cmDocumentationFormatterDocbook.cxx
STYLE: move the code for the different formats of the generated help into their own classes, making cmDocumentation smaller and also making it easier to eventually add another format Alex
2007-09-19 17:05:28 +04:00
cmDocumentationFormatterMan.cxx
cmDocumentationFormatterText.cxx
cmDocumentationFormatterUsage.cxx
ENH: change to make the documentation class more generic, about halfway there, also provides secitons for Variables now
2007-10-22 20:49:09 +04:00
cmDocumentationSection.cxx
Combine duplicate COMPILE_DEFINITIONS disclaimer
2011-01-17 15:55:48 +03:00
cmDocumentCompileDefinitions.h
Factor generator expression docs out of add_test This documentation may be reused wherever generator expressions are supported.
2010-12-07 01:11:36 +03:00
cmDocumentGeneratorExpressions.h
Factor out target location undefined behavior helper macro Move CM_LOCATION_UNDEFINED_BEHAVIOR into a dedicated header. Add a parameter to describe the action that leads to the undefined target location.
2011-12-02 00:41:01 +04:00
cmDocumentLocationUndefined.h
ENH: add docs for variables
2007-10-18 17:10:42 +04:00
cmDocumentVariables.cxx
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmDynamicLoader.cxx
cmDynamicLoader.h
ENH: Add ELF file parsing - Enabled when system provides elf.h - Introduce cmELF class to parse ELF files - Use in cmSystemTools::GuessLibrarySOName to really get soname
2008-02-28 00:26:35 +03:00
${ELF_SRCS}
ENH: Add rudamentary mathematical expression support
2005-10-18 00:42:47 +04:00
cmExprLexer.cxx
cmExprParser.cxx
cmExprParserHelper.cxx
ENH: Updated exporting and importing of targets to support libraries and configurations. - Created cmExportFileGenerator hierarchy to implement export file generation - Installed exports use per-config import files loaded by a central one. - Include soname of shared libraries in import information - Renamed PREFIX to NAMESPACE in INSTALL(EXPORT) and EXPORT() commands - Move addition of CMAKE_INSTALL_PREFIX to destinations to install generators - Import files compute the installation prefix relative to their location when loaded - Add mapping of importer configurations to importee configurations - Rename IMPORT targets to IMPORTED targets to distinguish from windows import libraries - Scope IMPORTED targets within directories to isolate them - Place all properties created by import files in the IMPORTED namespace - Document INSTALL(EXPORT) and EXPORT() commands. - Document IMPORTED signature of add_executable and add_library - Enable finding of imported targets in cmComputeLinkDepends
2008-01-28 16:38:36 +03:00
cmExportBuildFileGenerator.h
cmExportBuildFileGenerator.cxx
cmExportFileGenerator.h
cmExportFileGenerator.cxx
cmExportInstallFileGenerator.h
cmExportInstallFileGenerator.cxx
Add a new Export generator for IMPORTED targets. This is to be used during try_compile using LINK_LIBRARIES in the srcfile signature and, in the future, TARGETS in the binary dir signature.
2013-02-07 20:36:29 +04:00
cmExportTryCompileFileGenerator.h
cmExportTryCompileFileGenerator.cxx
exports: Create class cmExportSet Replace direct use of 'std::vector<cmTargetExport const*>' with a dedicated class.
2012-02-27 10:09:40 +04:00
cmExportSet.h
cmExportSet.cxx
exports: Add cmExportSetMap class This is a map<string, cmExportSet *> with overloaded operator[] and destructor.
2012-03-01 02:02:56 +04:00
cmExportSetMap.h
cmExportSetMap.cxx
Enable extra CodeBlocks generator on Cygwin This generator builds correctly on Cygwin so it should be enabled. Change based on patch from issue #10122.
2010-01-13 20:58:08 +03:00
cmExtraCodeBlocksGenerator.cxx
cmExtraCodeBlocksGenerator.h
ENH: add Eclipse CDT4 generator, patch from Miguel A. Figueroa-Villanueva Alex
2007-08-01 17:18:50 +04:00
cmExtraEclipseCDT4Generator.cxx
cmExtraEclipseCDT4Generator.h
Added a generator for Sublime Text 2 project files. The generator adds all list and source files for each defined project. The generated project files also include build_system entries that run the platform-specific make on the generated Makefiles. A build_system entry is created for each target that was defined in the CMakeLists.txt files. At the moment this has only been tested with C/C++ projects.
2012-10-11 02:01:48 +04:00
cmExtraSublimeTextGenerator.cxx
cmExtraSublimeTextGenerator.h
ENH: added properties into the compile
2006-12-04 19:05:23 +03:00
cmFileTimeComparison.cxx
cmFileTimeComparison.h
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmGeneratedFileStream.cxx
Add API to check that dependent target properties form a DAG. Initially this will only be used to check for self-references, but can be extended to check for cycles when chaining properties of other targets.
2012-09-18 15:42:23 +04:00
cmGeneratorExpressionDAGChecker.cxx
cmGeneratorExpressionDAGChecker.h
cmGeneratorExpression: Re-write for multi-stage evaluation The expressions may be parsed and then cached and evaluated multiple times. They are evaluated lazily so that literals such as ',' can be treated as universal parameter separators, and can be processed from results without appearing literally, and without interfering with the parsing/evaluation of the entire expression.
2012-09-11 21:53:38 +04:00
cmGeneratorExpressionEvaluator.cxx
cmGeneratorExpressionEvaluator.h
cmGeneratorExpressionLexer.cxx
cmGeneratorExpressionLexer.h
cmGeneratorExpressionParser.cxx
cmGeneratorExpressionParser.h
Introduce "generator expressions" to add_test() This introduces a new syntax called "generator expressions" to the test COMMAND option of the add_test(NAME) command mode. These expressions have a syntax like $<TARGET_FILE:mytarget> and are evaluated during build system generation. This syntax allows per-configuration target output files to be referenced in test commands and arguments.
2009-08-11 17:54:56 +04:00
cmGeneratorExpression.cxx
cmGeneratorExpression.h
Add cmGeneratorTarget to represent a target during generation Some per-target information and logic is common to all generators. Some of that information is currently stored in cmTarget but that should be reserved for the configure step. Create a class to hold per-target information for generators. On construction classify sources from the target and store them in separate members. This classification is already implemented separately in each generator.
2012-03-07 20:44:48 +04:00
cmGeneratorTarget.cxx
cmGeneratorTarget.h
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmGlobalGenerator.cxx
cmGlobalGenerator.h
Introduce the abstract class cmGlobalGeneratorFactory This new abstract class allows us move some logic from the cmGlobalGenerator into its own layer in a next step.
2012-11-19 18:48:33 +04:00
cmGlobalGeneratorFactory.h
ENH: added new generator
2005-05-12 18:49:56 +04:00
cmGlobalUnixMakefileGenerator3.cxx
cmGlobalUnixMakefileGenerator3.h
ENH: Improve link line generation for static library cycles. - Move Tarjan algorithm from cmComputeTargetDepends into its own class cmComputeComponentGraph - Use cmComputeComponentGraph to identify the component DAG of link dependencies in cmComputeLinkDepends - Emit non-trivial component members more than once but always in a contiguous group on the link line
2008-02-08 00:14:05 +03:00
cmGraphAdjacencyList.h
Move the code for generating dot-files into separate class cmGraphVizWriter Alex
2010-11-09 23:37:51 +03:00
cmGraphVizWriter.cxx
cmGraphVizWriter.h
ENH: Created new install script generation framework. The INSTALL command creates the generators which are later used by cmLocalGenerator to create the cmake_install.cmake files. A new target installation interface is provided by the INSTALL command which fixes several problems with the INSTALL_TARGETS command. See bug#2691. Bugs 1481 and 1695 are addressed by these changes.
2006-02-19 23:25:27 +03:00
cmInstallGenerator.h
cmInstallGenerator.cxx
ENH: add INSTALL(EXPORT ...) mode and INSTALL( TARGETS ... EXPORT <set> ) , tests still have to be added Alex
2007-06-19 21:10:21 +04:00
cmInstallExportGenerator.cxx
ENH: Implemented FILES and PROGRAMS forms of the INSTALL command as replacements for the INSTALL_FILES and INSTALL_PROGRAMS commands. This addresses the request for absolute path install destinations in bug#2691.
2006-02-20 02:47:13 +03:00
cmInstallFilesGenerator.h
cmInstallFilesGenerator.cxx
ENH: Created new install script generation framework. The INSTALL command creates the generators which are later used by cmLocalGenerator to create the cmake_install.cmake files. A new target installation interface is provided by the INSTALL command which fixes several problems with the INSTALL_TARGETS command. See bug#2691. Bugs 1481 and 1695 are addressed by these changes.
2006-02-19 23:25:27 +03:00
cmInstallScriptGenerator.h
cmInstallScriptGenerator.cxx
cmInstallTargetGenerator.h
cmInstallTargetGenerator.cxx
ENH: Started implementing INSTALL(DIRECTORY) command mode. This is not yet finished so it is undocumented and there is no test. These changes also separate the notions of file and directory permissions.
2006-08-17 22:48:54 +04:00
cmInstallDirectoryGenerator.h
cmInstallDirectoryGenerator.cxx
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmListFileCache.cxx
cmListFileCache.h
cmListFileLexer.c
cmLocalGenerator.cxx
cmLocalGenerator.h
ENH: added new generator
2005-05-12 18:49:56 +04:00
cmLocalUnixMakefileGenerator3.cxx
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmMakeDepend.cxx
cmMakeDepend.h
cmMakefile.cxx
cmMakefile.h
ENH: some reorg of the unix makefile generator
2006-02-15 18:34:11 +03:00
cmMakefileTargetGenerator.cxx
cmMakefileExecutableTargetGenerator.cxx
cmMakefileLibraryTargetGenerator.cxx
cmMakefileUtilityTargetGenerator.cxx
Re-factor OS X bundle and framework generation.
2012-07-07 21:54:16 +04:00
cmOSXBundleGenerator.cxx
cmOSXBundleGenerator.h
Add NEWLINE_STYLE option to configure_file (#3957)
2011-11-20 17:04:11 +04:00
cmNewLineStyle.h
cmNewLineStyle.cxx
ENH: Better linker search path computation. - Use linker search path -L.. -lfoo for lib w/out soname when platform sets CMAKE_PLATFORM_USES_PATH_WHEN_NO_SONAME - Rename cmOrderRuntimeDirectories to cmOrderDirectories and generalize it for both soname constraints and link library constraints - Use cmOrderDirectories to order -L directories based on all needed constraints - Avoid processing implicit link directories - For CMAKE_OLD_LINK_PATHS add constraints from libs producing them to produce old ordering
2008-02-21 19:41:11 +03:00
cmOrderDirectories.cxx
cmOrderDirectories.h
ENH: add first cut and policies still need to add the doc support
2008-03-01 23:20:35 +03:00
cmPolicies.h
cmPolicies.cxx
ENH: Create cmProcessTools to parse child output This class provides a RunProcess method to run a child process and send its output to an abstract parsing interface. This also provides a simple line parser and logger implementing the parsing interface.
2009-02-24 18:40:18 +03:00
cmProcessTools.cxx
cmProcessTools.h
ENH: added properties into the compile
2006-12-04 19:05:23 +03:00
cmProperty.cxx
cmProperty.h
cmPropertyDefinition.cxx
cmPropertyDefinition.h
ENH: make properties a bit more formal with documentation and chaining
2006-12-07 17:45:32 +03:00
cmPropertyDefinitionMap.cxx
cmPropertyDefinitionMap.h
cmPropertyMap.cxx
cmPropertyMap.h
Start work on automoc: add empty cmQtAutomoc class Alex
2011-08-07 14:02:46 +04:00
cmQtAutomoc.cxx
cmQtAutomoc.h
ENH: Refactor cmInstallGenerator for re-use A new cmScriptGenerator base class factors out the non-install-specific part of cmInstallGenerator. This will be useful for other generators that want per-configuration functionality.
2009-03-16 17:39:56 +03:00
cmScriptGenerator.h
cmScriptGenerator.cxx
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmSourceFile.cxx
cmSourceFile.h
ENH: Merging changes from branch CMake-SourceFile2-b between tags CMake-SourceFile2-bp and CMake-SourceFile2-b-mp1 to trunk. This commit is surrounded by tags CMake-SourceFile2-b-mp1-pre and CMake-SourceFile2-b-mp1-post on the trunk. The changes re-implement cmSourceFile and the use of it to allow instances to be created much earlier. The use of cmSourceFileLocation allows locating a source file referenced by a user to be much simpler and more robust. The two SetName methods are no longer needed so some duplicate code has been removed. The strange "SourceName" stuff is gone. Code that created cmSourceFile instances on the stack and then sent them to cmMakefile::AddSource has been simplified and converted to getting cmSourceFile instances from cmMakefile. The CPluginAPI has preserved the old API through a compatibility interface. Source lists are gone. Targets now get real instances of cmSourceFile right away instead of storing a list of strings until the final pass. TraceVSDependencies has been re-written to avoid the use of SourceName. It is now called TraceDependencies since it is not just for VS. It is now implemented with a helper object which makes the code simpler.
2007-06-18 19:59:23 +04:00
cmSourceFileLocation.cxx
cmSourceFileLocation.h
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmSourceGroup.cxx
cmSourceGroup.h
cmSystemTools.cxx
cmSystemTools.h
cmTarget.cxx
cmTarget.h
exports: Move cmTargetExport to a dedicated header file
2012-02-27 00:05:17 +04:00
cmTargetExport.h
ENH: Improve internal test handling by creating a test class. Command cmEnableTesting now only sets CMAKE_TESTING_ENABLED and cmAddTest only adds a test to the list. The actual test files are written by local generator. This way we can at some point in the future replace DartTestfile with some XML file
2005-04-24 23:59:51 +04:00
cmTest.cxx
cmTest.h
ENH: Refactor generation of CTestTestfile content This moves code which generates ADD_TEST and SET_TESTS_PROPERTIES calls into CTestTestfile.cmake files out of cmLocalGenerator and into a cmTestGenerator class. This will allow more advanced generation without cluttering cmLocalGenerator. The cmTestGenerator class derives from cmScriptGenerator to get support for per-configuration script generation (not yet enabled).
2009-03-16 17:40:46 +03:00
cmTestGenerator.cxx
cmTestGenerator.h
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmVariableWatch.cxx
cmVariableWatch.h
cmVersion.cxx
cmVersion.h
cmXMLParser.cxx
cmXMLParser.h
ENH: Create cmXMLSafe to help escapes in XML This class provides easy syntax to efficiently insert blocks of data into XML documents with proper escapes. It replaces the old cmCTest::MakeXMLSafe and cmSystemTools::MakeXMLSafe methods which allocated extra memory instead of directly streaming the data.
2009-02-06 00:31:37 +03:00
cmXMLSafe.cxx
cmXMLSafe.h
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
cmake.cxx
cmake.h
cmakewizard.cxx
cmakewizard.h
CTest: Do not munge UTF-8 output in XML files CTest filters the output from tools and tests to ensure that the XML build/test result documents it generates have valid characters. Previously we just converted all non-ASCII bytes into XML-escaped Unicode characters of the corresponding index. This does not preserve tool output encoded in UTF-8. We now assume UTF-8 output from tools and implement decoding as specified in RFC 3629. Valid characters are preserved, possibly with XML escaping. Invalid byte sequences and characters are converted to human-readable hex values with distinguishing tags. See issue #10003.
2009-12-08 23:43:55 +03:00
sha2: Build as part of CMakeLib Mangle sha2 symbols to avoid conflict with system libs.
2011-11-16 05:22:51 +04:00
cm_sha2.h
cm_sha2.c
CTest: Do not munge UTF-8 output in XML files CTest filters the output from tools and tests to ensure that the XML build/test result documents it generates have valid characters. Previously we just converted all non-ASCII bytes into XML-escaped Unicode characters of the corresponding index. This does not preserve tool output encoded in UTF-8. We now assume UTF-8 output from tools and implement decoding as specified in RFC 3629. Valid characters are preserved, possibly with XML escaping. Invalid byte sequences and characters are converted to human-readable hex values with distinguishing tags. See issue #10003.
2009-12-08 23:43:55 +03:00
cm_utf8.h
cm_utf8.c
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
)
support testing
2001-06-12 21:30:13 +04:00
NEW: add kdevelop patch from Alexander Neundorf
2004-10-11 19:32:14 +04:00
# Kdevelop only works on UNIX and not windows
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(UNIX)
set(SRCS ${SRCS} cmGlobalKdevelopGenerator.cxx)
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: build codeblocks generator also on Windows Alex
2007-07-18 18:19:33 +04:00
Fix XCode -> Xcode typos, notably in man page (#12231)
2011-05-28 02:12:14 +04:00
# Xcode only works on Apple
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(APPLE)
set(SRCS ${SRCS}
ENH: make xcode compile only on apple
2005-03-14 21:23:14 +03:00
cmXCodeObject.cxx
ENH: add real support for Xcode21
2005-09-03 00:29:32 +04:00
cmXCode21Object.cxx
ENH: make xcode compile only on apple
2005-03-14 21:23:14 +03:00
cmGlobalXCodeGenerator.cxx
ENH: if Xcode21 is installed then create 21 compatible project files
2005-07-20 00:40:44 +04:00
cmGlobalXCodeGenerator.h
ENH: make xcode compile only on apple
2005-03-14 21:23:14 +03:00
cmLocalXCodeGenerator.cxx
cmLocalXCodeGenerator.h)
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()
NEW: add kdevelop patch from Alexander Neundorf
2004-10-11 19:32:14 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if (WIN32)
set(SRCS ${SRCS}
ENH: Add ability to call Visual Studio macros from CMake. Add a CMake Visual Studio macro to reload a solution file automatically if CMake makes changes to .sln files or .vcproj files. Add code to call the macro automatically for any running Visual Studio instances with the .sln file open at the end of the Visual Studio Generate call. Only call the macro if some .sln or .vcproj file changed during Generate. Also, add handling for REG_EXPAND_SZ type to SystemTools::ReadRegistryValue - returned string has environment variable references expanded.
2007-11-16 15:01:58 +03:00
cmCallVisualStudioMacro.cxx
cmCallVisualStudioMacro.h
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(NOT UNIX)
set(SRCS ${SRCS}
ENH: add the unix makefile generator as an option from the windows GUI, this builds with mingw, cygwin, and combinations of make cl, bcc32
2003-08-22 00:22:23 +04:00
cmGlobalBorlandMakefileGenerator.cxx
ENH: Enabled build of VS 7 and 8 generators for MinGW.
2006-02-01 03:34:57 +03:00
cmGlobalBorlandMakefileGenerator.h
ENH: fix borland make clean targets before build, add new generators for msys and mingw
2005-12-23 00:42:36 +03:00
cmGlobalMSYSMakefileGenerator.cxx
cmGlobalMinGWMakefileGenerator.cxx
ENH: Enabled build of VS 7 and 8 generators for MinGW.
2006-02-01 03:34:57 +03:00
cmGlobalNMakeMakefileGenerator.cxx
ENH: add the unix makefile generator as an option from the windows GUI, this builds with mingw, cygwin, and combinations of make cl, bcc32
2003-08-22 00:22:23 +04:00
cmGlobalNMakeMakefileGenerator.h
Add JOM support and clean up some of the tar -E stuff
2009-11-05 23:00:15 +03:00
cmGlobalJOMMakefileGenerator.cxx
cmGlobalJOMMakefileGenerator.h
ENH: Enabled build of VS 7 and 8 generators for MinGW.
2006-02-01 03:34:57 +03:00
cmGlobalVisualStudio6Generator.cxx
ENH: add the unix makefile generator as an option from the windows GUI, this builds with mingw, cygwin, and combinations of make cl, bcc32
2003-08-22 00:22:23 +04:00
cmGlobalVisualStudio6Generator.h
ENH: Enabled build of VS 7 and 8 generators for MinGW.
2006-02-01 03:34:57 +03:00
cmGlobalVisualStudio71Generator.cxx
cmGlobalVisualStudio71Generator.h
cmGlobalVisualStudio7Generator.cxx
cmGlobalVisualStudio7Generator.h
cmGlobalVisualStudio8Generator.cxx
cmGlobalVisualStudio8Generator.h
ENH: add support for vs 2008 beta 2
2007-09-17 23:21:47 +04:00
cmGlobalVisualStudio9Generator.cxx
cmGlobalVisualStudio9Generator.h
ENH: first pass at VS 10, can bootstrap CMake, but many tests still fail
2009-06-26 00:41:57 +04:00
cmVisualStudioGeneratorOptions.h
cmVisualStudioGeneratorOptions.cxx
cmVisualStudio10TargetGenerator.h
cmVisualStudio10TargetGenerator.cxx
cmLocalVisualStudio10Generator.cxx
cmLocalVisualStudio10Generator.h
cmGlobalVisualStudio10Generator.h
cmGlobalVisualStudio10Generator.cxx
Add Visual Studio 11 generator for x86 and x64 tools
2011-09-23 17:07:40 +04:00
cmGlobalVisualStudio11Generator.h
cmGlobalVisualStudio11Generator.cxx
ENH: Added cmGlobalVisualStudioGenerator as superclass to all VS global generators.
2007-04-04 19:22:14 +04:00
cmGlobalVisualStudioGenerator.cxx
cmGlobalVisualStudioGenerator.h
ENH: Enabled build of VS 7 and 8 generators for MinGW.
2006-02-01 03:34:57 +03:00
cmGlobalWatcomWMakeGenerator.cxx
ENH: Separate VS flag table type Move the cmVS7FlagTable type out of the VS generators and rename it to cmIDEFlagTable. It will be useful for other generators.
2009-07-29 19:28:55 +04:00
cmIDEFlagTable.h
ENH: Separate option mapping from VS generators Split cmVisualStudioGeneratorOptions core functionality out into a base class cmIDEOptions. It will be useful for other generators.
2009-07-29 19:29:08 +04:00
cmIDEOptions.cxx
cmIDEOptions.h
ENH: Enabled build of VS 7 and 8 generators for MinGW.
2006-02-01 03:34:57 +03:00
cmLocalVisualStudio6Generator.cxx
ENH: add the unix makefile generator as an option from the windows GUI, this builds with mingw, cygwin, and combinations of make cl, bcc32
2003-08-22 00:22:23 +04:00
cmLocalVisualStudio6Generator.h
ENH: Enabled build of VS 7 and 8 generators for MinGW.
2006-02-01 03:34:57 +03:00
cmLocalVisualStudio7Generator.cxx
cmLocalVisualStudio7Generator.h
ENH: Moved unique object file name computation from cmLocalUnixMakefileGenerator3 up to cmLocalGenerator for use by all generators. Created cmLocalVisualStudioGenerator as superclass for all VS generators. Implemented on-demand unique object file name computation for VS 7 generator to avoid slow compiles when all sources are in subdirectories.
2006-07-11 19:41:38 +04:00
cmLocalVisualStudioGenerator.cxx
cmLocalVisualStudioGenerator.h
VS: Create parser for Visual Studio .sln files Create class cmVisualStudioSlnParser as a generic parser for Visual Studio .sln files. Implement minimum functionality but keep class extensible. Add tests for the class.
2013-01-08 17:10:42 +04:00
cmVisualStudioSlnData.h
cmVisualStudioSlnData.cxx
cmVisualStudioSlnParser.h
cmVisualStudioSlnParser.cxx
VS: Add parser for WCE.VCPlatform.config to read WinCE platforms Parse the WCE.VCPlatform.config file, which contains the installed WindowsCE SDKs in XML format, and add possibility to generate Visual Studio generators for them.
2012-11-20 16:12:27 +04:00
cmVisualStudioWCEPlatformParser.h
cmVisualStudioWCEPlatformParser.cxx
ENH: add the unix makefile generator as an option from the windows GUI, this builds with mingw, cygwin, and combinations of make cl, bcc32
2003-08-22 00:22:23 +04:00
cmWin32ProcessExecution.cxx
cmWin32ProcessExecution.h
)
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 ()
support testing
2001-06-12 21:30:13 +04:00
Ninja: enable ninja support everywhere
2012-07-20 12:53:34 +04:00
# Ninja support
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(SRCS ${SRCS}
Ninja: enable ninja support everywhere
2012-07-20 12:53:34 +04:00
cmGlobalNinjaGenerator.cxx
cmGlobalNinjaGenerator.h
cmNinjaTypes.h
cmLocalNinjaGenerator.cxx
cmLocalNinjaGenerator.h
cmNinjaTargetGenerator.cxx
cmNinjaTargetGenerator.h
cmNinjaNormalTargetGenerator.cxx
cmNinjaNormalTargetGenerator.h
cmNinjaUtilityTargetGenerator.cxx
cmNinjaUtilityTargetGenerator.h
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(WIN32 AND NOT CYGWIN AND NOT BORLAND)
set_source_files_properties(cmcldeps.cxx PROPERTIES COMPILE_DEFINITIONS _WIN32_WINNT=0x0501)
add_executable(cmcldeps cmcldeps.cxx)
target_link_libraries(cmcldeps CMakeLib)
install_targets(/bin cmcldeps)
endif()
Ninja: Add the Ninja generator
2011-11-11 09:00:49 +04:00
ENH: add bootstrap support for building fltk
2001-06-19 23:33:37 +04:00
# create a library used by the command line and the GUI
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_library(CMakeLib ${SRCS})
target_link_libraries(CMakeLib cmsys
ENH: Implement TarCompress generator using compress library
2006-08-21 20:37:40 +04:00
${CMAKE_EXPAT_LIBRARIES} ${CMAKE_ZLIB_LIBRARIES}
ENH: add DOWNLOAD option to FILE command
2008-02-06 17:35:02 +03:00
${CMAKE_TAR_LIBRARIES} ${CMAKE_COMPRESS_LIBRARIES}
Switch to using libarchive from libtar for cpack and cmake -E tar This allows for a built in bzip and zip capability, so external tools will not be needed for these packagers. The cmake -E tar xf should be able to handle all compression types now as well.
2009-10-30 20:10:56 +03:00
${CMAKE_CURL_LIBRARIES} )
ENH: Enabled build of VS 7 and 8 generators for MinGW.
2006-02-01 03:34:57 +03:00
Removed most usage of Carbon in favour of CoreFoundation
2010-08-18 00:11:33 +04:00
# On Apple we need CoreFoundation
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(APPLE)
target_link_libraries(CMakeLib "-framework CoreFoundation")
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: add patch for finding applications on OSX
2006-04-13 19:00:52 +04:00
ENH: Enabled build of VS 7 and 8 generators for MinGW.
2006-02-01 03:34:57 +03:00
# On some platforms we need the rpcrt4 library for the VS 7 generators.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_BUILD_ON_VISUAL_STUDIO OR MINGW)
target_link_libraries(CMakeLib rpcrt4)
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: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
#
# CTestLib
#
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
include_directories(
Refer to self with CMake_(SOURCE|BINARY)_DIR (#10046) This is good practice, and is necessary to support building CMake as a subdirectory of another project.
2010-07-29 18:59:27 +04:00
"${CMake_SOURCE_DIR}/Source/CTest"
ENH: More cleanups and start linking ctest to XML-RPC
2005-03-04 22:27:32 +03:00
${CMAKE_XMLRPC_INCLUDES}
ENH: Move curl to utilities
2005-06-24 17:06:26 +04:00
${CMAKE_CURL_INCLUDES}
ENH: More cleanups and start linking ctest to XML-RPC
2005-03-04 22:27:32 +03:00
)
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
#
# Sources for CTestLib
#
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CTEST_SRCS cmCTest.cxx
ENH: add initial ctest -j feature
2008-07-03 17:31:33 +04:00
CTest/cmProcess.cxx
BUG: Fixed segfault and bad reporting if a ctest executable could not be found. Also added some batch testing code that is not yet complete.
2009-09-10 19:16:08 +04:00
CTest/cmCTestBatchTestHandler.cxx
ENH: Add commands for memory checking and coverage
2005-06-14 22:00:45 +04:00
CTest/cmCTestBuildAndTestHandler.cxx
ENH: More commands. Start working on new style ctest configuration
2005-05-02 22:15:29 +04:00
CTest/cmCTestBuildCommand.cxx
more cleanup
2004-09-07 18:37:39 +04:00
CTest/cmCTestBuildHandler.cxx
ENH: More commands. Start working on new style ctest configuration
2005-05-02 22:15:29 +04:00
CTest/cmCTestConfigureCommand.cxx
more cleanup of ctest
2004-09-09 16:41:05 +04:00
CTest/cmCTestConfigureHandler.cxx
ENH: Add commands for memory checking and coverage
2005-06-14 22:00:45 +04:00
CTest/cmCTestCoverageCommand.cxx
more cleanup of ctest
2004-09-09 16:41:05 +04:00
CTest/cmCTestCoverageHandler.cxx
Add test for mumps coverage. Also refactor code to prepare for cache coverage. Add a simple test to make sure the GTM mumps coverage is working. Also refactor the code so that cache coverage can be added.
2012-05-01 21:35:07 +04:00
CTest/cmParseMumpsCoverage.cxx
Add support for Cache coverage. This adds support for Cache coverage parsing. A test is added that does a basic run of the coverage on a small bit of data.
2012-05-02 01:00:43 +04:00
CTest/cmParseCacheCoverage.cxx
Add support to ctest for GTM mumps coverage.
2012-04-26 01:04:28 +04:00
CTest/cmParseGTMCoverage.cxx
Add php coverage to ctest.
2010-05-25 17:23:25 +04:00
CTest/cmParsePHPCoverage.cxx
ENH: added more capabilities to ctest
2005-01-27 18:11:04 +03:00
CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
ENH: More commands. Start working on new style ctest configuration
2005-05-02 22:15:29 +04:00
CTest/cmCTestGenericHandler.cxx
ENH: Several improvements with the way things are handled. Also, support multiple submited files
2005-06-23 21:04:18 +04:00
CTest/cmCTestHandlerCommand.cxx
ENH: Create internal 'ctest --launch' tool This creates an undocumented 'ctest --launch' mode. It launches a specified command and optionally records a failure in an xml fragment. We will optionally use this in CTest's Build stage to record per-rule build failure information when using Makefile generators.
2009-02-11 19:31:25 +03:00
CTest/cmCTestLaunch.cxx
ENH: Add commands for memory checking and coverage
2005-06-14 22:00:45 +04:00
CTest/cmCTestMemCheckCommand.cxx
ENH: More commands. Start working on new style ctest configuration
2005-05-02 22:15:29 +04:00
CTest/cmCTestMemCheckHandler.cxx
ENH: add initial ctest -j feature
2008-07-03 17:31:33 +04:00
CTest/cmCTestMultiProcessHandler.cxx
ENH: Add new ctest command
2006-03-29 00:20:03 +04:00
CTest/cmCTestReadCustomFilesCommand.cxx
ENH: added more capabilities to ctest
2005-01-27 18:11:04 +03:00
CTest/cmCTestRunScriptCommand.cxx
ENH: Refactored CTest test execution code into an object
2009-08-19 16:58:36 +04:00
CTest/cmCTestRunTest.cxx
ENH: More commands. Start working on new style ctest configuration
2005-05-02 22:15:29 +04:00
CTest/cmCTestScriptHandler.cxx
ENH: added more capabilities to ctest
2005-01-27 18:11:04 +03:00
CTest/cmCTestSleepCommand.cxx
ENH: Cleanups and add CTEST_START command
2005-02-17 18:51:52 +03:00
CTest/cmCTestStartCommand.cxx
ENH: Promote submit into a full handler, add test and submit command and do some cleanups
2005-05-03 16:17:39 +04:00
CTest/cmCTestSubmitCommand.cxx
CTest/cmCTestSubmitHandler.cxx
CTest/cmCTestTestCommand.cxx
ENH: More commands. Start working on new style ctest configuration
2005-05-02 22:15:29 +04:00
CTest/cmCTestTestHandler.cxx
CTest/cmCTestUpdateCommand.cxx
CTest/cmCTestUpdateHandler.cxx
Implement ctest_upload command
2011-02-18 20:11:51 +03:00
CTest/cmCTestUploadCommand.cxx
CTest/cmCTestUploadHandler.cxx
ENH: Create cmCTestVC for VCS interaction This creates cmCTestVC, the base for a forthcoming class hierarchy to interact with version control systems.
2009-02-24 18:39:28 +03:00
CTest/cmCTestVC.cxx
CTest/cmCTestVC.h
ENH: Factor global-VC parts out of cmCTestSVN This factors parts of the svn update implementation that are useful for any globally-versioning vcs tool into cmCTestGlobalVC. It will allow the code to be shared among the support classes for most vcs tools.
2009-04-22 17:18:19 +04:00
CTest/cmCTestGlobalVC.cxx
CTest/cmCTestGlobalVC.h
ENH: Add cmCTestCVS and cmCTestSVN These cmCTestVC subclasses will implement interaction with CVS and SVN tools.
2009-02-24 18:39:55 +03:00
CTest/cmCTestCVS.cxx
CTest/cmCTestCVS.h
CTest/cmCTestSVN.cxx
CTest/cmCTestSVN.h
ENH: Teach CTest to handle Bazaar repositories This creates cmCTestBZR to drive CTest Update handling on bzr-based work trees. Currently we always update to the head of the remote tracking branch (bzr pull), so the nightly start time is ignored for Nightly builds. A later change will address this. Patch from Tom Vercauteren. See issue #6857.
2009-05-15 00:13:52 +04:00
CTest/cmCTestBZR.cxx
CTest/cmCTestBZR.h
ENH: Teach CTest to handle git repositories This creates cmCTestGIT to drive CTest Update handling on git-based work trees. Currently we always update to the head of the remote tracking branch (git pull), so the nightly start time is ignored for Nightly builds. A later change will address this. See issue #6994.
2009-04-22 17:19:06 +04:00
CTest/cmCTestGIT.cxx
CTest/cmCTestGIT.h
ENH: Teach CTest to handle Mercurial repositories This creates cmCTestHG to drive CTest Update handling on hg-based work trees. Currently we always update to the head of the remote tracking branch (hg pull), so the nightly start time is ignored for Nightly builds. A later change will address this. See issue #7879. Patch from Emmanuel Christophe. I modified the patch slightly for code style, to finish up some parsing details, and to fix the test.
2009-07-10 19:08:05 +04:00
CTest/cmCTestHG.cxx
CTest/cmCTestHG.h
ENH: Add XML parser
2005-01-18 21:41:23 +03:00
)
oops
2004-09-06 21:37:34 +04:00
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
# Build CTestLib
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_library(CTestLib ${CTEST_SRCS})
target_link_libraries(CTestLib CMakeLib ${CMAKE_CURL_LIBRARIES} ${CMAKE_XMLRPC_LIBRARIES})
fixed bootstrap build to not use LoadCOmmandCOmmand
2002-08-27 16:36:03 +04:00
ENH: Merge from cpack branch
2006-01-02 07:31:17 +03:00
#
# Sources for CPack
#
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CPACK_SRCS
Switch to using libarchive from libtar for cpack and cmake -E tar This allows for a built in bzip and zip capability, so external tools will not be needed for these packagers. The cmake -E tar xf should be able to handle all compression types now as well.
2009-10-30 20:10:56 +03:00
CPack/cmCPackArchiveGenerator.cxx
ENH: One more patch from Doug Gregor including PackageMaker functionality for componentized-for-the-end-user and download-some-bit-on-demand installers.
2008-07-09 21:38:56 +04:00
CPack/cmCPackComponentGroup.cxx
ENH: change name of class
2007-11-06 00:33:19 +03:00
CPack/cmCPackGeneratorFactory.cxx
ENH: change name
2007-11-06 00:55:45 +03:00
CPack/cmCPackGenerator.cxx
ENH: First pass at CPack generator for OSX X11 applications. This are applications that require X11 to work. This is not really installed but a bundle packager
2007-01-10 23:30:26 +03:00
CPack/cmCPackLog.cxx
ENH: Merge from cpack branch
2006-01-02 07:31:17 +03:00
CPack/cmCPackNSISGenerator.cxx
ENH: First pass at CPack generator for OSX X11 applications. This are applications that require X11 to work. This is not really installed but a bundle packager
2007-01-10 23:30:26 +03:00
CPack/cmCPackSTGZGenerator.cxx
CPack/cmCPackTGZGenerator.cxx
ENH: Add BZip2 support, add better documentation
2006-05-04 05:42:51 +04:00
CPack/cmCPackTarBZip2Generator.cxx
ENH: Initial cut at TarCompress generator
2006-05-03 01:07:16 +04:00
CPack/cmCPackTarCompressGenerator.cxx
ENH: First pass at CPack generator for OSX X11 applications. This are applications that require X11 to work. This is not really installed but a bundle packager
2007-01-10 23:30:26 +03:00
CPack/cmCPackZIPGenerator.cxx
CPack begin the implementation of --help-command* and --help-variables* This modifications set tries to keep the unified doc for cmake/ctest/cpack while introducing tool specific documentation separated. Some documentation sections for CMake do not fit well to CPack.
2011-11-14 01:44:53 +04:00
CPack/cmCPackDocumentVariables.cxx
CPack/cmCPackDocumentMacros.cxx
ENH: Merge from cpack branch
2006-01-02 07:31:17 +03:00
)
ENH: deb generator: don't use the system provided ar, but do it yourself using the code from OpenBSD ar COMP: don't build all package generators on all platforms Alex
2007-08-14 16:40:40 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CYGWIN)
set(CPACK_SRCS ${CPACK_SRCS}
ENH: deb generator: don't use the system provided ar, but do it yourself using the code from OpenBSD ar COMP: don't build all package generators on all platforms Alex
2007-08-14 16:40:40 +04:00
CPack/cmCPackCygwinBinaryGenerator.cxx
CPack/cmCPackCygwinSourceGenerator.cxx
)
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()
Move the code for generating dot-files into separate class cmGraphVizWriter Alex
2010-11-09 23:37:51 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(UNIX)
set(CPACK_SRCS ${CPACK_SRCS}
ENH: deb generator: don't use the system provided ar, but do it yourself using the code from OpenBSD ar COMP: don't build all package generators on all platforms Alex
2007-08-14 16:40:40 +04:00
CPack/cmCPackDebGenerator.cxx
CPack/cmCPackRPMGenerator.cxx
)
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: deb generator: don't use the system provided ar, but do it yourself using the code from OpenBSD ar COMP: don't build all package generators on all platforms Alex
2007-08-14 16:40:40 +04:00
CPack: Add a WiX Generator (#11575) This new CPack generator produces an *.msi installer file. Requires having the WiX Toolset installed in order to work properly. Download the WiX Toolset installer "WiX36.exe" here: http://wix.codeplex.com/releases/view/93929
2012-10-03 18:08:49 +04:00
if(WIN32)
set(CPACK_SRCS ${CPACK_SRCS}
CPack/WiX/cmCPackWIXGenerator.cxx
CPack/WiX/cmWIXSourceWriter.cxx
CPack/WiX/cmWIXRichTextFormatWriter.cxx
)
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(APPLE)
set(CPACK_SRCS ${CPACK_SRCS}
ENH: Apply patch for feature request #7170. Thanks to Tim Shead for contributing...
2008-06-18 17:53:29 +04:00
CPack/cmCPackBundleGenerator.cxx
BUG: Fix issue #8402. Add a drag and drop bundle generator to the Mac build of CPack. Add a test of it in the CPackComponents test. Thanks to Clinton Stimpson for the patch.
2009-01-22 20:12:44 +03:00
CPack/cmCPackDragNDropGenerator.cxx
ENH: deb generator: don't use the system provided ar, but do it yourself using the code from OpenBSD ar COMP: don't build all package generators on all platforms Alex
2007-08-14 16:40:40 +04:00
CPack/cmCPackOSXX11Generator.cxx
CPack/cmCPackPackageMakerGenerator.cxx
)
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: deb generator: don't use the system provided ar, but do it yourself using the code from OpenBSD ar COMP: don't build all package generators on all platforms Alex
2007-08-14 16:40:40 +04:00
ENH: Merge from cpack branch
2006-01-02 07:31:17 +03:00
# Build CPackLib
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_library(CPackLib ${CPACK_SRCS})
target_link_libraries(CPackLib CMakeLib)
ENH: Merge from cpack branch
2006-01-02 07:31:17 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(APPLE)
add_executable(cmakexbuild cmakexbuild.cxx)
target_link_libraries(cmakexbuild CMakeLib)
add_executable(OSXScriptLauncher
COMP: Remove osx bundle from OSXScriptLauncher
2007-01-31 21:54:02 +03:00
CPack/OSXScriptLauncher.cxx)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
target_link_libraries(OSXScriptLauncher cmsys)
target_link_libraries(OSXScriptLauncher "-framework CoreFoundation")
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: add a wrapper for xcodebuild to get around bug and verbose output
2006-03-31 22:17:23 +04:00
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
# Build CMake executable
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_executable(cmake cmakemain.cxx)
target_link_libraries(cmake CMakeLib)
ENH: Enable CTest to be build as a part of CMake
2003-04-25 23:17:08 +04:00
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
# Build special executable for running programs on Windows 98
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(WIN32)
if(NOT UNIX)
add_executable(cmw9xcom cmw9xcom.cxx)
target_link_libraries(cmw9xcom CMakeLib)
install_targets(/bin cmw9xcom)
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: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
# Build CTest executable
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_executable(ctest ctest.cxx)
target_link_libraries(ctest CTestLib)
Debug optimized cache fixes
2002-05-02 23:10:19 +04:00
ENH: Merge from cpack branch
2006-01-02 07:31:17 +03:00
# Build CPack executable
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_executable(cpack CPack/cpack.cxx)
target_link_libraries(cpack CPackLib)
ENH: Merge from cpack branch
2006-01-02 07:31:17 +03:00
ENH: More cleanups and reorganization
2005-03-04 19:38:34 +03:00
# Curses GUI
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(BUILD_CursesDialog)
include(${CMake_SOURCE_DIR}/Source/CursesDialog/CMakeLists.txt)
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()
Debug optimized cache fixes
2002-05-02 23:10:19 +04:00
ENH: add option for qt dialog
2007-11-02 19:03:29 +03:00
# Qt GUI
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
option(BUILD_QtDialog "Build Qt dialog for CMake" FALSE)
if(BUILD_QtDialog)
Use add_subdirectory instead of the obsolete subdirs.
2012-08-17 22:37:54 +04:00
add_subdirectory(QtDialog)
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()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
include (${CMake_BINARY_DIR}/Source/LocalUserOptions.cmake OPTIONAL)
include (${CMake_SOURCE_DIR}/Source/LocalUserOptions.cmake OPTIONAL)
install_targets(/bin cmake)
install_targets(/bin ctest)
install_targets(/bin cpack)
if(APPLE)
install_targets(/bin cmakexbuild)
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()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
install_files(${CMAKE_DATA_DIR}/include cmCPluginAPI.h)