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

1 files changed, 85 insertions, 85 deletions

diff --git a/Modules/CMakeDetermineCXXCompiler.cmake b/Modules/CMakeDetermineCXXCompiler.cmake
index 0116d34..aaabb20 100644
--- a/Modules/CMakeDetermineCXXCompiler.cmake
+++ b/Modules/CMakeDetermineCXXCompiler.cmake
@@ -30,42 +30,42 @@
 # If not already set before, it also sets
 #   _CMAKE_TOOLCHAIN_PREFIX
 
-INCLUDE(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
+include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
 
 # Load system-specific compiler preferences for this language.
-INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-CXX OPTIONAL)
-IF(NOT CMAKE_CXX_COMPILER_NAMES)
-  SET(CMAKE_CXX_COMPILER_NAMES CC)
-ENDIF()
+include(Platform/${CMAKE_SYSTEM_NAME}-CXX OPTIONAL)
+if(NOT CMAKE_CXX_COMPILER_NAMES)
+  set(CMAKE_CXX_COMPILER_NAMES CC)
+endif()
 
-IF(NOT CMAKE_CXX_COMPILER)
-  SET(CMAKE_CXX_COMPILER_INIT NOTFOUND)
+if(NOT CMAKE_CXX_COMPILER)
+  set(CMAKE_CXX_COMPILER_INIT NOTFOUND)
 
   # prefer the environment variable CXX
-  IF($ENV{CXX} MATCHES ".+")
-    GET_FILENAME_COMPONENT(CMAKE_CXX_COMPILER_INIT $ENV{CXX} PROGRAM PROGRAM_ARGS CMAKE_CXX_FLAGS_ENV_INIT)
-    IF(CMAKE_CXX_FLAGS_ENV_INIT)
-      SET(CMAKE_CXX_COMPILER_ARG1 "${CMAKE_CXX_FLAGS_ENV_INIT}" CACHE STRING "First argument to CXX compiler")
-    ENDIF(CMAKE_CXX_FLAGS_ENV_INIT)
-    IF(NOT EXISTS ${CMAKE_CXX_COMPILER_INIT})
-      MESSAGE(FATAL_ERROR "Could not find compiler set in environment variable CXX:\n$ENV{CXX}.\n${CMAKE_CXX_COMPILER_INIT}")
-    ENDIF(NOT EXISTS ${CMAKE_CXX_COMPILER_INIT})
-  ENDIF($ENV{CXX} MATCHES ".+")
+  if($ENV{CXX} MATCHES ".+")
+    get_filename_component(CMAKE_CXX_COMPILER_INIT $ENV{CXX} PROGRAM PROGRAM_ARGS CMAKE_CXX_FLAGS_ENV_INIT)
+    if(CMAKE_CXX_FLAGS_ENV_INIT)
+      set(CMAKE_CXX_COMPILER_ARG1 "${CMAKE_CXX_FLAGS_ENV_INIT}" CACHE STRING "First argument to CXX compiler")
+    endif(CMAKE_CXX_FLAGS_ENV_INIT)
+    if(NOT EXISTS ${CMAKE_CXX_COMPILER_INIT})
+      message(FATAL_ERROR "Could not find compiler set in environment variable CXX:\n$ENV{CXX}.\n${CMAKE_CXX_COMPILER_INIT}")
+    endif(NOT EXISTS ${CMAKE_CXX_COMPILER_INIT})
+  endif($ENV{CXX} MATCHES ".+")
 
   # next prefer the generator specified compiler
-  IF(CMAKE_GENERATOR_CXX)
-    IF(NOT CMAKE_CXX_COMPILER_INIT)
-      SET(CMAKE_CXX_COMPILER_INIT ${CMAKE_GENERATOR_CXX})
-    ENDIF(NOT CMAKE_CXX_COMPILER_INIT)
-  ENDIF(CMAKE_GENERATOR_CXX)
+  if(CMAKE_GENERATOR_CXX)
+    if(NOT CMAKE_CXX_COMPILER_INIT)
+      set(CMAKE_CXX_COMPILER_INIT ${CMAKE_GENERATOR_CXX})
+    endif(NOT CMAKE_CXX_COMPILER_INIT)
+  endif(CMAKE_GENERATOR_CXX)
 
   # finally list compilers to try
-  IF(NOT CMAKE_CXX_COMPILER_INIT)
-    SET(CMAKE_CXX_COMPILER_LIST CC ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ aCC cl bcc xlC clang++)
-  ENDIF()
+  if(NOT CMAKE_CXX_COMPILER_INIT)
+    set(CMAKE_CXX_COMPILER_LIST CC ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ aCC cl bcc xlC clang++)
+  endif()
 
   _cmake_find_compiler(CXX)
-ELSE(NOT CMAKE_CXX_COMPILER)
+else(NOT CMAKE_CXX_COMPILER)
 
 # we only get here if CMAKE_CXX_COMPILER was specified using -D or a pre-made CMakeCache.txt
 # (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
@@ -73,31 +73,31 @@ ELSE(NOT CMAKE_CXX_COMPILER)
 # if CMAKE_CXX_COMPILER is a list of length 2, use the first item as
 # CMAKE_CXX_COMPILER and the 2nd one as CMAKE_CXX_COMPILER_ARG1
 
-  LIST(LENGTH CMAKE_CXX_COMPILER _CMAKE_CXX_COMPILER_LIST_LENGTH)
-  IF("${_CMAKE_CXX_COMPILER_LIST_LENGTH}" EQUAL 2)
-    LIST(GET CMAKE_CXX_COMPILER 1 CMAKE_CXX_COMPILER_ARG1)
-    LIST(GET CMAKE_CXX_COMPILER 0 CMAKE_CXX_COMPILER)
-  ENDIF("${_CMAKE_CXX_COMPILER_LIST_LENGTH}" EQUAL 2)
+  list(LENGTH CMAKE_CXX_COMPILER _CMAKE_CXX_COMPILER_LIST_LENGTH)
+  if("${_CMAKE_CXX_COMPILER_LIST_LENGTH}" EQUAL 2)
+    list(GET CMAKE_CXX_COMPILER 1 CMAKE_CXX_COMPILER_ARG1)
+    list(GET CMAKE_CXX_COMPILER 0 CMAKE_CXX_COMPILER)
+  endif("${_CMAKE_CXX_COMPILER_LIST_LENGTH}" EQUAL 2)
 
 # if a compiler was specified by the user but without path,
 # now try to find it with the full path
 # if it is found, force it into the cache,
 # if not, don't overwrite the setting (which was given by the user) with "NOTFOUND"
 # if the CXX compiler already had a path, reuse it for searching the C compiler
-  GET_FILENAME_COMPONENT(_CMAKE_USER_CXX_COMPILER_PATH "${CMAKE_CXX_COMPILER}" PATH)
-  IF(NOT _CMAKE_USER_CXX_COMPILER_PATH)
-    FIND_PROGRAM(CMAKE_CXX_COMPILER_WITH_PATH NAMES ${CMAKE_CXX_COMPILER})
-    MARK_AS_ADVANCED(CMAKE_CXX_COMPILER_WITH_PATH)
-    IF(CMAKE_CXX_COMPILER_WITH_PATH)
-      SET(CMAKE_CXX_COMPILER ${CMAKE_CXX_COMPILER_WITH_PATH} CACHE STRING "CXX compiler" FORCE)
-    ENDIF(CMAKE_CXX_COMPILER_WITH_PATH)
-  ENDIF(NOT _CMAKE_USER_CXX_COMPILER_PATH)
-ENDIF(NOT CMAKE_CXX_COMPILER)
-MARK_AS_ADVANCED(CMAKE_CXX_COMPILER)
-
-IF (NOT _CMAKE_TOOLCHAIN_LOCATION)
-  GET_FILENAME_COMPONENT(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_CXX_COMPILER}" PATH)
-ENDIF (NOT _CMAKE_TOOLCHAIN_LOCATION)
+  get_filename_component(_CMAKE_USER_CXX_COMPILER_PATH "${CMAKE_CXX_COMPILER}" PATH)
+  if(NOT _CMAKE_USER_CXX_COMPILER_PATH)
+    find_program(CMAKE_CXX_COMPILER_WITH_PATH NAMES ${CMAKE_CXX_COMPILER})
+    mark_as_advanced(CMAKE_CXX_COMPILER_WITH_PATH)
+    if(CMAKE_CXX_COMPILER_WITH_PATH)
+      set(CMAKE_CXX_COMPILER ${CMAKE_CXX_COMPILER_WITH_PATH} CACHE STRING "CXX compiler" FORCE)
+    endif(CMAKE_CXX_COMPILER_WITH_PATH)
+  endif(NOT _CMAKE_USER_CXX_COMPILER_PATH)
+endif(NOT CMAKE_CXX_COMPILER)
+mark_as_advanced(CMAKE_CXX_COMPILER)
+
+if (NOT _CMAKE_TOOLCHAIN_LOCATION)
+  get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_CXX_COMPILER}" PATH)
+endif (NOT _CMAKE_TOOLCHAIN_LOCATION)
 
 # This block was used before the compiler was identified by building a
 # source file.  Unless g++ crashes when building a small C++
@@ -106,45 +106,45 @@ ENDIF (NOT _CMAKE_TOOLCHAIN_LOCATION)
 # The g++ that comes with BeOS 5 segfaults if you run "g++ -E"
 #  ("gcc -E" is fine), which throws up a system dialog box that hangs cmake
 #  until the user clicks "OK"...so for now, we just assume it's g++.
-# IF(BEOS)
-#   SET(CMAKE_COMPILER_IS_GNUCXX 1)
-#   SET(CMAKE_COMPILER_IS_GNUCXX_RUN 1)
-# ENDIF(BEOS)
+# if(BEOS)
+#   set(CMAKE_COMPILER_IS_GNUCXX 1)
+#   set(CMAKE_COMPILER_IS_GNUCXX_RUN 1)
+# endif(BEOS)
 
 # Build a small source file to identify the compiler.
-IF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
-  SET(CMAKE_CXX_COMPILER_ID_RUN 1)
-  SET(CMAKE_CXX_PLATFORM_ID "Windows")
-  SET(CMAKE_CXX_COMPILER_ID "MSVC")
-ENDIF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
-IF(NOT CMAKE_CXX_COMPILER_ID_RUN)
-  SET(CMAKE_CXX_COMPILER_ID_RUN 1)
+if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
+  set(CMAKE_CXX_COMPILER_ID_RUN 1)
+  set(CMAKE_CXX_PLATFORM_ID "Windows")
+  set(CMAKE_CXX_COMPILER_ID "MSVC")
+endif(${CMAKE_GENERATOR} MATCHES "Visual Studio")
+if(NOT CMAKE_CXX_COMPILER_ID_RUN)
+  set(CMAKE_CXX_COMPILER_ID_RUN 1)
 
   # Each entry in this list is a set of extra flags to try
   # adding to the compile line to see if it helps produce
   # a valid identification file.
-  SET(CMAKE_CXX_COMPILER_ID_TEST_FLAGS
+  set(CMAKE_CXX_COMPILER_ID_TEST_FLAGS
     # Try compiling to an object file only.
     "-c"
     )
 
   # Try to identify the compiler.
-  SET(CMAKE_CXX_COMPILER_ID)
-  FILE(READ ${CMAKE_ROOT}/Modules/CMakePlatformId.h.in
+  set(CMAKE_CXX_COMPILER_ID)
+  file(READ ${CMAKE_ROOT}/Modules/CMakePlatformId.h.in
     CMAKE_CXX_COMPILER_ID_PLATFORM_CONTENT)
-  INCLUDE(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
+  include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
   CMAKE_DETERMINE_COMPILER_ID(CXX CXXFLAGS CMakeCXXCompilerId.cpp)
 
   # Set old compiler and platform id variables.
-  IF("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
-    SET(CMAKE_COMPILER_IS_GNUCXX 1)
-  ENDIF("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
-  IF("${CMAKE_CXX_PLATFORM_ID}" MATCHES "MinGW")
-    SET(CMAKE_COMPILER_IS_MINGW 1)
-  ELSEIF("${CMAKE_CXX_PLATFORM_ID}" MATCHES "Cygwin")
-    SET(CMAKE_COMPILER_IS_CYGWIN 1)
-  ENDIF("${CMAKE_CXX_PLATFORM_ID}" MATCHES "MinGW")
-ENDIF(NOT CMAKE_CXX_COMPILER_ID_RUN)
+  if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+    set(CMAKE_COMPILER_IS_GNUCXX 1)
+  endif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+  if("${CMAKE_CXX_PLATFORM_ID}" MATCHES "MinGW")
+    set(CMAKE_COMPILER_IS_MINGW 1)
+  elseif("${CMAKE_CXX_PLATFORM_ID}" MATCHES "Cygwin")
+    set(CMAKE_COMPILER_IS_CYGWIN 1)
+  endif("${CMAKE_CXX_PLATFORM_ID}" MATCHES "MinGW")
+endif(NOT CMAKE_CXX_COMPILER_ID_RUN)
 
 # if we have a g++ cross compiler, they have usually some prefix, like
 # e.g. powerpc-linux-g++, arm-elf-g++ or i586-mingw32msvc-g++ , optionally
@@ -153,34 +153,34 @@ ENDIF(NOT CMAKE_CXX_COMPILER_ID_RUN)
 # NAME_WE cannot be used since then this test will fail for names lile
 # "arm-unknown-nto-qnx6.3.0-gcc.exe", where BASENAME would be
 # "arm-unknown-nto-qnx6" instead of the correct "arm-unknown-nto-qnx6.3.0-"
-IF (CMAKE_CROSSCOMPILING
+if (CMAKE_CROSSCOMPILING
     AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU"
     AND NOT _CMAKE_TOOLCHAIN_PREFIX)
-  GET_FILENAME_COMPONENT(COMPILER_BASENAME "${CMAKE_CXX_COMPILER}" NAME)
-  IF (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
-    SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
-  ENDIF (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+  get_filename_component(COMPILER_BASENAME "${CMAKE_CXX_COMPILER}" NAME)
+  if (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
 
   # if "llvm-" is part of the prefix, remove it, since llvm doesn't have its own binutils
   # but uses the regular ar, objcopy, etc. (instead of llvm-objcopy etc.)
-  IF ("${_CMAKE_TOOLCHAIN_PREFIX}" MATCHES "(.+-)?llvm-$")
-    SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
-  ENDIF ("${_CMAKE_TOOLCHAIN_PREFIX}" MATCHES "(.+-)?llvm-$")
+  if ("${_CMAKE_TOOLCHAIN_PREFIX}" MATCHES "(.+-)?llvm-$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ("${_CMAKE_TOOLCHAIN_PREFIX}" MATCHES "(.+-)?llvm-$")
 
-ENDIF (CMAKE_CROSSCOMPILING
+endif (CMAKE_CROSSCOMPILING
     AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU"
     AND NOT _CMAKE_TOOLCHAIN_PREFIX)
 
-INCLUDE(${CMAKE_ROOT}/Modules/CMakeClDeps.cmake)
-INCLUDE(CMakeFindBinUtils)
-IF(MSVC_CXX_ARCHITECTURE_ID)
-  SET(SET_MSVC_CXX_ARCHITECTURE_ID
-    "SET(MSVC_CXX_ARCHITECTURE_ID ${MSVC_CXX_ARCHITECTURE_ID})")
-ENDIF(MSVC_CXX_ARCHITECTURE_ID)
+include(${CMAKE_ROOT}/Modules/CMakeClDeps.cmake)
+include(CMakeFindBinUtils)
+if(MSVC_CXX_ARCHITECTURE_ID)
+  set(SET_MSVC_CXX_ARCHITECTURE_ID
+    "set(MSVC_CXX_ARCHITECTURE_ID ${MSVC_CXX_ARCHITECTURE_ID})")
+endif(MSVC_CXX_ARCHITECTURE_ID)
 # configure all variables set in this file
-CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
+configure_file(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
   ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCXXCompiler.cmake
   @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
   )
 
-SET(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
+set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")