Imported Upstream version 2.8.10.2upstream/2.8.10.2

1401 files changed, 45757 insertions, 24188 deletions

diff --git a/CMakeCPack.cmake b/CMakeCPack.cmake
index c3c25f560..a27d00004 100644
--- a/CMakeCPack.cmake
+++ b/CMakeCPack.cmake
@@ -11,113 +11,114 @@
 #=============================================================================
 
 # If the cmake version includes cpack, use it
-IF(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
-  IF(EXISTS "${CMAKE_ROOT}/Modules/InstallRequiredSystemLibraries.cmake")
-    OPTION(CMAKE_INSTALL_DEBUG_LIBRARIES
+if(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
+  if(EXISTS "${CMAKE_ROOT}/Modules/InstallRequiredSystemLibraries.cmake")
+    option(CMAKE_INSTALL_DEBUG_LIBRARIES
       "Install Microsoft runtime debug libraries with CMake." FALSE)
-    MARK_AS_ADVANCED(CMAKE_INSTALL_DEBUG_LIBRARIES)
+    mark_as_advanced(CMAKE_INSTALL_DEBUG_LIBRARIES)
 
     # By default, do not warn when built on machines using only VS Express:
-    IF(NOT DEFINED CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS)
-      SET(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON)
-    ENDIF()
+    if(NOT DEFINED CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS)
+      set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON)
+    endif()
 
-    INCLUDE(${CMake_SOURCE_DIR}/Modules/InstallRequiredSystemLibraries.cmake)
-  ENDIF(EXISTS "${CMAKE_ROOT}/Modules/InstallRequiredSystemLibraries.cmake")
+    include(${CMake_SOURCE_DIR}/Modules/InstallRequiredSystemLibraries.cmake)
+  endif()
 
-  SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "CMake is a build tool")
-  SET(CPACK_PACKAGE_VENDOR "Kitware")
-  SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Copyright.txt")
-  SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/Copyright.txt")
-  SET(CPACK_PACKAGE_VERSION "${CMake_VERSION}")
-  SET(CPACK_PACKAGE_INSTALL_DIRECTORY "CMake ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}")
-  SET(CPACK_SOURCE_PACKAGE_FILE_NAME "cmake-${CMake_VERSION}")
+  set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "CMake is a build tool")
+  set(CPACK_PACKAGE_VENDOR "Kitware")
+  set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/Copyright.txt")
+  set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/Copyright.txt")
+  set(CPACK_PACKAGE_VERSION "${CMake_VERSION}")
+  set(CPACK_PACKAGE_INSTALL_DIRECTORY "CMake ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}")
+  set(CPACK_SOURCE_PACKAGE_FILE_NAME "cmake-${CMake_VERSION}")
 
   # Make this explicit here, rather than accepting the CPack default value,
   # so we can refer to it:
-  SET(CPACK_PACKAGE_NAME "${CMAKE_PROJECT_NAME}")
+  set(CPACK_PACKAGE_NAME "${CMAKE_PROJECT_NAME}")
 
   # Installers for 32- vs. 64-bit CMake:
   #  - Root install directory (displayed to end user at installer-run time)
   #  - "NSIS package/display name" (text used in the installer GUI)
   #  - Registry key used to store info about the installation
-  IF(CMAKE_CL_64)
-    SET(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES64")
-    SET(CPACK_NSIS_PACKAGE_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} (Win64)")
-    SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${CPACK_PACKAGE_NAME} ${CPACK_PACKAGE_VERSION} (Win64)")
-  ELSE()
-    SET(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES")
-    SET(CPACK_NSIS_PACKAGE_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY}")
-    SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${CPACK_PACKAGE_NAME} ${CPACK_PACKAGE_VERSION}")
-  ENDIF()
+  if(CMAKE_CL_64)
+    set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES64")
+    set(CPACK_NSIS_PACKAGE_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} (Win64)")
+    set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${CPACK_PACKAGE_NAME} ${CPACK_PACKAGE_VERSION} (Win64)")
+  else()
+    set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES")
+    set(CPACK_NSIS_PACKAGE_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY}")
+    set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "${CPACK_PACKAGE_NAME} ${CPACK_PACKAGE_VERSION}")
+  endif()
 
-  IF(NOT DEFINED CPACK_SYSTEM_NAME)
+  if(NOT DEFINED CPACK_SYSTEM_NAME)
     # make sure package is not Cygwin-unknown, for Cygwin just
     # cygwin is good for the system name
-    IF("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
-      SET(CPACK_SYSTEM_NAME Cygwin)
-    ELSE("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
-      SET(CPACK_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR})
-    ENDIF("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
-  ENDIF(NOT DEFINED CPACK_SYSTEM_NAME)
-  IF(${CPACK_SYSTEM_NAME} MATCHES Windows)
-    IF(CMAKE_CL_64)
-      SET(CPACK_SYSTEM_NAME win64-x64)
-    ELSE(CMAKE_CL_64)
-      SET(CPACK_SYSTEM_NAME win32-x86)
-    ENDIF(CMAKE_CL_64)
-  ENDIF(${CPACK_SYSTEM_NAME} MATCHES Windows)
+    if("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
+      set(CPACK_SYSTEM_NAME Cygwin)
+    else()
+      set(CPACK_SYSTEM_NAME ${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR})
+    endif()
+  endif()
+  if(${CPACK_SYSTEM_NAME} MATCHES Windows)
+    if(CMAKE_CL_64)
+      set(CPACK_SYSTEM_NAME win64-x64)
+    else()
+      set(CPACK_SYSTEM_NAME win32-x86)
+    endif()
+  endif()
 
-  IF(NOT DEFINED CPACK_PACKAGE_FILE_NAME)
+  if(NOT DEFINED CPACK_PACKAGE_FILE_NAME)
     # if the CPACK_PACKAGE_FILE_NAME is not defined by the cache
-    # default to source package - system, on cygwin system is not 
+    # default to source package - system, on cygwin system is not
     # needed
-    IF(CYGWIN)
-      SET(CPACK_PACKAGE_FILE_NAME "${CPACK_SOURCE_PACKAGE_FILE_NAME}")
-    ELSE(CYGWIN)
-      SET(CPACK_PACKAGE_FILE_NAME 
+    if(CYGWIN)
+      set(CPACK_PACKAGE_FILE_NAME "${CPACK_SOURCE_PACKAGE_FILE_NAME}")
+    else()
+      set(CPACK_PACKAGE_FILE_NAME
         "${CPACK_SOURCE_PACKAGE_FILE_NAME}-${CPACK_SYSTEM_NAME}")
-    ENDIF(CYGWIN)
-  ENDIF(NOT DEFINED CPACK_PACKAGE_FILE_NAME)
+    endif()
+  endif()
 
-  SET(CPACK_PACKAGE_CONTACT "cmake@cmake.org")
+  set(CPACK_PACKAGE_CONTACT "cmake@cmake.org")
 
-  IF(UNIX)
-    SET(CPACK_STRIP_FILES "bin/ccmake;bin/cmake;bin/cpack;bin/ctest")
-    SET(CPACK_SOURCE_STRIP_FILES "")
-    SET(CPACK_PACKAGE_EXECUTABLES "ccmake" "CMake")
-  ENDIF(UNIX)
+  if(UNIX)
+    set(CPACK_STRIP_FILES "bin/ccmake;bin/cmake;bin/cpack;bin/ctest")
+    set(CPACK_SOURCE_STRIP_FILES "")
+    set(CPACK_PACKAGE_EXECUTABLES "ccmake" "CMake")
+  endif()
 
   # cygwin specific packaging stuff
-  IF(CYGWIN)
+  if(CYGWIN)
     # setup the cygwin package name
-    SET(CPACK_PACKAGE_NAME cmake)
+    set(CPACK_PACKAGE_NAME cmake)
     # setup the name of the package for cygwin cmake-2.4.3
-    SET(CPACK_PACKAGE_FILE_NAME
+    set(CPACK_PACKAGE_FILE_NAME
       "${CPACK_PACKAGE_NAME}-${CMake_VERSION}")
     # the source has the same name as the binary
-    SET(CPACK_SOURCE_PACKAGE_FILE_NAME ${CPACK_PACKAGE_FILE_NAME})
+    set(CPACK_SOURCE_PACKAGE_FILE_NAME ${CPACK_PACKAGE_FILE_NAME})
     # Create a cygwin version number in case there are changes for cygwin
     # that are not reflected upstream in CMake
-    SET(CPACK_CYGWIN_PATCH_NUMBER 1)
+    set(CPACK_CYGWIN_PATCH_NUMBER 1 CACHE STRING "patch number for CMake cygwin packages")
+    mark_as_advanced(CPACK_CYGWIN_PATCH_NUMBER)
     # These files are required by the cmCPackCygwinSourceGenerator and the files
     # put into the release tar files.
-    SET(CPACK_CYGWIN_BUILD_SCRIPT 
-      "${CMake_BINARY_DIR}/@CPACK_PACKAGE_FILE_NAME@-@CPACK_CYGWIN_PATCH_NUMBER@.sh")
-    SET(CPACK_CYGWIN_PATCH_FILE 
-      "${CMake_BINARY_DIR}/@CPACK_PACKAGE_FILE_NAME@-@CPACK_CYGWIN_PATCH_NUMBER@.patch")
+    set(CPACK_CYGWIN_BUILD_SCRIPT
+      "${CMake_BINARY_DIR}/${CPACK_PACKAGE_FILE_NAME}-${CPACK_CYGWIN_PATCH_NUMBER}.sh")
+    set(CPACK_CYGWIN_PATCH_FILE
+      "${CMake_BINARY_DIR}/${CPACK_PACKAGE_FILE_NAME}-${CPACK_CYGWIN_PATCH_NUMBER}.patch")
     # include the sub directory cmake file for cygwin that
     # configures some files and adds some install targets
     # this file uses some of the package file name variables
-    INCLUDE(Utilities/Release/Cygwin/CMakeLists.txt)
-  ENDIF(CYGWIN)
+    include(Utilities/Release/Cygwin/CMakeLists.txt)
+  endif()
 
   # Set the options file that needs to be included inside CMakeCPackOptions.cmake
-  SET(QT_DIALOG_CPACK_OPTIONS_FILE ${CMake_BINARY_DIR}/Source/QtDialog/QtDialogCPack.cmake)
-  CONFIGURE_FILE("${CMake_SOURCE_DIR}/CMakeCPackOptions.cmake.in"
+  set(QT_DIALOG_CPACK_OPTIONS_FILE ${CMake_BINARY_DIR}/Source/QtDialog/QtDialogCPack.cmake)
+  configure_file("${CMake_SOURCE_DIR}/CMakeCPackOptions.cmake.in"
     "${CMake_BINARY_DIR}/CMakeCPackOptions.cmake" @ONLY)
-  SET(CPACK_PROJECT_CONFIG_FILE "${CMake_BINARY_DIR}/CMakeCPackOptions.cmake")
+  set(CPACK_PROJECT_CONFIG_FILE "${CMake_BINARY_DIR}/CMakeCPackOptions.cmake")
 
   # include CPack model once all variables are set
-  INCLUDE(CPack)
-ENDIF(EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
+  include(CPack)
+endif()
diff --git a/CMakeCPackOptions.cmake.in b/CMakeCPackOptions.cmake.in
index 69a150851..3a72eaa5c 100644
--- a/CMakeCPackOptions.cmake.in
+++ b/CMakeCPackOptions.cmake.in
@@ -1,18 +1,18 @@
 # This file is configured at cmake time, and loaded at cpack time.
 # To pass variables to cpack from cmake, they must be configured
-# in this file.  
+# in this file.
 
 if(CPACK_GENERATOR MATCHES "NSIS")
-  SET(CPACK_NSIS_INSTALL_ROOT "@CPACK_NSIS_INSTALL_ROOT@")
+  set(CPACK_NSIS_INSTALL_ROOT "@CPACK_NSIS_INSTALL_ROOT@")
 
   # set the install/unistall icon used for the installer itself
   # There is a bug in NSI that does not handle full unix paths properly.
-  SET(CPACK_NSIS_MUI_ICON "@CMake_SOURCE_DIR@/Utilities/Release\\CMakeLogo.ico")
-  SET(CPACK_NSIS_MUI_UNIICON "@CMake_SOURCE_DIR@/Utilities/Release\\CMakeLogo.ico")
+  set(CPACK_NSIS_MUI_ICON "@CMake_SOURCE_DIR@/Utilities/Release\\CMakeLogo.ico")
+  set(CPACK_NSIS_MUI_UNIICON "@CMake_SOURCE_DIR@/Utilities/Release\\CMakeLogo.ico")
   # set the package header icon for MUI
-  SET(CPACK_PACKAGE_ICON "@CMake_SOURCE_DIR@/Utilities/Release\\CMakeInstall.bmp")
+  set(CPACK_PACKAGE_ICON "@CMake_SOURCE_DIR@/Utilities/Release\\CMakeInstall.bmp")
   # tell cpack to create links to the doc files
-  SET(CPACK_NSIS_MENU_LINKS
+  set(CPACK_NSIS_MENU_LINKS
     "doc/cmake-@CMake_VERSION_MAJOR@.@CMake_VERSION_MINOR@/cmake-gui.html" "cmake-gui Help"
     "doc/cmake-@CMake_VERSION_MAJOR@.@CMake_VERSION_MINOR@/cmake.html" "CMake Help"
     "doc/cmake-@CMake_VERSION_MAJOR@.@CMake_VERSION_MINOR@/cmake-properties.html"
@@ -24,30 +24,30 @@ if(CPACK_GENERATOR MATCHES "NSIS")
     "http://www.cmake.org" "CMake Web Site"
     )
   # Use the icon from cmake-gui for add-remove programs
-  SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\cmake-gui.exe")
+  set(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\cmake-gui.exe")
 
-  SET(CPACK_NSIS_PACKAGE_NAME "@CPACK_NSIS_PACKAGE_NAME@")
-  SET(CPACK_NSIS_DISPLAY_NAME "@CPACK_NSIS_PACKAGE_NAME@, a cross-platform, open-source build system")
-  SET(CPACK_NSIS_HELP_LINK "http://www.cmake.org")
-  SET(CPACK_NSIS_URL_INFO_ABOUT "http://www.kitware.com")
-  SET(CPACK_NSIS_CONTACT @CPACK_PACKAGE_CONTACT@)
-  SET(CPACK_NSIS_MODIFY_PATH ON)
-endif(CPACK_GENERATOR MATCHES "NSIS")
+  set(CPACK_NSIS_PACKAGE_NAME "@CPACK_NSIS_PACKAGE_NAME@")
+  set(CPACK_NSIS_DISPLAY_NAME "@CPACK_NSIS_PACKAGE_NAME@, a cross-platform, open-source build system")
+  set(CPACK_NSIS_HELP_LINK "http://www.cmake.org")
+  set(CPACK_NSIS_URL_INFO_ABOUT "http://www.kitware.com")
+  set(CPACK_NSIS_CONTACT @CPACK_PACKAGE_CONTACT@)
+  set(CPACK_NSIS_MODIFY_PATH ON)
+endif()
 
 # include the cpack options for qt dialog if they exisit
 # they might not if qt was not enabled for the build
-INCLUDE("@QT_DIALOG_CPACK_OPTIONS_FILE@" OPTIONAL)
+include("@QT_DIALOG_CPACK_OPTIONS_FILE@" OPTIONAL)
 
 if(CPACK_GENERATOR MATCHES "CygwinSource")
   # when packaging source make sure the .build directory is not included
-    SET(CPACK_SOURCE_IGNORE_FILES
+    set(CPACK_SOURCE_IGNORE_FILES
       "/CVS/" "/\\.build/" "/\\.svn/" "\\.swp$" "\\.#" "/#" "~$")
-endif(CPACK_GENERATOR MATCHES "CygwinSource")
+endif()
 
 if("${CPACK_GENERATOR}" STREQUAL "PackageMaker")
-  if(CMAKE_PACKAGE_QTGUI)                       
+  if(CMAKE_PACKAGE_QTGUI)
     set(CPACK_PACKAGE_DEFAULT_LOCATION "/Applications")
-  else(CMAKE_PACKAGE_QTGUI)                     
+  else()
     set(CPACK_PACKAGE_DEFAULT_LOCATION "/usr")
-  endif(CMAKE_PACKAGE_QTGUI)                    
-endif("${CPACK_GENERATOR}" STREQUAL "PackageMaker")
+  endif()
+endif()
diff --git a/CMakeGraphVizOptions.cmake b/CMakeGraphVizOptions.cmake
index 038f17e9b..1add78c55 100644
--- a/CMakeGraphVizOptions.cmake
+++ b/CMakeGraphVizOptions.cmake
@@ -1 +1 @@
-SET(GRAPHVIZ_IGNORE_TARGETS "tartest;testSystemTools;testRegistry;testProcess;testIOS;testHashSTL;testFail;testCommandLineArguments;xrtest;LIBCURL;foo")
+set(GRAPHVIZ_IGNORE_TARGETS "tartest;testSystemTools;testRegistry;testProcess;testIOS;testHashSTL;testFail;testCommandLineArguments;xrtest;LIBCURL;foo")
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8522cad28..ea1c0339e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,71 +9,71 @@
 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 # See the License for more information.
 #=============================================================================
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.2 FATAL_ERROR)
-SET(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required
-PROJECT(CMake)
+cmake_minimum_required(VERSION 2.8.2 FATAL_ERROR)
+set(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required
+project(CMake)
 
-IF(CMAKE_BOOTSTRAP)
+if(CMAKE_BOOTSTRAP)
   # Running from bootstrap script.  Set local variable and remove from cache.
-  SET(CMAKE_BOOTSTRAP 1)
-  UNSET(CMAKE_BOOTSTRAP CACHE)
-ENDIF()
+  set(CMAKE_BOOTSTRAP 1)
+  unset(CMAKE_BOOTSTRAP CACHE)
+endif()
 
-SET(CMake_BIN_DIR ${CMake_BINARY_DIR}/bin)
+set(CMake_BIN_DIR ${CMake_BINARY_DIR}/bin)
 
-IF("${CMake_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}")
+if("${CMake_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}")
   # Disallow architecture-specific try_run.  It may not run on the host.
-  MACRO(TRY_RUN)
-    IF(CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
-      MESSAGE(FATAL_ERROR "TRY_RUN not allowed with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES=[${CMAKE_TRY_COMPILE_OSX_ARCHITECTURES}]")
-    ELSE()
+  macro(TRY_RUN)
+    if(CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+      message(FATAL_ERROR "TRY_RUN not allowed with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES=[${CMAKE_TRY_COMPILE_OSX_ARCHITECTURES}]")
+    else()
       _TRY_RUN(${ARGV})
-    ENDIF()
-  ENDMACRO()
-ENDIF()
+    endif()
+  endmacro()
+endif()
 
 #-----------------------------------------------------------------------
 # a macro to deal with system libraries, implemented as a macro
 # simply to improve readability of the main script
 #-----------------------------------------------------------------------
-MACRO(CMAKE_HANDLE_SYSTEM_LIBRARIES)
+macro(CMAKE_HANDLE_SYSTEM_LIBRARIES)
   # Options have dependencies.
-  INCLUDE(CMakeDependentOption)
+  include(CMakeDependentOption)
 
   # Optionally use system xmlrpc.  We no longer build or use it by default.
-  OPTION(CTEST_USE_XMLRPC "Enable xmlrpc submission method in CTest." OFF)
-  MARK_AS_ADVANCED(CTEST_USE_XMLRPC)
+  option(CTEST_USE_XMLRPC "Enable xmlrpc submission method in CTest." OFF)
+  mark_as_advanced(CTEST_USE_XMLRPC)
 
   # Allow the user to enable/disable all system utility library options by
   # defining CMAKE_USE_SYSTEM_LIBRARIES or CMAKE_USE_SYSTEM_LIBRARY_${util}.
-  SET(UTILITIES BZIP2 CURL EXPAT LIBARCHIVE ZLIB)
-  FOREACH(util ${UTILITIES})
-    IF(NOT DEFINED CMAKE_USE_SYSTEM_LIBRARY_${util}
+  set(UTILITIES BZIP2 CURL EXPAT LIBARCHIVE ZLIB)
+  foreach(util ${UTILITIES})
+    if(NOT DEFINED CMAKE_USE_SYSTEM_LIBRARY_${util}
         AND DEFINED CMAKE_USE_SYSTEM_LIBRARIES)
-      SET(CMAKE_USE_SYSTEM_LIBRARY_${util} "${CMAKE_USE_SYSTEM_LIBRARIES}")
-    ENDIF()
-    IF(DEFINED CMAKE_USE_SYSTEM_LIBRARY_${util})
-      IF(CMAKE_USE_SYSTEM_LIBRARY_${util})
-        SET(CMAKE_USE_SYSTEM_LIBRARY_${util} ON)
-      ELSE()
-        SET(CMAKE_USE_SYSTEM_LIBRARY_${util} OFF)
-      ENDIF()
-      IF(CMAKE_BOOTSTRAP)
-        UNSET(CMAKE_USE_SYSTEM_LIBRARY_${util} CACHE)
-      ENDIF()
-      STRING(TOLOWER "${util}" lutil)
-      SET(CMAKE_USE_SYSTEM_${util} "${CMAKE_USE_SYSTEM_LIBRARY_${util}}"
+      set(CMAKE_USE_SYSTEM_LIBRARY_${util} "${CMAKE_USE_SYSTEM_LIBRARIES}")
+    endif()
+    if(DEFINED CMAKE_USE_SYSTEM_LIBRARY_${util})
+      if(CMAKE_USE_SYSTEM_LIBRARY_${util})
+        set(CMAKE_USE_SYSTEM_LIBRARY_${util} ON)
+      else()
+        set(CMAKE_USE_SYSTEM_LIBRARY_${util} OFF)
+      endif()
+      if(CMAKE_BOOTSTRAP)
+        unset(CMAKE_USE_SYSTEM_LIBRARY_${util} CACHE)
+      endif()
+      string(TOLOWER "${util}" lutil)
+      set(CMAKE_USE_SYSTEM_${util} "${CMAKE_USE_SYSTEM_LIBRARY_${util}}"
         CACHE BOOL "Use system-installed ${lutil}" FORCE)
-    ELSE()
-      SET(CMAKE_USE_SYSTEM_LIBRARY_${util} OFF)
-    ENDIF()
-  ENDFOREACH(util)
-  IF(CMAKE_BOOTSTRAP)
-    UNSET(CMAKE_USE_SYSTEM_LIBRARIES CACHE)
-  ENDIF()
+    else()
+      set(CMAKE_USE_SYSTEM_LIBRARY_${util} OFF)
+    endif()
+  endforeach()
+  if(CMAKE_BOOTSTRAP)
+    unset(CMAKE_USE_SYSTEM_LIBRARIES CACHE)
+  endif()
 
   # Optionally use system utility libraries.
-  OPTION(CMAKE_USE_SYSTEM_LIBARCHIVE "Use system-installed libarchive" "${CMAKE_USE_SYSTEM_LIBRARY_LIBARCHIVE}")
+  option(CMAKE_USE_SYSTEM_LIBARCHIVE "Use system-installed libarchive" "${CMAKE_USE_SYSTEM_LIBRARY_LIBARCHIVE}")
   CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_CURL "Use system-installed curl"
     "${CMAKE_USE_SYSTEM_LIBRARY_CURL}" "NOT CTEST_USE_XMLRPC" ON)
   CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_EXPAT "Use system-installed expat"
@@ -84,155 +84,154 @@ MACRO(CMAKE_HANDLE_SYSTEM_LIBRARIES)
     "${CMAKE_USE_SYSTEM_LIBRARY_BZIP2}" "NOT CMAKE_USE_SYSTEM_LIBARCHIVE" ON)
 
   # Mention to the user what system libraries are being used.
-  FOREACH(util ${UTILITIES})
-    IF(CMAKE_USE_SYSTEM_${util})
-      MESSAGE(STATUS "Using system-installed ${util}")
-    ENDIF(CMAKE_USE_SYSTEM_${util})
-  ENDFOREACH(util)
+  foreach(util ${UTILITIES})
+    if(CMAKE_USE_SYSTEM_${util})
+      message(STATUS "Using system-installed ${util}")
+    endif()
+  endforeach()
 
   # Inform utility library header wrappers whether to use system versions.
-  CONFIGURE_FILE(${CMake_SOURCE_DIR}/Utilities/cmThirdParty.h.in
+  configure_file(${CMake_SOURCE_DIR}/Utilities/cmThirdParty.h.in
     ${CMake_BINARY_DIR}/Utilities/cmThirdParty.h
     @ONLY)
 
-ENDMACRO(CMAKE_HANDLE_SYSTEM_LIBRARIES)
+endmacro()
 
 
 
 
-SET(CMAKE_BUILD_ON_VISUAL_STUDIO 0)
-IF(WIN32 AND NOT UNIX AND NOT BORLAND AND NOT MINGW )
-  SET(CMAKE_BUILD_ON_VISUAL_STUDIO 1)
-ENDIF(WIN32 AND NOT UNIX AND NOT BORLAND AND NOT MINGW )
+set(CMAKE_BUILD_ON_VISUAL_STUDIO 0)
+if(WIN32 AND NOT UNIX AND NOT BORLAND AND NOT MINGW )
+  set(CMAKE_BUILD_ON_VISUAL_STUDIO 1)
+endif()
 
 
 #-----------------------------------------------------------------------
 # a macro to determine the generator and ctest executable to use
 # for testing. Simply to improve readability of the main script.
 #-----------------------------------------------------------------------
-MACRO(CMAKE_SETUP_TESTING)
-  IF (NOT DART_ROOT)
-    SET(MAKEPROGRAM ${CMAKE_MAKE_PROGRAM})
-  ENDIF (NOT DART_ROOT)
-  
-  IF(BUILD_TESTING)
-    SET(CMAKE_TEST_GENERATOR "" CACHE STRING 
+macro(CMAKE_SETUP_TESTING)
+  if (NOT DART_ROOT)
+    set(MAKEPROGRAM ${CMAKE_MAKE_PROGRAM})
+  endif ()
+
+  if(BUILD_TESTING)
+    set(CMAKE_TEST_GENERATOR "" CACHE STRING
       "Generator used when running tests")
-    SET(CMAKE_TEST_MAKEPROGRAM "" CACHE FILEPATH 
+    set(CMAKE_TEST_MAKEPROGRAM "" CACHE FILEPATH
       "Generator used when running tests")
-    IF(NOT CMAKE_TEST_GENERATOR)
-      SET(CMAKE_TEST_GENERATOR "${CMAKE_GENERATOR}")
-      SET(CMAKE_TEST_MAKEPROGRAM "${MAKEPROGRAM}")
-    ELSE(NOT CMAKE_TEST_GENERATOR)
-      SET(CMAKE_TEST_DIFFERENT_GENERATOR TRUE)
-    ENDIF(NOT CMAKE_TEST_GENERATOR)
-    
+    if(NOT CMAKE_TEST_GENERATOR)
+      set(CMAKE_TEST_GENERATOR "${CMAKE_GENERATOR}")
+      set(CMAKE_TEST_MAKEPROGRAM "${MAKEPROGRAM}")
+    else()
+      set(CMAKE_TEST_DIFFERENT_GENERATOR TRUE)
+    endif()
+
     # Are we testing with the MSVC compiler?
-    SET(CMAKE_TEST_MSVC 0)
-    IF(MSVC AND NOT CMAKE_TEST_DIFFERENT_GENERATOR)
-      SET(CMAKE_TEST_MSVC 1)
-    ELSE(MSVC AND NOT CMAKE_TEST_DIFFERENT_GENERATOR)
-      IF("${CMAKE_TEST_GENERATOR}" MATCHES "NMake" OR
+    set(CMAKE_TEST_MSVC 0)
+    if(MSVC AND NOT CMAKE_TEST_DIFFERENT_GENERATOR)
+      set(CMAKE_TEST_MSVC 1)
+    else()
+      if("${CMAKE_TEST_GENERATOR}" MATCHES "NMake" OR
           "${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio")
-        SET(CMAKE_TEST_MSVC 1)
-      ENDIF("${CMAKE_TEST_GENERATOR}" MATCHES "NMake" OR
-        "${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio")
-    ENDIF(MSVC AND NOT CMAKE_TEST_DIFFERENT_GENERATOR)
-    
-    SET(CMAKE_TEST_SYSTEM_LIBRARIES 0)
-    FOREACH(util CURL EXPAT XMLRPC ZLIB)
-      IF(CMAKE_USE_SYSTEM_${util})
-        SET(CMAKE_TEST_SYSTEM_LIBRARIES 1)
-      ENDIF(CMAKE_USE_SYSTEM_${util})
-    ENDFOREACH(util)
-    
+        set(CMAKE_TEST_MSVC 1)
+      endif()
+    endif()
+
+    set(CMAKE_TEST_SYSTEM_LIBRARIES 0)
+    foreach(util CURL EXPAT XMLRPC ZLIB)
+      if(CMAKE_USE_SYSTEM_${util})
+        set(CMAKE_TEST_SYSTEM_LIBRARIES 1)
+      endif()
+    endforeach()
+
     # This variable is set by cmake, however to
     # test cmake we want to make sure that
     # the ctest from this cmake is used for testing
     # and not the ctest from the cmake building and testing
     # cmake.
-    SET(CMAKE_CTEST_COMMAND "${CMake_BIN_DIR}/ctest")
-    SET(CMAKE_CMAKE_COMMAND "${CMake_BIN_DIR}/cmake")
-    SET(CMAKE_CPACK_COMMAND "${CMake_BIN_DIR}/cpack")
-  ENDIF(BUILD_TESTING)
+    set(CMAKE_CTEST_COMMAND "${CMake_BIN_DIR}/ctest")
+    set(CMAKE_CMAKE_COMMAND "${CMake_BIN_DIR}/cmake")
+    set(CMAKE_CPACK_COMMAND "${CMake_BIN_DIR}/cpack")
+  endif()
 
   # configure some files for testing
-  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/Templates/CTestScript.cmake.in"
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/Templates/CTestScript.cmake.in"
     "${CMAKE_CURRENT_BINARY_DIR}/CTestScript.cmake"
     @ONLY)
-  CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/.NoDartCoverage
+  configure_file(${CMake_SOURCE_DIR}/Tests/.NoDartCoverage
     ${CMake_BINARY_DIR}/Tests/.NoDartCoverage)
-  CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/.NoDartCoverage
+  configure_file(${CMake_SOURCE_DIR}/Tests/.NoDartCoverage
     ${CMake_BINARY_DIR}/Modules/.NoDartCoverage)
-  CONFIGURE_FILE(${CMake_SOURCE_DIR}/CTestCustom.cmake.in
+  configure_file(${CMake_SOURCE_DIR}/CTestCustom.cmake.in
     ${CMake_BINARY_DIR}/CTestCustom.cmake @ONLY)
-  CONFIGURE_FILE(${CMake_SOURCE_DIR}/CTestCustom.ctest.in
+  configure_file(${CMake_SOURCE_DIR}/CTestCustom.ctest.in
     ${CMake_BINARY_DIR}/CTestCustom.ctest @ONLY)
-  IF(BUILD_TESTING AND DART_ROOT)
-    CONFIGURE_FILE(${CMake_SOURCE_DIR}/CMakeLogo.gif 
+  if(BUILD_TESTING AND DART_ROOT)
+    configure_file(${CMake_SOURCE_DIR}/CMakeLogo.gif
       ${CMake_BINARY_DIR}/Testing/HTML/TestingResults/Icons/Logo.gif COPYONLY)
-  ENDIF(BUILD_TESTING AND DART_ROOT)
-  MARK_AS_ADVANCED(DART_ROOT)
-  MARK_AS_ADVANCED(CURL_TESTING)
-ENDMACRO(CMAKE_SETUP_TESTING)
+  endif()
+  mark_as_advanced(DART_ROOT)
+  mark_as_advanced(CURL_TESTING)
+endmacro()
 
 
 # Provide a way for Visual Studio Express users to turn OFF the new FOLDER
 # organization feature. Default to ON for non-Express users. Express users must
 # explicitly turn off this option to build CMake in the Express IDE...
 #
-OPTION(CMAKE_USE_FOLDERS "Enable folder grouping of projects in IDEs." ON)
-MARK_AS_ADVANCED(CMAKE_USE_FOLDERS)
+option(CMAKE_USE_FOLDERS "Enable folder grouping of projects in IDEs." ON)
+mark_as_advanced(CMAKE_USE_FOLDERS)
 
 
 #-----------------------------------------------------------------------
 # a macro that only sets the FOLDER target property if it's
 # "appropriate"
 #-----------------------------------------------------------------------
-MACRO(CMAKE_SET_TARGET_FOLDER tgt folder)
-  IF(CMAKE_USE_FOLDERS)
-    SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS ON)
+macro(CMAKE_SET_TARGET_FOLDER tgt folder)
+  if(CMAKE_USE_FOLDERS)
+    set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
     # Really, I just want this to be an "if(TARGET ${tgt})" ...
     # but I'm not sure that our min req'd., CMake 2.4.5 can handle
     # that... so I'm just activating this for now, with a version
     # compare, and only for MSVC builds.
-    IF(MSVC)
-      IF(NOT ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} LESS 2.8)
-        SET_PROPERTY(TARGET "${tgt}" PROPERTY FOLDER "${folder}")
-      ENDIF()
-    ENDIF()
-  ELSE()
-    SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS OFF)
-  ENDIF()
-ENDMACRO(CMAKE_SET_TARGET_FOLDER)
+    if(MSVC)
+      if(NOT ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} LESS 2.8)
+        set_property(TARGET "${tgt}" PROPERTY FOLDER "${folder}")
+      endif()
+    endif()
+  else()
+    set_property(GLOBAL PROPERTY USE_FOLDERS OFF)
+  endif()
+endmacro()
 
 
 #-----------------------------------------------------------------------
 # a macro to build the utilities used by CMake
 # Simply to improve readability of the main script.
 #-----------------------------------------------------------------------
-MACRO (CMAKE_BUILD_UTILITIES)
+macro (CMAKE_BUILD_UTILITIES)
   #---------------------------------------------------------------------
   # Create the KWIML library for CMake.
-  SET(KWIML cmIML)
-  SET(KWIML_HEADER_ROOT ${CMake_BINARY_DIR}/Utilities)
-  ADD_SUBDIRECTORY(Utilities/KWIML)
+  set(KWIML cmIML)
+  set(KWIML_HEADER_ROOT ${CMake_BINARY_DIR}/Utilities)
+  add_subdirectory(Utilities/KWIML)
 
   #---------------------------------------------------------------------
   # Create the kwsys library for CMake.
-  SET(KWSYS_NAMESPACE cmsys)
-  SET(KWSYS_USE_SystemTools 1)
-  SET(KWSYS_USE_Directory 1)
-  SET(KWSYS_USE_RegularExpression 1)
-  SET(KWSYS_USE_Base64 1)
-  SET(KWSYS_USE_MD5 1)
-  SET(KWSYS_USE_Process 1)
-  SET(KWSYS_USE_CommandLineArguments 1)
-  SET(KWSYS_HEADER_ROOT ${CMake_BINARY_DIR}/Source)
-  SET(KWSYS_INSTALL_DOC_DIR "${CMake_DOC_DEST}")
-  ADD_SUBDIRECTORY(Source/kwsys)
-  SET(kwsys_folder "Utilities/KWSys")
+  set(KWSYS_NAMESPACE cmsys)
+  set(KWSYS_USE_SystemTools 1)
+  set(KWSYS_USE_Directory 1)
+  set(KWSYS_USE_RegularExpression 1)
+  set(KWSYS_USE_Base64 1)
+  set(KWSYS_USE_MD5 1)
+  set(KWSYS_USE_Process 1)
+  set(KWSYS_USE_CommandLineArguments 1)
+  set(KWSYS_HEADER_ROOT ${CMake_BINARY_DIR}/Source)
+  set(KWSYS_INSTALL_DOC_DIR "${CMake_DOC_DEST}")
+  add_subdirectory(Source/kwsys)
+  set(kwsys_folder "Utilities/KWSys")
   CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE} "${kwsys_folder}")
   CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}_c "${kwsys_folder}")
   CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}EncodeExecutable "${kwsys_folder}")
@@ -249,248 +248,248 @@ MACRO (CMAKE_BUILD_UTILITIES)
   # Setup third-party libraries.
   # Everything in the tree should be able to include files from the
   # Utilities directory.
-  INCLUDE_DIRECTORIES(
+  include_directories(
     ${CMake_BINARY_DIR}/Utilities
     ${CMake_SOURCE_DIR}/Utilities
     )
-  
+
   # check for the use of system libraries versus builtin ones
   # (a macro defined in this file)
   CMAKE_HANDLE_SYSTEM_LIBRARIES()
-  
+
   #---------------------------------------------------------------------
   # Build zlib library for Curl, CMake, and CTest.
-  SET(CMAKE_ZLIB_HEADER "cm_zlib.h")
-  IF(CMAKE_USE_SYSTEM_ZLIB)
-    FIND_PACKAGE(ZLIB)
-    IF(NOT ZLIB_FOUND)
-      MESSAGE(FATAL_ERROR 
+  set(CMAKE_ZLIB_HEADER "cm_zlib.h")
+  if(CMAKE_USE_SYSTEM_ZLIB)
+    find_package(ZLIB)
+    if(NOT ZLIB_FOUND)
+      message(FATAL_ERROR
         "CMAKE_USE_SYSTEM_ZLIB is ON but a zlib is not found!")
-    ENDIF(NOT ZLIB_FOUND)
-    SET(CMAKE_ZLIB_INCLUDES ${ZLIB_INCLUDE_DIR})
-    SET(CMAKE_ZLIB_LIBRARIES ${ZLIB_LIBRARIES})
-  ELSE(CMAKE_USE_SYSTEM_ZLIB)
-    SET(CMAKE_ZLIB_INCLUDES ${CMake_SOURCE_DIR}/Utilities)
-    SET(CMAKE_ZLIB_LIBRARIES cmzlib)
-    ADD_SUBDIRECTORY(Utilities/cmzlib)
+    endif()
+    set(CMAKE_ZLIB_INCLUDES ${ZLIB_INCLUDE_DIR})
+    set(CMAKE_ZLIB_LIBRARIES ${ZLIB_LIBRARIES})
+  else()
+    set(CMAKE_ZLIB_INCLUDES ${CMake_SOURCE_DIR}/Utilities)
+    set(CMAKE_ZLIB_LIBRARIES cmzlib)
+    add_subdirectory(Utilities/cmzlib)
     CMAKE_SET_TARGET_FOLDER(cmzlib "Utilities/3rdParty")
-  ENDIF(CMAKE_USE_SYSTEM_ZLIB)
-  
+  endif()
+
   #---------------------------------------------------------------------
   # Build Curl library for CTest.
-  IF(CMAKE_USE_SYSTEM_CURL)
-    FIND_PACKAGE(CURL)
-    IF(NOT CURL_FOUND)
-      MESSAGE(FATAL_ERROR 
+  if(CMAKE_USE_SYSTEM_CURL)
+    find_package(CURL)
+    if(NOT CURL_FOUND)
+      message(FATAL_ERROR
         "CMAKE_USE_SYSTEM_CURL is ON but a curl is not found!")
-    ENDIF(NOT CURL_FOUND)
-    SET(CMAKE_CURL_INCLUDES ${CURL_INCLUDE_DIRS})
-    SET(CMAKE_CURL_LIBRARIES ${CURL_LIBRARIES})
-  ELSE(CMAKE_USE_SYSTEM_CURL)
-    SET(CURL_SPECIAL_ZLIB_H ${CMAKE_ZLIB_HEADER})
-    SET(CURL_SPECIAL_LIBZ_INCLUDES ${CMAKE_ZLIB_INCLUDES})
-    SET(CURL_SPECIAL_LIBZ ${CMAKE_ZLIB_LIBRARIES})
-    OPTION(CMAKE_BUILD_CURL_SHARED "Should curl be built shared" FALSE)
-    IF(NOT CMAKE_BUILD_CURL_SHARED)
-      ADD_DEFINITIONS(-DCURL_STATICLIB)
-    ENDIF(NOT CMAKE_BUILD_CURL_SHARED)
-    SET(CMAKE_CURL_INCLUDES)
-    SET(CMAKE_CURL_LIBRARIES cmcurl)
-    IF(CMAKE_TESTS_CDASH_SERVER)
-      SET(CMAKE_CURL_TEST_URL "${CMAKE_TESTS_CDASH_SERVER}/user.php")
-    ENDIF(CMAKE_TESTS_CDASH_SERVER)
-    ADD_SUBDIRECTORY(Utilities/cmcurl)
+    endif()
+    set(CMAKE_CURL_INCLUDES ${CURL_INCLUDE_DIRS})
+    set(CMAKE_CURL_LIBRARIES ${CURL_LIBRARIES})
+  else()
+    set(CURL_SPECIAL_ZLIB_H ${CMAKE_ZLIB_HEADER})
+    set(CURL_SPECIAL_LIBZ_INCLUDES ${CMAKE_ZLIB_INCLUDES})
+    set(CURL_SPECIAL_LIBZ ${CMAKE_ZLIB_LIBRARIES})
+    option(CMAKE_BUILD_CURL_SHARED "Should curl be built shared" FALSE)
+    if(NOT CMAKE_BUILD_CURL_SHARED)
+      add_definitions(-DCURL_STATICLIB)
+    endif()
+    set(CMAKE_CURL_INCLUDES)
+    set(CMAKE_CURL_LIBRARIES cmcurl)
+    if(CMAKE_TESTS_CDASH_SERVER)
+      set(CMAKE_CURL_TEST_URL "${CMAKE_TESTS_CDASH_SERVER}/user.php")
+    endif()
+    add_subdirectory(Utilities/cmcurl)
     CMAKE_SET_TARGET_FOLDER(cmcurl "Utilities/3rdParty")
     CMAKE_SET_TARGET_FOLDER(LIBCURL "Utilities/3rdParty")
-  ENDIF(CMAKE_USE_SYSTEM_CURL)
+  endif()
 
   #---------------------------------------------------------------------
   # Build Compress library for CTest.
-  SET(CMAKE_COMPRESS_INCLUDES 
+  set(CMAKE_COMPRESS_INCLUDES
     "${CMAKE_CURRENT_BINARY_DIR}/Utilities/cmcompress")
-  SET(CMAKE_COMPRESS_LIBRARIES "cmcompress")
-  ADD_SUBDIRECTORY(Utilities/cmcompress)
+  set(CMAKE_COMPRESS_LIBRARIES "cmcompress")
+  add_subdirectory(Utilities/cmcompress)
   CMAKE_SET_TARGET_FOLDER(cmcompress "Utilities/3rdParty")
-  IF(CMAKE_USE_SYSTEM_BZIP2)
-    FIND_PACKAGE(BZip2)
-  ELSE()
-    SET(BZIP2_INCLUDE_DIR 
+  if(CMAKE_USE_SYSTEM_BZIP2)
+    find_package(BZip2)
+  else()
+    set(BZIP2_INCLUDE_DIR
       "${CMAKE_CURRENT_SOURCE_DIR}/Utilities/cmbzip2")
-    SET(BZIP2_LIBRARIES cmbzip2)
-    ADD_SUBDIRECTORY(Utilities/cmbzip2)
+    set(BZIP2_LIBRARIES cmbzip2)
+    add_subdirectory(Utilities/cmbzip2)
     CMAKE_SET_TARGET_FOLDER(cmbzip2 "Utilities/3rdParty")
-  ENDIF()
+  endif()
 
   #---------------------------------------------------------------------
   # Build or use system libarchive for CMake and CTest.
-  IF(CMAKE_USE_SYSTEM_LIBARCHIVE)
-    IF(EXISTS ${CMAKE_ROOT}/Modules/FindLibArchive.cmake) # added in 2.8.3
-      FIND_PACKAGE(LibArchive)
-    ELSE()
-      INCLUDE(${CMake_SOURCE_DIR}/Modules/FindLibArchive.cmake)
-    ENDIF()
-    IF(NOT LibArchive_FOUND)
-      MESSAGE(FATAL_ERROR "CMAKE_USE_SYSTEM_LIBARCHIVE is ON but LibArchive is not found!")
-    ENDIF()
-    SET(CMAKE_TAR_INCLUDES ${LibArchive_INCLUDE_DIRS})
-    SET(CMAKE_TAR_LIBRARIES ${LibArchive_LIBRARIES})
-  ELSE(CMAKE_USE_SYSTEM_LIBARCHIVE)
-    SET(ZLIB_INCLUDE_DIR ${CMAKE_ZLIB_INCLUDES})
-    SET(ZLIB_LIBRARY ${CMAKE_ZLIB_LIBRARIES})
-    ADD_DEFINITIONS(-DLIBARCHIVE_STATIC)
-    SET(ENABLE_NETTLE OFF CACHE INTERNAL "Enable use of Nettle")
-    SET(ENABLE_OPENSSL ${CMAKE_USE_OPENSSL} CACHE INTERNAL "Enable use of OpenSSL")
-    SET(ENABLE_XATTR OFF CACHE INTERNAL "Enable extended attribute support")
-    SET(ENABLE_ACL OFF CACHE INTERNAL "Enable ACL support")
-    SET(ENABLE_ICONV OFF CACHE INTERNAL "Enable iconv support")
-    ADD_SUBDIRECTORY(Utilities/cmlibarchive)
+  if(CMAKE_USE_SYSTEM_LIBARCHIVE)
+    if(EXISTS ${CMAKE_ROOT}/Modules/FindLibArchive.cmake) # added in 2.8.3
+      find_package(LibArchive)
+    else()
+      include(${CMake_SOURCE_DIR}/Modules/FindLibArchive.cmake)
+    endif()
+    if(NOT LibArchive_FOUND)
+      message(FATAL_ERROR "CMAKE_USE_SYSTEM_LIBARCHIVE is ON but LibArchive is not found!")
+    endif()
+    set(CMAKE_TAR_INCLUDES ${LibArchive_INCLUDE_DIRS})
+    set(CMAKE_TAR_LIBRARIES ${LibArchive_LIBRARIES})
+  else()
+    set(ZLIB_INCLUDE_DIR ${CMAKE_ZLIB_INCLUDES})
+    set(ZLIB_LIBRARY ${CMAKE_ZLIB_LIBRARIES})
+    add_definitions(-DLIBARCHIVE_STATIC)
+    set(ENABLE_NETTLE OFF CACHE INTERNAL "Enable use of Nettle")
+    set(ENABLE_OPENSSL ${CMAKE_USE_OPENSSL} CACHE INTERNAL "Enable use of OpenSSL")
+    set(ENABLE_XATTR OFF CACHE INTERNAL "Enable extended attribute support")
+    set(ENABLE_ACL OFF CACHE INTERNAL "Enable ACL support")
+    set(ENABLE_ICONV OFF CACHE INTERNAL "Enable iconv support")
+    add_subdirectory(Utilities/cmlibarchive)
     CMAKE_SET_TARGET_FOLDER(cmlibarchive "Utilities/3rdParty")
-    SET(CMAKE_TAR_LIBRARIES cmlibarchive ${BZIP2_LIBRARIES})
-  ENDIF(CMAKE_USE_SYSTEM_LIBARCHIVE)
+    set(CMAKE_TAR_LIBRARIES cmlibarchive ${BZIP2_LIBRARIES})
+  endif()
 
   #---------------------------------------------------------------------
   # Build expat library for CMake and CTest.
-  IF(CMAKE_USE_SYSTEM_EXPAT)
-    FIND_PACKAGE(EXPAT)
-    IF(NOT EXPAT_FOUND)
-      MESSAGE(FATAL_ERROR
+  if(CMAKE_USE_SYSTEM_EXPAT)
+    find_package(EXPAT)
+    if(NOT EXPAT_FOUND)
+      message(FATAL_ERROR
         "CMAKE_USE_SYSTEM_EXPAT is ON but a expat is not found!")
-    ENDIF(NOT EXPAT_FOUND)
-    SET(CMAKE_EXPAT_INCLUDES ${EXPAT_INCLUDE_DIRS})
-    SET(CMAKE_EXPAT_LIBRARIES ${EXPAT_LIBRARIES})
-  ELSE(CMAKE_USE_SYSTEM_EXPAT)
-    SET(CMAKE_EXPAT_INCLUDES)
-    SET(CMAKE_EXPAT_LIBRARIES cmexpat)
-    ADD_SUBDIRECTORY(Utilities/cmexpat)
+    endif()
+    set(CMAKE_EXPAT_INCLUDES ${EXPAT_INCLUDE_DIRS})
+    set(CMAKE_EXPAT_LIBRARIES ${EXPAT_LIBRARIES})
+  else()
+    set(CMAKE_EXPAT_INCLUDES)
+    set(CMAKE_EXPAT_LIBRARIES cmexpat)
+    add_subdirectory(Utilities/cmexpat)
     CMAKE_SET_TARGET_FOLDER(cmexpat "Utilities/3rdParty")
-  ENDIF(CMAKE_USE_SYSTEM_EXPAT)
-  
+  endif()
+
   #---------------------------------------------------------------------
   # Build XMLRPC library for CMake and CTest.
-  IF(CTEST_USE_XMLRPC)
-    FIND_PACKAGE(XMLRPC QUIET REQUIRED libwww-client)
-    IF(NOT XMLRPC_FOUND)
-      MESSAGE(FATAL_ERROR
+  if(CTEST_USE_XMLRPC)
+    find_package(XMLRPC QUIET REQUIRED libwww-client)
+    if(NOT XMLRPC_FOUND)
+      message(FATAL_ERROR
         "CTEST_USE_XMLRPC is ON but xmlrpc is not found!")
-    ENDIF(NOT XMLRPC_FOUND)
-    SET(CMAKE_XMLRPC_INCLUDES ${XMLRPC_INCLUDE_DIRS})
-    SET(CMAKE_XMLRPC_LIBRARIES ${XMLRPC_LIBRARIES})
-  ENDIF(CTEST_USE_XMLRPC)
-  
+    endif()
+    set(CMAKE_XMLRPC_INCLUDES ${XMLRPC_INCLUDE_DIRS})
+    set(CMAKE_XMLRPC_LIBRARIES ${XMLRPC_LIBRARIES})
+  endif()
+
   #---------------------------------------------------------------------
   # Use curses?
-  IF (UNIX)
+  if (UNIX)
     # there is a bug in the Syllable libraries which makes linking ccmake fail, Alex
-    IF(NOT "${CMAKE_SYSTEM_NAME}" MATCHES syllable)
-      SET(CURSES_NEED_NCURSES TRUE)
-      FIND_PACKAGE(Curses QUIET)
-      IF (CURSES_LIBRARY)
-        OPTION(BUILD_CursesDialog "Build the CMake Curses Dialog ccmake" ON)
-      ELSE (CURSES_LIBRARY)
-        MESSAGE("Curses libraries were not found. Curses GUI for CMake will not be built.")
-        SET(BUILD_CursesDialog 0)
-      ENDIF (CURSES_LIBRARY)
-    ELSE(NOT "${CMAKE_SYSTEM_NAME}" MATCHES syllable)
-      SET(BUILD_CursesDialog 0)
-    ENDIF(NOT "${CMAKE_SYSTEM_NAME}" MATCHES syllable)
-  ELSE (UNIX)
-    SET(BUILD_CursesDialog 0)
-  ENDIF (UNIX)
-  IF(BUILD_CursesDialog)
-    ADD_SUBDIRECTORY(Source/CursesDialog/form)
-  ENDIF(BUILD_CursesDialog)
-ENDMACRO (CMAKE_BUILD_UTILITIES)
+    if(NOT "${CMAKE_SYSTEM_NAME}" MATCHES syllable)
+      set(CURSES_NEED_NCURSES TRUE)
+      find_package(Curses QUIET)
+      if (CURSES_LIBRARY)
+        option(BUILD_CursesDialog "Build the CMake Curses Dialog ccmake" ON)
+      else ()
+        message("Curses libraries were not found. Curses GUI for CMake will not be built.")
+        set(BUILD_CursesDialog 0)
+      endif ()
+    else()
+      set(BUILD_CursesDialog 0)
+    endif()
+  else ()
+    set(BUILD_CursesDialog 0)
+  endif ()
+  if(BUILD_CursesDialog)
+    add_subdirectory(Source/CursesDialog/form)
+  endif()
+endmacro ()
 
 #-----------------------------------------------------------------------
-IF(CMAKE_CXX_PLATFORM_ID MATCHES "OpenBSD")
-  EXECUTE_PROCESS(COMMAND ${CMAKE_CXX_COMPILER}
+if(CMAKE_CXX_PLATFORM_ID MATCHES "OpenBSD")
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER}
     ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
     OUTPUT_VARIABLE _GXX_VERSION
   )
-  STRING(REGEX REPLACE "([0-9])\\.([0-9])(\\.[0-9])?" "\\1\\2"
+  string(REGEX REPLACE "([0-9])\\.([0-9])(\\.[0-9])?" "\\1\\2"
     _GXX_VERSION_SHORT ${_GXX_VERSION})
-  IF(_GXX_VERSION_SHORT EQUAL 33)
-    MESSAGE(FATAL_ERROR
+  if(_GXX_VERSION_SHORT EQUAL 33)
+    message(FATAL_ERROR
       "GXX 3.3 on OpenBSD is known to cause CPack to Crash.\n"
       "Please use GXX 4.2 or greater to build CMake on OpenBSD\n"
       "${CMAKE_CXX_COMPILER} version is: ${_GXX_VERSION}")
-  ENDIF()
-ENDIF()
+  endif()
+endif()
 
 #-----------------------------------------------------------------------
 # The main section of the CMakeLists file
 #
 #-----------------------------------------------------------------------
-INCLUDE(Source/CMakeVersion.cmake)
+include(Source/CMakeVersion.cmake)
 # Releases define a small tweak level.
-IF("${CMake_VERSION_TWEAK}" VERSION_LESS 20000000)
-  SET(CMake_VERSION_IS_RELEASE 1)
-  SET(CMake_VERSION_SOURCE "")
-ELSE()
-  SET(CMake_VERSION_IS_RELEASE 0)
-  INCLUDE(${CMake_SOURCE_DIR}/Source/CMakeVersionSource.cmake)
-ENDIF()
+if("${CMake_VERSION_TWEAK}" VERSION_LESS 20000000)
+  set(CMake_VERSION_IS_RELEASE 1)
+  set(CMake_VERSION_SOURCE "")
+else()
+  set(CMake_VERSION_IS_RELEASE 0)
+  include(${CMake_SOURCE_DIR}/Source/CMakeVersionSource.cmake)
+endif()
 
 # Compute the full version string.
-SET(CMake_VERSION ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH})
-IF(${CMake_VERSION_TWEAK} GREATER 0)
-  SET(CMake_VERSION ${CMake_VERSION}.${CMake_VERSION_TWEAK})
-ENDIF()
-IF(CMake_VERSION_RC)
-  SET(CMake_VERSION ${CMake_VERSION}-rc${CMake_VERSION_RC})
-ENDIF()
-IF(CMake_VERSION_SOURCE)
-  SET(CMake_VERSION ${CMake_VERSION}-${CMake_VERSION_SOURCE})
-ENDIF()
+set(CMake_VERSION ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH})
+if(${CMake_VERSION_TWEAK} GREATER 0)
+  set(CMake_VERSION ${CMake_VERSION}.${CMake_VERSION_TWEAK})
+endif()
+if(CMake_VERSION_RC)
+  set(CMake_VERSION ${CMake_VERSION}-rc${CMake_VERSION_RC})
+endif()
+if(CMake_VERSION_SOURCE)
+  set(CMake_VERSION ${CMake_VERSION}-${CMake_VERSION_SOURCE})
+endif()
 
 # Include the standard Dart testing module
-ENABLE_TESTING()
-INCLUDE (${CMAKE_ROOT}/Modules/Dart.cmake)
+enable_testing()
+include (${CMAKE_ROOT}/Modules/Dart.cmake)
 
 # Set up test-time configuration.
-SET_DIRECTORY_PROPERTIES(PROPERTIES
+set_directory_properties(PROPERTIES
   TEST_INCLUDE_FILE "${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake")
 
 # where to write the resulting executables and libraries
-SET(BUILD_SHARED_LIBS OFF)
-SET(EXECUTABLE_OUTPUT_PATH "" CACHE INTERNAL "No configurable exe dir.")
-SET(LIBRARY_OUTPUT_PATH "" CACHE INTERNAL 
+set(BUILD_SHARED_LIBS OFF)
+set(EXECUTABLE_OUTPUT_PATH "" CACHE INTERNAL "No configurable exe dir.")
+set(LIBRARY_OUTPUT_PATH "" CACHE INTERNAL
   "Where to put the libraries for CMake")
 
 # The CMake executables usually do not need any rpath to run in the build or
 # install tree.
-SET(CMAKE_SKIP_RPATH ON CACHE INTERNAL "CMake does not need RPATHs.")
+set(CMAKE_SKIP_RPATH ON CACHE INTERNAL "CMake does not need RPATHs.")
 
-SET(CMAKE_DATA_DIR "/share/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}" CACHE STRING
+set(CMAKE_DATA_DIR "/share/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}" CACHE STRING
   "Install location for data (relative to prefix).")
-SET(CMAKE_DOC_DIR "/doc/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}" CACHE STRING
+set(CMAKE_DOC_DIR "/doc/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}" CACHE STRING
   "Install location for documentation (relative to prefix).")
-SET(CMAKE_MAN_DIR "/man" CACHE STRING
+set(CMAKE_MAN_DIR "/man" CACHE STRING
   "Install location for man pages (relative to prefix).")
-MARK_AS_ADVANCED(CMAKE_DATA_DIR CMAKE_DOC_DIR CMAKE_MAN_DIR)
-IF(CYGWIN AND EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
+mark_as_advanced(CMAKE_DATA_DIR CMAKE_DOC_DIR CMAKE_MAN_DIR)
+if(CYGWIN AND EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
   # Force doc, data and man dirs to conform to cygwin layout.
-  SET(CMAKE_DOC_DIR  "/share/doc/cmake-${CMake_VERSION}")
-  SET(CMAKE_DATA_DIR "/share/cmake-${CMake_VERSION}")
-  SET(CMAKE_MAN_DIR  "/share/man")
+  set(CMAKE_DOC_DIR  "/share/doc/cmake-${CMake_VERSION}")
+  set(CMAKE_DATA_DIR "/share/cmake-${CMake_VERSION}")
+  set(CMAKE_MAN_DIR  "/share/man")
   # let the user know we just forced these values
-  MESSAGE(STATUS "Setup for Cygwin packaging")
-  MESSAGE(STATUS "Override cache CMAKE_DOC_DIR = ${CMAKE_DOC_DIR}")
-  MESSAGE(STATUS "Override cache CMAKE_DATA_DIR = ${CMAKE_DATA_DIR}")
-  MESSAGE(STATUS "Override cache CMAKE_MAN_DIR = ${CMAKE_MAN_DIR}")
-ENDIF()
-STRING(REGEX REPLACE "^/" "" CMake_DATA_DEST "${CMAKE_DATA_DIR}")
-STRING(REGEX REPLACE "^/" "" CMake_DOC_DEST "${CMAKE_DOC_DIR}")
-
-IF(BUILD_TESTING)
-  INCLUDE(${CMake_SOURCE_DIR}/Tests/CMakeInstall.cmake)
-ENDIF()
+  message(STATUS "Setup for Cygwin packaging")
+  message(STATUS "Override cache CMAKE_DOC_DIR = ${CMAKE_DOC_DIR}")
+  message(STATUS "Override cache CMAKE_DATA_DIR = ${CMAKE_DATA_DIR}")
+  message(STATUS "Override cache CMAKE_MAN_DIR = ${CMAKE_MAN_DIR}")
+endif()
+string(REGEX REPLACE "^/" "" CMake_DATA_DEST "${CMAKE_DATA_DIR}")
+string(REGEX REPLACE "^/" "" CMake_DOC_DEST "${CMAKE_DOC_DIR}")
+
+if(BUILD_TESTING)
+  include(${CMake_SOURCE_DIR}/Tests/CMakeInstall.cmake)
+endif()
 
 # include special compile flags for some compilers
-INCLUDE(CompileFlags.cmake)
+include(CompileFlags.cmake)
 
 # no clue why we are testing for this here
-INCLUDE(CheckSymbolExists)
+include(CheckSymbolExists)
 CHECK_SYMBOL_EXISTS(unsetenv "stdlib.h" HAVE_UNSETENV)
 CHECK_SYMBOL_EXISTS(environ "stdlib.h" HAVE_ENVIRON_NOT_REQUIRE_PROTOTYPE)
 
@@ -507,91 +506,90 @@ CHECK_SYMBOL_EXISTS(environ "stdlib.h" HAVE_ENVIRON_NOT_REQUIRE_PROTOTYPE)
 # to a cdash4simpletest database. In these cases, the CDash dashboards
 # should be run first.
 #
-IF("x${CMAKE_TESTS_CDASH_SERVER}" STREQUAL "x")
-  SET(CMAKE_TESTS_CDASH_SERVER "http://www.cdash.org/CDash")
-ENDIF("x${CMAKE_TESTS_CDASH_SERVER}" STREQUAL "x")
+if("x${CMAKE_TESTS_CDASH_SERVER}" STREQUAL "x")
+  set(CMAKE_TESTS_CDASH_SERVER "http://www.cdash.org/CDash")
+endif()
 
-# build the utilities (a macro defined in this file) 
+# build the utilities (a macro defined in this file)
 CMAKE_BUILD_UTILITIES()
 
 # On NetBSD ncurses is required, since curses doesn't have the wsyncup()
 # function. ncurses is installed via pkgsrc, so the library is in /usr/pkg/lib,
-# which isn't in the default linker search path. So without RPATH ccmake 
+# which isn't in the default linker search path. So without RPATH ccmake
 # doesn't run and the build doesn't succeed since ccmake is executed for
 # generating the documentation.
-IF(BUILD_CursesDialog)
-  GET_FILENAME_COMPONENT(_CURSES_DIR "${CURSES_LIBRARY}" PATH)
-  SET(CURSES_NEED_RPATH FALSE)
-  IF(NOT "${_CURSES_DIR}" STREQUAL "/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/lib64" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib64")
-    SET(CURSES_NEED_RPATH TRUE)
-  ENDIF(NOT "${_CURSES_DIR}" STREQUAL "/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/lib64" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib64")
-ENDIF(BUILD_CursesDialog)
-
-IF(BUILD_QtDialog)
-  IF(APPLE)
-    SET(CMAKE_BUNDLE_NAME
+if(BUILD_CursesDialog)
+  get_filename_component(_CURSES_DIR "${CURSES_LIBRARY}" PATH)
+  set(CURSES_NEED_RPATH FALSE)
+  if(NOT "${_CURSES_DIR}" STREQUAL "/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/lib64" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib64")
+    set(CURSES_NEED_RPATH TRUE)
+  endif()
+endif()
+
+if(BUILD_QtDialog)
+  if(APPLE)
+    set(CMAKE_BUNDLE_NAME
       "CMake ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}-${CMake_VERSION_PATCH}")
-    SET(CMAKE_BUNDLE_LOCATION "${CMAKE_INSTALL_PREFIX}")
+    set(CMAKE_BUNDLE_LOCATION "${CMAKE_INSTALL_PREFIX}")
     # make sure CMAKE_INSTALL_PREFIX ends in /
-    STRING(LENGTH "${CMAKE_INSTALL_PREFIX}" LEN)
-    MATH(EXPR LEN "${LEN} -1" )
-    STRING(SUBSTRING "${CMAKE_INSTALL_PREFIX}" ${LEN} 1 ENDCH)
-    IF(NOT "${ENDCH}" STREQUAL "/")
-      SET(CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/")
-    ENDIF(NOT "${ENDCH}" STREQUAL "/")
-    SET(CMAKE_INSTALL_PREFIX 
+    string(LENGTH "${CMAKE_INSTALL_PREFIX}" LEN)
+    math(EXPR LEN "${LEN} -1" )
+    string(SUBSTRING "${CMAKE_INSTALL_PREFIX}" ${LEN} 1 ENDCH)
+    if(NOT "${ENDCH}" STREQUAL "/")
+      set(CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/")
+    endif()
+    set(CMAKE_INSTALL_PREFIX
       "${CMAKE_INSTALL_PREFIX}${CMAKE_BUNDLE_NAME}.app/Contents")
-  ENDIF(APPLE)
-  
-  SET(QT_NEED_RPATH FALSE)
-  IF(NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib64" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib64")
-    SET(QT_NEED_RPATH TRUE)
-  ENDIF(NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib64" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib64")
-ENDIF(BUILD_QtDialog)
+  endif()
+
+  set(QT_NEED_RPATH FALSE)
+  if(NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib64" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib64")
+    set(QT_NEED_RPATH TRUE)
+  endif()
+endif()
 
 
 # The same might be true on other systems for other libraries.
-# Then only enable RPATH if we have are building at least with cmake 2.4, 
+# Then only enable RPATH if we have are building at least with cmake 2.4,
 # since this one has much better RPATH features than cmake 2.2.
 # The executables are then built with the RPATH for the libraries outside
 # the build tree, which is both the build and the install RPATH.
-IF (UNIX)
-  IF(   CMAKE_USE_SYSTEM_CURL   OR  CMAKE_USE_SYSTEM_ZLIB
+if (UNIX)
+  if(   CMAKE_USE_SYSTEM_CURL   OR  CMAKE_USE_SYSTEM_ZLIB
         OR  CMAKE_USE_SYSTEM_EXPAT  OR  CTEST_USE_XMLRPC  OR  CURSES_NEED_RPATH  OR  QT_NEED_RPATH)
-    SET(CMAKE_SKIP_RPATH OFF CACHE INTERNAL "CMake built with RPATH.")
-    SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
-    SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
-  ENDIF(CMAKE_USE_SYSTEM_CURL   OR  CMAKE_USE_SYSTEM_ZLIB
-        OR  CMAKE_USE_SYSTEM_EXPAT  OR  CTEST_USE_XMLRPC  OR  CURSES_NEED_RPATH  OR  QT_NEED_RPATH)
-ENDIF (UNIX)
+    set(CMAKE_SKIP_RPATH OFF CACHE INTERNAL "CMake built with RPATH.")
+    set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
+    set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+  endif()
+endif ()
 
 
 # add the uninstall support
-CONFIGURE_FILE(
+configure_file(
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
   "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
   @ONLY)
-ADD_CUSTOM_TARGET(uninstall
+add_custom_target(uninstall
   "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
 
-INCLUDE (CMakeCPack.cmake)
+include (CMakeCPack.cmake)
 
 # setup some Testing support (a macro defined in this file)
 CMAKE_SETUP_TESTING()
-CONFIGURE_FILE(
+configure_file(
   "${CMAKE_CURRENT_SOURCE_DIR}/DartLocal.conf.in"
   "${CMAKE_CURRENT_BINARY_DIR}/DartLocal.conf"
   COPYONLY)
 
-OPTION(CMAKE_STRICT   
+option(CMAKE_STRICT
   "Perform strict testing to record property and variable access. Can be used to report any undefined properties or variables" OFF)
-MARK_AS_ADVANCED(CMAKE_STRICT)
+mark_as_advanced(CMAKE_STRICT)
 
 
 # build the remaining subdirectories
-ADD_SUBDIRECTORY(Source)
-ADD_SUBDIRECTORY(Utilities)
-ADD_SUBDIRECTORY(Tests)
+add_subdirectory(Source)
+add_subdirectory(Utilities)
+add_subdirectory(Tests)
 
 if(BUILD_TESTING)
   CMAKE_SET_TARGET_FOLDER(CMakeLibTests "Tests")
@@ -600,14 +598,14 @@ CMAKE_SET_TARGET_FOLDER(cmw9xcom "Utilities/Win9xCompat")
 CMAKE_SET_TARGET_FOLDER(documentation "Documentation")
 
 # add a test
-ADD_TEST(SystemInformationNew "${CMAKE_CMAKE_COMMAND}" 
+add_test(SystemInformationNew "${CMAKE_CMAKE_COMMAND}"
   --system-information  -G "${CMAKE_TEST_GENERATOR}" )
 
 # Install license file as it requires.
-INSTALL(FILES Copyright.txt DESTINATION ${CMake_DOC_DEST})
+install(FILES Copyright.txt DESTINATION ${CMake_DOC_DEST})
 
 # Install script directories.
-INSTALL(
+install(
   DIRECTORY Modules Templates
   DESTINATION "${CMake_DATA_DEST}"
   FILE_PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
@@ -620,7 +618,7 @@ INSTALL(
   )
 
 # process docs related install
-ADD_SUBDIRECTORY(Docs)
+add_subdirectory(Docs)
 
 #-----------------------------------------------------------------------
 # End of the main section of the CMakeLists file
@@ -631,4 +629,4 @@ ADD_SUBDIRECTORY(Docs)
 # to compute the location of the "cmake" executable.  We set it here
 # so that those CMake versions can find it.  We wait until after all
 # the add_subdirectory() calls to avoid affecting the subdirectories.
-SET(EXECUTABLE_OUTPUT_PATH ${CMake_BIN_DIR})
+set(EXECUTABLE_OUTPUT_PATH ${CMake_BIN_DIR})
diff --git a/CTestConfig.cmake b/CTestConfig.cmake
index 39032220e..92eacd8e3 100644
--- a/CTestConfig.cmake
+++ b/CTestConfig.cmake
@@ -19,7 +19,7 @@ set(CTEST_DROP_SITE_CDASH TRUE)
 set(CTEST_CDASH_VERSION "1.6")
 set(CTEST_CDASH_QUERY_VERSION TRUE)
 
-# use old trigger stuff so that cmake 2.4 and below will not 
+# use old trigger stuff so that cmake 2.4 and below will not
 # get errors on trigger
-SET (TRIGGER_SITE 
+set (TRIGGER_SITE
   "http://public.kitware.com/cgi-bin/Submit-CMake-TestingResults.cgi")
diff --git a/CTestCustom.cmake.in b/CTestCustom.cmake.in
index 982919198..1e6224b4b 100644
--- a/CTestCustom.cmake.in
+++ b/CTestCustom.cmake.in
@@ -1,8 +1,8 @@
-SET(CTEST_CUSTOM_ERROR_MATCH
+set(CTEST_CUSTOM_ERROR_MATCH
   ${CTEST_CUSTOM_ERROR_MATCH}
   "ERROR:")
 
-SET(CTEST_CUSTOM_WARNING_EXCEPTION
+set(CTEST_CUSTOM_WARNING_EXCEPTION
   ${CTEST_CUSTOM_WARNING_EXCEPTION}
   "xtree.[0-9]+. : warning C4702: unreachable code"
   "warning LNK4221"
@@ -56,21 +56,21 @@ SET(CTEST_CUSTOM_WARNING_EXCEPTION
   "[0-9,]+ warnings? generated."
   )
 
-IF(NOT "@CMAKE_GENERATOR@" MATCHES "Xcode")
-  SET(CTEST_CUSTOM_COVERAGE_EXCLUDE
+if(NOT "@CMAKE_GENERATOR@" MATCHES "Xcode")
+  set(CTEST_CUSTOM_COVERAGE_EXCLUDE
     ${CTEST_CUSTOM_COVERAGE_EXCLUDE}
     "XCode"
     )
-ENDIF (NOT "@CMAKE_GENERATOR@" MATCHES "Xcode")
+endif ()
 
-IF(NOT "@CMAKE_GENERATOR@" MATCHES "KDevelop")
-  SET(CTEST_CUSTOM_COVERAGE_EXCLUDE
+if(NOT "@CMAKE_GENERATOR@" MATCHES "KDevelop")
+  set(CTEST_CUSTOM_COVERAGE_EXCLUDE
     ${CTEST_CUSTOM_COVERAGE_EXCLUDE}
     "Kdevelop"
     )
-ENDIF (NOT "@CMAKE_GENERATOR@" MATCHES "KDevelop")
+endif ()
 
-SET(CTEST_CUSTOM_COVERAGE_EXCLUDE
+set(CTEST_CUSTOM_COVERAGE_EXCLUDE
   ${CTEST_CUSTOM_COVERAGE_EXCLUDE}
 
   # Exclude kwsys files from coverage results. They are reported
diff --git a/ChangeLog.manual b/ChangeLog.manual
index cdab4422d..90c91629e 100644
--- a/ChangeLog.manual
+++ b/ChangeLog.manual
@@ -1,3 +1,477 @@
+Changes in CMake 2.8.10.2 (since 2.8.10.1)
+----------------------------------------------
+Alex Neundorf (1):
+      Automoc: fix regression #13667, broken build in phonon
+
+Brad King (1):
+      Initialize IMPORTED GLOBAL targets on reconfigure (#13702)
+
+David Cole (1):
+      CMake: Fix infinite loop untarring corrupt tar file
+
+Rolf Eike Beer (1):
+      FindGettext: fix overwriting result with empty variable (#13691)
+
+Changes in CMake 2.8.10.1 (since 2.8.10)
+----------------------------------------------
+Brad King (5):
+      Fix default PDB output directory (#13644)
+      Fix PathScale compiler id for Clang-based upstream
+      Update programmatically-reported copyright year (#13638)
+      FindSDL: Restore accidentally dropped search paths (#13651)
+      OS X: Fix default CMAKE_OSX_SYSROOT with deployment target
+
+Rolf Eike Beer (2):
+      FindOpenSSL: fix library selection on Windows (#13645)
+      FindOpenSSL: also find the non-MD debug libraries for MSVC
+
+Stephen Kelly (1):
+      GenEx: Use case insensitive comparison for $<CONFIG:...>
+
+Changes in CMake 2.8.10 (since 2.8.10-rc3)
+----------------------------------------------
+None
+
+Changes in CMake 2.8.10-rc3 (since 2.8.10-rc2)
+----------------------------------------------
+Rolf Eike Beer (2):
+      SelectLibraryConfigurations: add testcase
+      SelectLibraryConfigurations: fix for release and debug libs being the same
+
+Stephen Kelly (5):
+      BasicConfigVersion: Make docs refer to the macro, not the module name
+      Document LOCATION undefined behavior with use of LINKER_LANGUAGE.
+      GenEx: Add an accessor for imported targets in a makefile.
+      GenEx: Create cmGeneratorTargets for imported targets.
+      GexEx: Validate Target names and property names differently.
+
+Thomas Arcila (1):
+      SelectLibraryConfigurations: Fix foreach(x IN LISTS ...) syntax
+
+Changes in CMake 2.8.10-rc2 (since 2.8.10-rc1)
+----------------------------------------------
+Alex Neundorf (2):
+      Document CMAKE_FIND_PACKAGE_NAME
+      Automoc: fix #13572: issue with symbolic links
+
+Brad King (4):
+      cmCTestSVN: Fix compilation with Sun CC 5.1
+      if: Document that plain 'NOTFOUND' is a false constant
+      string: Clarify regex documentation of '-' behavior
+      FortranCInterface: Pass all flags to VERIFY project (#13579)
+
+David Cole (1):
+      NSIS: Fix incorrect uninstall registry key name (#13578)
+
+Eric NOULARD (3):
+      CPACK_XX_ON_ABSOLUTE_INSTALL_DESTINATION is now properly checked for ON/OFF
+      Document CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY and fix some typo.
+      Make CPACK_SET_DESTDIR work with archive generator + component-based packaging
+
+Jean-Christophe Fillion-Robin (1):
+      CTest: Ensure CTEST_USE_LAUNCHERS behaves nicely in Superbuild setup
+
+Pere Nubiola i Radigales (1):
+      Find PostgreSQL headers on Debian
+
+Peter Kümmel (4):
+      Ninja: also set OBJECT_DIR when compiling
+      Ninja: don't pollute current dir when using gui (#13495)
+      Ninja: implicit dependency for custom command files
+      Fix regression: write compile definitions if any
+
+Philip Lowman (4):
+      FindGTK2: Rollback lib64 changes which broke header file finding
+      FindGTK2: #12049 fix detection of header files on multiarch systems
+      FindGTK2: #12596 Missing paths for FindGTK2 on NetBSD
+      FindGTK2: Update local changelog
+
+Rolf Eike Beer (6):
+      CTest: fix usage of memory checker with spaces in path
+      CTest: fix pre and post test commands with spaces
+      CTest: add tests that simulate memcheck runs
+      CTest: improve memory checker type detection
+      CTest: add a test for CTEST_CUSTOM_MEMCHECK_IGNORE
+      CTest: add a check with a quoted memory checker
+
+Stephen Kelly (18):
+      GenEx: It is not an error to specify an empty parameter
+      GenEx: Return after error reported.
+      GenEx: Report actual target name not found, not "0" each time.
+      GenEx: Parse comma after colon tokens specially
+      GenEx: Validate target and property names.
+      GenEx: Ensure that the empty CONFIGURATION can be used conditionally.
+      GenEx: Add test for $<BOOL:> with empty parameter.
+      GenEx: Add tests for "0" and "1" expressions with literal commas.
+      GenEx: Don't use std::vector::at(int).
+      Attempt to fix the compile of cmake on Sun CC.
+      GenEx: Parse colon after arguments separator colon specially.
+      GenEx: Test the use of generator expressions to generate lists.
+      GenEx: Fix termination bugs in generator expression parser.
+      GenEx: Break if there are no more commas in the container
+      GenEx: Add some more asserts to verify code-sanity.
+      GenEx: Replace some failing tests with Borland and NMake makefiles.
+      GenEx: Fix reporting about not-found include directories and libraries.
+      Fix config-specific INCLUDE_DIRECTORIES in multi-config generators
+
+Changes in CMake 2.8.10-rc1 (since 2.8.9)
+-----------------------------------------
+Scripted Changes (3):
+      Remove trailing whitespace from most CMake and C/C++ code
+      Convert CMake-language commands to lower case
+      Remove CMake-language block-end command arguments
+
+Alex Neundorf (27):
+      Eclipse: add support for the 4.2 Juno release (#13367)
+      Eclipse: improve (fix ?) version detection on OSX
+      Eclipse: fix #13358: don't create bad linked resources
+      Eclipse: fix #13358: don't create bad linked resources
+      remove non-working KDE4 test
+      Eclipse on OSX: fix handling of framework include dirs (#13464)
+      Eclipse on OSX: improve handling of framework include dirs (#13367)
+      -fix line length
+      fix #13474: also rescan dependencies if the depender does not exist
+      -fix line length
+      -fix Java dependency scanning, broken in previous commit
+      error out if CTEST_USE_LAUNCHERS is TRUE but RULE_LAUNCH_* are not set
+      fix #13494: rerun automoc also if include dirs or moc options change
+      CMakeDetermineFortranCompiler: add support for cross-compiling (#13379)
+      Automoc: fix #13493, use target properties for include dirs
+      Automoc: do not use DEFINITIONS, but only COMPILE_DEFINITIONS
+      Automoc: also the makefile-COMPILE_DEFINITIONS
+      cmGlobalGenerator.h: some minor coding style fixes
+      Modules/readme.txt: fix typo
+      find_package: add support for a <package>_NOT_FOUND_MESSAGE variable
+      exports: store pointers to all installations of each export set
+      exports: accept a missing target if it is exported exactly once
+      exports: first try at error handling if a target is missing
+      exports: fix build with MSVC6
+      exports: move the handling of missing targets into subclasses
+      exports: define a CMAKE_FIND_PACKAGE_NAME var set by find_package()
+      exports: add a test for exporting dependent targets
+
+Andreas Mohr (1):
+      FindCURL: Find older MSVC prebuilts
+
+Andy Piper (1):
+      Do not include directories which are part of the package install prefix.
+
+Benjamin Eikel (21):
+      Initial version of find module
+      FindSDL: Add version support for FindSDL_net
+      FindSDL: Version support for FindSDL_image
+      FindSDL: Use prefix SDL_NET, because it matches the file name.
+      FindSDL: Use SDL_IMAGE prefix for varibales
+      FindSDL: Add "cmake_minimum_required" to "try_compile" project
+      FindSDL: Format the documentation
+      FindSDL: Version support for FindSDL_sound
+      FindSDL: Use same capitalization for FPHSA as file name
+      FindSDL: Pass SDL_SOUND_LIBRARY to FIND_PACKAGE_HANDLE_STANDARD_ARGS
+      FindSDL: Use SDL_MIXER prefix for variables
+      FindSDL: Add version support for FindSDL_mixer
+      FindSDL: Update documentation
+      FindSDL: Use SDL_TTF prefix for variables
+      FindSDL: Add version support for FindSDL_ttf
+      FindSDL: Update documentation
+      FindSDL: Format documentation
+      FindSDL: Add version support
+      FindSDL: Add my copyright tag to all FindSDL_* modules
+      FindSDL: Remove from find_... calls PATHS that are set by default
+      FindSDL: Stay compatible with old input variables
+
+Bill Hoffman (8):
+      Use OUTPUT_NORMAL instead of OUTPUT_MERGE for cmake -E chdir.
+      curl: Use find_package(OpenSSL)
+      curl: Make OpenSSL DLLs available to CMake on Windows
+      file(DOWNLOAD): Generalize EXPECTED_MD5 to EXPECTED_HASH
+      file(DOWNLOAD): Add options for SSL
+      Utilities/Release: Enable CMAKE_USE_OPENSSL in nightly binaries
+      Add SSL_VERIFYPEER and CAINFO file options to ExternalProject_Add.
+      Revert "Ninja: don't expand any rsp files"
+
+Brad King (83):
+      find_library: Add test covering lib->lib64 cases
+      find_library: Refactor lib->lib64 conversion
+      find_library: Simplify lib->lib<arch> expansion
+      find_library: Fix mixed lib->lib64 (non-)conversion cases (#13419)
+      CMakeDetermine(C|CXX)Compiler: Consider Clang compilers
+      Factor common code out of CMakeDetermine(ASM|C|CXX|Fortran)Compiler
+      Prefer generic system compilers by default for C, C++, and Fortran
+      Xcode: Fix object library references in multi-project trees (#13452)
+      Xcode: Run xcode-select to find Xcode version file (#13463)
+      Watcom: Simplify compiler version detection (#11866)
+      Remove trailing TAB from NSIS.template.in
+      Fix WarnUnusedUnusedViaUnset test pass/fail regex
+      CMakeVersion.bash: Update sed expression for lower-case 'set'
+      GetPrerequisites: Mark file_cmd as advanced cache entry
+      Add boolean generator expressions
+      Add $<CONFIG:...> boolean query generator expression
+      Recognize Clang ASM support (#13473)
+      Xcode: Set ASM source language in project file (#13472)
+      Tests/Assembler: Do not use assembler in universal binaries
+      Add FindHg module to find Mercurial
+      ExternalProject: Add Mercurial (hg) repository support
+      Qt4Macros: Fix recently broken resource file parsing
+      Tests/ObjectLibrary: Do not enable CXX in subdirectories
+      VS11: Rename 'Immersive' to 'WindowsAppContainer' (#12930)
+      VS: Disable precompiled headers unless enabled by project (#12930)
+      VS11: Generate flag tables from MSBuild V110 tool files
+      Detect Compaq compiler version with its id
+      Detect PathScale compiler version with its id
+      Detect TI compiler version with its id
+      Detect Comeau compiler version with its id
+      Detect SDCC compiler version with its id
+      Detect Cray compiler version with its id
+      Detect Analog VisualDSP++ compiler version with its id
+      Re-order C/C++/Fortran compiler determination logic
+      CMakeDetermineCompilerId: Prepare to detect IDE compiler id
+      Xcode: Detect the compiler id and tool location
+      VS10: Define CMAKE_VS_PLATFORM_TOOLSET variable
+      VS: Detect the compiler id and tool location
+      Cleanly enable a language in multiple subdirectories
+      Test variables CMAKE_(C|CXX|Fortran)_COMPILER(|_ID|_VERSION)
+      Document CMAKE_<LANG>_COMPILER_(ID|VERSION) values
+      Make platform information files specific to the CMake version
+      Move CMAKE_<LANG>_COMPILER_WORKS to compiler information files
+      Store ABI detection results in compiler information files
+      VS: Remove support for "free" version 2003 tools
+      VS: Simplify MSVC version reporting
+      Modernize MSVC compiler information files
+      VS: Fix MSVC_IDE definition recently broken by refactoring
+      add_library: Document POSITION_INDEPENDENT_CODE default (#13479)
+      magrathea: Tell cmELF about DT_RUNPATH (#13497)
+      Utilities/Release: Link AIX binary with large maxdata
+      Utilities/xml: Add .gitattributes to disable whitespace checks
+      Utilities/xml: Add docbook-4.5 DTD (#13508)
+      docbook: Fix formatter naming convention to avoid shadow
+      docbook: Fix Sun CC warning on ptr_fun(isalnum)
+      curl: Honor OPENSSL_NO_SSL2
+      if: Compare up to 8 components in VERSION tests
+      ExternalProject: Generalize URL_MD5 option to URL_HASH
+      Rename SSL terminology to TLS
+      file(DOWNLOAD): Make TLS options behave as documented
+      OS X: Add platform-specific Clang compiler info files (#13536)
+      VS11: Detect VS 2012 Express for default generator (#13348)
+      VS11: Add VS 2012 Express support (#13348)
+      file(DOWNLOAD): Add HTTP User-Agent string
+      ExternalProject: Add DOWNLOAD_NAME option
+      file(DOWNLOAD): Change EXPECTED_HASH to take ALGO=value
+      VS8: Remove '.NET' from generator description (#10158)
+      Clang: Split Compiler/Clang* modules out from GNU (#13550)
+      Clang: All versions know about -fPIE (#13550)
+      Xcode: Remove unused code reading CMAKE_OSX_SYSROOT_DEFAULT
+      OS X: Always generate -isysroot if any SDK is in use
+      OS X: Improve default CMAKE_OSX_SYSROOT selection
+      bootstrap: Suppress CMAKE_OSX_SYSROOT if CFLAGS have -isysroot
+      Tests/Assembler: Use CMAKE_OSX_SYSROOT to generate .s file
+      OS X: Allow CMAKE_OSX_SYSROOT to be a logical SDK name
+      OS X: Simplify selection of CMAKE_OSX_ARCHITECTURES
+      OS X: If CMAKE_OSX_SYSROOT is already set do not compute default
+      OS X: Further improve default CMAKE_OSX_SYSROOT selection
+      OS X: Teach deployment target sanity check about SDK names
+      OS X: Ignore MACOSX_DEPLOYMENT_TARGET during Xcode compiler id
+      Verify that PDB_(NAME|OUTPUT_DIRECTORY) are honored in test
+      Document that PDB_(NAME|OUTPUT_DIRECTORY) are ignored for VS 6
+      Run PDBDirectoryAndName test on MSVC and Intel
+
+Clinton Stimpson (8):
+      fphsa: clarify message about minimum required version found.
+      DeployQt4:  Include DESTDIR for some cpack generators.
+      Add -DNDEBUG to RelWithDebInfo flags where where Release flags had it.
+      Fix regex for qt minor version.
+      FindQt4: Give precedence to QTDIR environment variable, if set.
+      FindQt4: Give precedence to QTDIR environment variable, if set.
+      Fix errors detecting Qt4 on Windows 8.
+      cmake-gui: Fix error status when interrupted.
+
+Daniel Pfeifer (8):
+      Simplify CMake.HTML documentation test command line
+      docbook: Remove table of contents
+      docbook: Factor out code to write valid DocBook IDs
+      docbook: Fix the DocBook section output
+      docbook: Cleanup formatter and generated DocBook
+      docbook: Add support for <abstract> at section level 1
+      docbook: Add CMake.DocBook test to validate xml (#13508)
+      docbook: Remove redundant docs that cause invalid DocBook
+
+David Cole (9):
+      Begin post-2.8.9 development
+      Release: Temporarily exclude ExternalProject test on cygwin
+      Add ability to run as a ctest -S script also
+      CMake: Clarify the documentation for if(f1 IS_NEWER_THAN f2)
+      Convert the CPACK_CYGWIN_PATCH_NUMBER variable to a cache variable
+      InstallRequiredSystemLibraries: Use correct file names (#13315)
+      ProcessorCount: Mark find_program vars as advanced (#13236)
+      FindQt4: Avoid "finding" non-existent library in a .framework
+      FindMPI: Set correct variables for calls to FPHSA
+
+Eric NOULARD (2):
+      Enhance DESTDIR documentation. Fixes #0012374.
+      Handles %attr(nnn,-,-) /path/to/file in CPACK_RPM_USER_FILELIST properly.
+
+James Bigler (3):
+      Replace -g3 with -g for CUDA 4.1 and 4.2 in addition to CUDA < 3.0.
+      Added CUDA_SOURCE_PROPERTY_FORMAT. Allows setting per file format (OBJ or PTX)
+      FindCUDA: Added CUDA_HOST_COMPILER variable.
+
+Marcin Wojdyr (1):
+      Remove CMake multiline block-end command arguments
+
+Nils Gladitz (1):
+      ctest_update: Tell svn not to prompt interactively (#13024)
+
+Patrick Gansterer (4):
+      VS: Cleanup AddPlatformDefinitions() of Visual Studio generators
+      Add additional architectures to CMakePlatformId.h.in
+      Add WindowsCE platform information files
+      VS: Remove duplicated implementations of CreateLocalGenerator()
+
+Peter Kuemmel (1):
+      Ninja: don't expand any rsp files
+
+Peter Kümmel (15):
+      Ninja: cmcldeps needs a compiler
+      Ninja: don't crash on returned 0 pointer
+      Ninja: prepare msvc pdb cleanup
+      Ninja:split out setting of msvc TARGET_PDB
+      Ninja: remove GetTargetPDB because it is used only once
+      Ninja: also detect /showInclude prefix for icl
+      Find mingw's windres also when Unix Makefiles are used
+      Ninja: don't suppress warning about compiler options
+      Ninja: suppress cmcldeps only for source file signature try_compiles
+      Ninja: filter target specific compile flags with language specific regex
+      Ninja: OBJECT_DEPENDS should set an implicit dependency
+      Ninja: don't confuse ninja's rsp files with nmake's
+      Ninja: move -LIBPATH behind -link option
+      Ninja: move <OBJECTS> in front of the first linker option
+      Ninja: add option to enforce usage of response files
+
+Philip Lowman (3):
+      FindOpenSceneGraph: CMake variable OSG_DIR influences detection now too
+      FindGTK2: Add GTK2_CAIROMMCONFIG_INCLUDE_DIR for cairommconfig.h
+      CMakeDetermineVSServicePack: Visual Studio 2012 added
+
+Rolf Eike Beer (25):
+      remove lib64 Unix paths if the respective lib path is also given
+      FindOpenSSL: find cross-compiled OpenSSL from MinGW (#13431)
+      FindOpenSSL: use SelectLibraryConfigurations
+      FindOpenSSL: let CMake handle environment variable HINTS
+      FindOpenSSL: cleanup path hints
+      FindOpenSSL: remove leftover comment
+      SelectLibraryConfiguration: generate correct output when input vars are lists
+      Fix typo direcotry -> directory (and similar) [#13444]
+      FindSelfPackers: fix typo (#13456)
+      CheckTypeSize: show in documentation how to get struct member size (#10579)
+      CheckTypeSize: add a test for size of struct members
+      FindX11: remove duplicates from X11 include path list (#13316)
+      FindX11: avoid calling list(REMOVE_DUPLICATES) on an empty list
+      list command: error on too many arguments
+      CMake.List test: explicitely test with lists containing only an empty string
+      use the find_* functions ENV parameter
+      use PATH_SUFFIXES to simplify find_* calls
+      do not escape spaces in regular expressions
+      read less from version headers into variables
+      FindFLEX: fix version extraction on Apple
+      FindGettext: remove code duplicating FPHSA checks
+      include FPHSA from current directory in all modules
+      FindOpenSceneGraph: simplify by using more features of FPHSA
+      FindSDL: add SDLMAIN_LIBRARY only once (#13262)
+      add documentation for all MSVCxxx version variables (#12567)
+
+Sergei Nikulov (1):
+      fix for discovering ft2build.h using FREETYPE_DIR environment var (#13502)
+
+Stephen Kelly (60):
+      Add new qt4_use_modules function.
+      Add missing whitespace to docs.
+      Fix some typos in the docs.
+      Remove incorrect doc string for link type enum
+      Remove duplicate 'of' from docs.
+      Fix unfortunate documentation error for PIC feature.
+      Don't duplicate -D defines sent to the compiler.
+      Fix CompileDefinitions test on Visual Studio.
+      Fix the test setting COMPILE_DEFINITIONS target property
+      Rename files from main.cpp to more meaningful names.
+      Fix casing of 'Qt' in docs, comments and user-visible strings.
+      Read entire Qt4 qrc file when parsing for depends info.
+      Add a return-after-error if an old Qt is found.
+      Use CMake platform variables instead of Qt ones.
+      Move variable setting down to where it relates to.
+      Remove an if which is always true.
+      Use add_subdirectory instead of the obsolete subdirs.
+      Replace two include_directories with a setting.
+      Compile with both Qt4 and Qt5.
+      Build with Qt5 if it is found.
+      cmGeneratorExpression: Re-write for multi-stage evaluation
+      cmGeneratorExpression: Port users to two-stage processing
+      Fix the regular expression validator for target names.
+      Handle colons as a special case in the generator expression parser.
+      Enable deprecated API when using Qt 5.
+      Add more forwarding API to cmGeneratorTarget.
+      Store cmGeneratorTargets with the makefile.
+      Move GenerateTargetManifest to cmGeneratorTarget.
+      Move GetLinkInformation to cmGeneratorTarget
+      Make cmLocalGenerator::AddArchitectureFlags take a cmGeneratorTarget.
+      Move GetCreateRuleVariable to cmGeneratorTarget.
+      Port cmLocalGenerator::GetTargetFlags to cmGeneratorTarget.
+      Move GetIncludeDirectories to cmGeneratorTarget.
+      Append the COMPILE_DEFINITIONS from the Makefile to all targets.
+      Add a wrapper for accessing config-specific compile-definitions.
+      Add convenience for getting a cmGeneratorTarget to use.
+      Fix compiler warning with initialization order.
+      Revert "Move GenerateTargetManifest to cmGeneratorTarget."
+      Use the cmGeneratorTarget for the include directories API.
+      Fix indentation in the code blocks generator.
+      Port remaining code to GetCompileDefinitions().
+      Add include guard for cmGeneratorExpression.
+      Don't prepend a path before generator expressions in include_directories.
+      Convert paths in INCLUDE_DIRECTORIES property to Unix slashes.
+      Add an AppendDefines std::string overload.
+      Return a std::string from GetCompileDefinitions.
+      Refactor GetCompileDefinitions a bit.
+      Extend the generator expression language with more logic.
+      Add a generator expression for target properties.
+      Add API to check that dependent target properties form a DAG.
+      Add a self-reference check for target properties.
+      Early return if there is no target.
+      Process generator expressions in the INCLUDE_DIRECTORIES property.
+      Process generator expressions in the COMPILE_DEFINITIONS target property.
+      Fix the layout of the generator expression documentation.
+      Fix punctuation in some variables documentation.
+      Document that generator expressions can be used in target properties.
+      Remove unused parameter marker and the unused parameter.
+      Fix minor typos.
+      Remove period at the end of the check message.
+
+Tom Schutter (2):
+      cmake-mode.el: Use more readable regex and case-fold-search
+      cmake-mode.el: add local keybindings
+
+Xavier Besseron (7):
+      cmCTestSVN: Add the new SVNInfo structure
+      cmCTestSVN: Extend Revision struct with SVN repo information
+      cmCTestSVN: Add the Repositories list and the RootInfo pointer
+      cmCTestSVN: Create the SVNInfo for the root repository
+      cmCTestSVN: Use the SVNInfo structure
+      cmCTestSVN: Add a LoadExternal() function and an ExternalParser class
+      cmCTestSVN: Load and process information from externals
+
+Yuchen Deng (1):
+      Add PDB_OUTPUT_DIRECTORY and PDB_NAME target properties (#10830)
+
+Yury G. Kudryashov (7):
+      exports: Move cmTargetExport to a dedicated header file
+      exports: Remove cmTargetExport constructor
+      exports: Rename cmGlobalGenerator::AddTargetToExport{s,}
+      exports: Create class cmExportSet
+      exports: Add cmExportSetMap class
+      exports: Hold an ExportSet pointer in cm*Export*Generator
+      exports: cmGlobalGenerator::ExportSets destructor will clear it
+
+Zack Galbreath (2):
+      Clean up documentation formatting so that it is rendered properly in HTML.
+      cmparseMSBuildXML: Include DisplayName in the output
+
 Changes in CMake 2.8.9 (since 2.8.9-rc3)
 ----------------------------------------
 None
diff --git a/CompileFlags.cmake b/CompileFlags.cmake
index 3b455b96f..b2044e441 100644
--- a/CompileFlags.cmake
+++ b/CompileFlags.cmake
@@ -13,52 +13,52 @@
 #-----------------------------------------------------------------------------
 # set some special flags for different compilers
 #
-IF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
-  SET(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
-ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
-IF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
-  SET(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
-ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
-INCLUDE (${CMAKE_ROOT}/Modules/CMakeBackwardCompatibilityCXX.cmake)
+if(CMAKE_GENERATOR MATCHES "Visual Studio 7")
+  set(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
+endif()
+if(CMAKE_GENERATOR MATCHES "Visual Studio 6")
+  set(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
+endif()
+include (${CMAKE_ROOT}/Modules/CMakeBackwardCompatibilityCXX.cmake)
 
-IF(WIN32 AND "${CMAKE_C_COMPILER_ID}" MATCHES "^(Intel)$")
-  SET(_INTEL_WINDOWS 1)
-ENDIF()
+if(WIN32 AND "${CMAKE_C_COMPILER_ID}" MATCHES "^(Intel)$")
+  set(_INTEL_WINDOWS 1)
+endif()
 
 # Disable deprecation warnings for standard C functions.
 # really only needed for newer versions of VS, but should
-# not hurt other versions, and this will work into the 
+# not hurt other versions, and this will work into the
 # future
-IF(MSVC OR _INTEL_WINDOWS)
-  ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
-ELSE()
-ENDIF()
+if(MSVC OR _INTEL_WINDOWS)
+  add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
+else()
+endif()
 
 #silence duplicate symbol warnings on AIX
-IF(CMAKE_SYSTEM MATCHES "AIX.*")
-  IF(NOT CMAKE_COMPILER_IS_GNUCXX)
-    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -bhalt:5 ")
-  ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
-ENDIF(CMAKE_SYSTEM MATCHES "AIX.*")
+if(CMAKE_SYSTEM MATCHES "AIX.*")
+  if(NOT CMAKE_COMPILER_IS_GNUCXX)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -bhalt:5 ")
+  endif()
+endif()
 
-IF(CMAKE_SYSTEM MATCHES "IRIX.*")
-  IF(NOT CMAKE_COMPILER_IS_GNUCXX)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-woff84 -no_auto_include")
-    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-woff15")
-  ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
-ENDIF(CMAKE_SYSTEM MATCHES "IRIX.*")
+if(CMAKE_SYSTEM MATCHES "IRIX.*")
+  if(NOT CMAKE_COMPILER_IS_GNUCXX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wl,-woff84 -no_auto_include")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-woff15")
+  endif()
+endif()
 
-IF(CMAKE_SYSTEM MATCHES "OSF1-V.*")
-  IF(NOT CMAKE_COMPILER_IS_GNUCXX)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -timplicit_local -no_implicit_include ")
-  ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
-ENDIF(CMAKE_SYSTEM MATCHES "OSF1-V.*")
+if(CMAKE_SYSTEM MATCHES "OSF1-V.*")
+  if(NOT CMAKE_COMPILER_IS_GNUCXX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -timplicit_local -no_implicit_include ")
+  endif()
+endif()
 
 # use the ansi CXX compile flag for building cmake
-IF (CMAKE_ANSI_CXXFLAGS)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_ANSI_CXXFLAGS}")  
-ENDIF (CMAKE_ANSI_CXXFLAGS)
+if (CMAKE_ANSI_CXXFLAGS)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_ANSI_CXXFLAGS}")
+endif ()
 
-IF (CMAKE_ANSI_CFLAGS)
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_ANSI_CFLAGS}")  
-ENDIF (CMAKE_ANSI_CFLAGS)
+if (CMAKE_ANSI_CFLAGS)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_ANSI_CFLAGS}")
+endif ()
diff --git a/Docs/CMakeLists.txt b/Docs/CMakeLists.txt
index b04b32d5e..a5e91c9d1 100644
--- a/Docs/CMakeLists.txt
+++ b/Docs/CMakeLists.txt
@@ -1,4 +1,4 @@
 string(REGEX REPLACE "^/(.*)" "\\1" REL_CMAKE_DATA_DIR "${CMAKE_DATA_DIR}")
 install(FILES cmake-help.vim cmake-indent.vim cmake-syntax.vim DESTINATION ${REL_CMAKE_DATA_DIR}/editors/vim)
 install(FILES cmake-mode.el DESTINATION ${REL_CMAKE_DATA_DIR}/editors/emacs)
-ADD_SUBDIRECTORY (bash-completion)
+add_subdirectory (bash-completion)
diff --git a/Docs/bash-completion/cpack b/Docs/bash-completion/cpack
index 84dcfd534..a0c1f8375 100644
--- a/Docs/bash-completion/cpack
+++ b/Docs/bash-completion/cpack
@@ -8,7 +8,7 @@ _cpack()
     case "$prev" in
         -G)
             COMPREPLY=( $( compgen -W '$( cpack --help 2>/dev/null |
-                grep "^  .*=\ .*" 2> /dev/null | grep -v "^  -" 2>/dev/null |
+                grep "^  .*= .*" 2> /dev/null | grep -v "^  -" 2>/dev/null |
                 cut -d" " -f 3 )' -- "$cur" ) )
             return
             ;;
diff --git a/Docs/cmake-indent.vim b/Docs/cmake-indent.vim
index f149873ed..a26dd06a2 100644
--- a/Docs/cmake-indent.vim
+++ b/Docs/cmake-indent.vim
@@ -1,11 +1,11 @@
 " =============================================================================
-" 
+"
 "   Program:   CMake - Cross-Platform Makefile Generator
 "   Module:    $RCSfile$
 "   Language:  VIM
 "   Date:      $Date$
 "   Version:   $Revision$
-" 
+"
 " =============================================================================
 
 " Vim indent file
diff --git a/Docs/cmake-mode.el b/Docs/cmake-mode.el
index 951745515..6feed94c5 100644
--- a/Docs/cmake-mode.el
+++ b/Docs/cmake-mode.el
@@ -34,7 +34,7 @@
 ;; cmake executable variable used to run cmake --help-command
 ;; on commands in cmake-mode
 ;;
-;; cmake-command-help Written by James Bigler 
+;; cmake-command-help Written by James Bigler
 ;;
 
 (defcustom cmake-mode-cmake-executable "cmake"
@@ -68,9 +68,9 @@ set the path with these commands:
                                        "\\|" "[ \t\r\n]"
                                        "\\)*"))
 (defconst cmake-regex-block-open
-  "^\\([iI][fF]\\|[mM][aA][cC][rR][oO]\\|[fF][oO][rR][eE][aA][cC][hH]\\|[eE][lL][sS][eE]\\|[eE][lL][sS][eE][iI][fF]\\|[wW][hH][iI][lL][eE]\\|[fF][uU][nN][cC][tT][iI][oO][nN]\\)$")
+  "^\\(if\\|macro\\|foreach\\|else\\|elseif\\|while\\|function\\)$")
 (defconst cmake-regex-block-close
-  "^[ \t]*\\([eE][nN][dD][iI][fF]\\|[eE][nN][dD][fF][oO][rR][eE][aA][cC][hH]\\|[eE][nN][dD][mM][aA][cC][rR][oO]\\|[eE][lL][sS][eE]\\|[eE][lL][sS][eE][iI][fF]\\|[eE][nN][dD][wW][hH][iI][lL][eE]\\|[eE][nN][dD][fF][uU][nN][cC][tT][iI][oO][nN]\\)[ \t]*(")
+  "^[ \t]*\\(endif\\|endforeach\\|endmacro\\|else\\|elseif\\|endwhile\\|endfunction\\)[ \t]*(")
 
 ;------------------------------------------------------------------------------
 
@@ -126,6 +126,7 @@ set the path with these commands:
           (beginning-of-line)
 
           (let ((point-start (point))
+                (case-fold-search t)  ;; case-insensitive
                 token)
 
             ; Search back for the last indented line.
@@ -191,11 +192,11 @@ the indentation.  Otherwise it retains the same position on the line"
   (setq save-point (point))
   (goto-char (point-min))
   (while (re-search-forward "^\\([ \t]*\\)\\(\\w+\\)\\([ \t]*(\\)" nil t)
-    (replace-match 
-     (concat 
-      (match-string 1) 
-      (downcase (match-string 2)) 
-      (match-string 3)) 
+    (replace-match
+     (concat
+      (match-string 1)
+      (downcase (match-string 2))
+      (match-string 3))
      t))
   (goto-char save-point)
   )
@@ -229,13 +230,26 @@ the indentation.  Otherwise it retains the same position on the line"
 ;;
 (defvar cmake-tab-width 2)
 
+;;
+;; Keymap.
+;;
+(defvar cmake-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\C-ch" 'cmake-help-command)
+    (define-key map "\C-cl" 'cmake-help-list-commands)
+    (define-key map "\C-cu" 'unscreamify-cmake-buffer)
+    map)
+  "Keymap used in cmake-mode buffers.")
+
 ;------------------------------------------------------------------------------
 
 ;;
 ;; CMake mode startup function.
 ;;
 (defun cmake-mode ()
-  "Major mode for editing CMake listfiles."
+  "Major mode for editing CMake listfiles.
+
+\\{cmake-mode-map}"
   (interactive)
   (kill-all-local-variables)
   (setq major-mode 'cmake-mode)
@@ -262,6 +276,9 @@ the indentation.  Otherwise it retains the same position on the line"
   (make-local-variable 'comment-start)
   (setq comment-start "#")
 
+  ; Setup keymap.
+  (use-local-map cmake-mode-map)
+
   ; Run user hooks.
   (run-hooks 'cmake-mode-hook))
 
diff --git a/Docs/cmake-syntax.vim b/Docs/cmake-syntax.vim
index 80b348eef..80395ab1a 100644
--- a/Docs/cmake-syntax.vim
+++ b/Docs/cmake-syntax.vim
@@ -36,9 +36,9 @@ syn region cmakeVariableValue start=/\${/ end=/}/
             \ contained oneline contains=CONTAINED,cmakeTodo
 syn region cmakeEnvironment start=/\$ENV{/ end=/}/
             \ contained oneline contains=CONTAINED,cmakeTodo
-syn region cmakeString start=/"/ end=/"/ 
+syn region cmakeString start=/"/ end=/"/
             \ contains=CONTAINED,cmakeTodo,cmakeOperators
-syn region cmakeArguments start=/(/ end=/)/ 
+syn region cmakeArguments start=/(/ end=/)/
             \ contains=ALLBUT,cmakeArguments,cmakeTodo
 syn keyword cmakeSystemVariables
             \ WIN32 UNIX APPLE CYGWIN BORLAND MINGW MSVC MSVC_IDE MSVC60 MSVC70 MSVC71 MSVC80 MSVC90
@@ -49,11 +49,11 @@ syn keyword cmakeDeprecated ABSTRACT_FILES BUILD_NAME SOURCE_FILES SOURCE_FILES_
            \ nextgroup=cmakeArguments
 
 " The keywords are generated as:  cmake --help-command-list | tr "\n" " "
-syn keyword cmakeStatement 
+syn keyword cmakeStatement
       \ ADD_CUSTOM_COMMAND ADD_CUSTOM_TARGET ADD_DEFINITIONS ADD_DEPENDENCIES ADD_EXECUTABLE ADD_LIBRARY ADD_SUBDIRECTORY ADD_TEST AUX_SOURCE_DIRECTORY BUILD_COMMAND BUILD_NAME CMAKE_MINIMUM_REQUIRED CONFIGURE_FILE CREATE_TEST_SOURCELIST ELSE ELSEIF ENABLE_LANGUAGE ENABLE_TESTING ENDFOREACH ENDFUNCTION ENDIF ENDMACRO ENDWHILE EXEC_PROGRAM EXECUTE_PROCESS EXPORT_LIBRARY_DEPENDENCIES FILE FIND_FILE FIND_LIBRARY FIND_PACKAGE FIND_PATH FIND_PROGRAM FLTK_WRAP_UI FOREACH FUNCTION GET_CMAKE_PROPERTY GET_DIRECTORY_PROPERTY GET_FILENAME_COMPONENT GET_SOURCE_FILE_PROPERTY GET_TARGET_PROPERTY GET_TEST_PROPERTY IF INCLUDE INCLUDE_DIRECTORIES INCLUDE_EXTERNAL_MSPROJECT INCLUDE_REGULAR_EXPRESSION INSTALL INSTALL_FILES INSTALL_PROGRAMS INSTALL_TARGETS LINK_DIRECTORIES LINK_LIBRARIES LIST LOAD_CACHE LOAD_COMMAND MACRO MAKE_DIRECTORY MARK_AS_ADVANCED MATH MESSAGE OPTION OUTPUT_REQUIRED_FILES PROJECT QT_WRAP_CPP QT_WRAP_UI REMOVE REMOVE_DEFINITIONS SEPARATE_ARGUMENTS SET SET_DIRECTORY_PROPERTIES SET_SOURCE_FILES_PROPERTIES SET_TARGET_PROPERTIES SET_TESTS_PROPERTIES SITE_NAME SOURCE_GROUP STRING SUBDIR_DEPENDS SUBDIRS TARGET_LINK_LIBRARIES TRY_COMPILE TRY_RUN UNSET USE_MANGLED_MESA UTILITY_SOURCE VARIABLE_REQUIRES VTK_MAKE_INSTANTIATOR VTK_WRAP_JAVA VTK_WRAP_PYTHON VTK_WRAP_TCL WHILE WRITE_FILE
             \ nextgroup=cmakeArguments
-syn keyword cmakeTodo 
-            \ TODO FIXME XXX 
+syn keyword cmakeTodo
+            \ TODO FIXME XXX
             \ contained
 
 " Define the default highlighting.
diff --git a/Example/Demo/demo.cxx b/Example/Demo/demo.cxx
index 31de0386c..815c8149e 100644
--- a/Example/Demo/demo.cxx
+++ b/Example/Demo/demo.cxx
@@ -5,6 +5,6 @@ extern Hello hello;
 int main()
 {
   hello.Print();
-  
+
   return 0;
 }
diff --git a/Modules/AddFileDependencies.cmake b/Modules/AddFileDependencies.cmake
index f971e37f5..e88025c14 100644
--- a/Modules/AddFileDependencies.cmake
+++ b/Modules/AddFileDependencies.cmake
@@ -15,15 +15,15 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
-MACRO(ADD_FILE_DEPENDENCIES _file)
+macro(ADD_FILE_DEPENDENCIES _file)
 
-   GET_SOURCE_FILE_PROPERTY(_deps ${_file} OBJECT_DEPENDS)
-   IF (_deps)
-      SET(_deps ${_deps} ${ARGN})
-   ELSE (_deps)
-      SET(_deps ${ARGN})
-   ENDIF (_deps)
+   get_source_file_property(_deps ${_file} OBJECT_DEPENDS)
+   if (_deps)
+      set(_deps ${_deps} ${ARGN})
+   else ()
+      set(_deps ${ARGN})
+   endif ()
 
-   SET_SOURCE_FILES_PROPERTIES(${_file} PROPERTIES OBJECT_DEPENDS "${_deps}")
+   set_source_files_properties(${_file} PROPERTIES OBJECT_DEPENDS "${_deps}")
 
-ENDMACRO(ADD_FILE_DEPENDENCIES)
+endmacro()
diff --git a/Modules/AutomocInfo.cmake.in b/Modules/AutomocInfo.cmake.in
index 13f21617b..640bf70a0 100644
--- a/Modules/AutomocInfo.cmake.in
+++ b/Modules/AutomocInfo.cmake.in
@@ -1,7 +1,6 @@
 set(AM_SOURCES @_moc_files@ )
 set(AM_HEADERS @_moc_headers@ )
 set(AM_MOC_COMPILE_DEFINITIONS @_moc_compile_defs@)
-set(AM_MOC_DEFINITIONS @_moc_defs@)
 set(AM_MOC_INCLUDES @_moc_incs@)
 set(AM_MOC_OPTIONS @_moc_options@)
 set(AM_CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE "@CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE@")
diff --git a/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in b/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in
index 9f7f03e27..b1c4fdf81 100644
--- a/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in
+++ b/Modules/BasicConfigVersion-AnyNewerVersion.cmake.in
@@ -1,5 +1,5 @@
 # This is a basic version file for the Config-mode of find_package().
-# It is used by WriteBasicConfigVersionFile.cmake as input file for configure_file()
+# It is used by write_basic_package_version_file() as input file for configure_file()
 # to create a version-file which can be installed along a config.cmake file.
 #
 # The created file sets PACKAGE_VERSION_EXACT if the current version string and
diff --git a/Modules/BasicConfigVersion-SameMajorVersion.cmake.in b/Modules/BasicConfigVersion-SameMajorVersion.cmake.in
index 7bcea88a5..4acd9bb5e 100644
--- a/Modules/BasicConfigVersion-SameMajorVersion.cmake.in
+++ b/Modules/BasicConfigVersion-SameMajorVersion.cmake.in
@@ -1,5 +1,5 @@
 # This is a basic version file for the Config-mode of find_package().
-# It is used by WriteBasicConfigVersionFile.cmake as input file for configure_file()
+# It is used by write_basic_package_version_file() as input file for configure_file()
 # to create a version-file which can be installed along a config.cmake file.
 #
 # The created file sets PACKAGE_VERSION_EXACT if the current version string and
diff --git a/Modules/BundleUtilities.cmake b/Modules/BundleUtilities.cmake
index 0143d593d..4557be6e0 100644
--- a/Modules/BundleUtilities.cmake
+++ b/Modules/BundleUtilities.cmake
@@ -184,17 +184,17 @@ function(get_bundle_main_executable bundle result_var)
       if(line_is_main_executable)
         string(REGEX REPLACE "^.*<string>(.*)</string>.*$" "\\1" bundle_executable "${line}")
         break()
-      endif(line_is_main_executable)
+      endif()
 
       if(line MATCHES "^.*<key>CFBundleExecutable</key>.*$")
         set(line_is_main_executable 1)
-      endif(line MATCHES "^.*<key>CFBundleExecutable</key>.*$")
-    endforeach(line)
+      endif()
+    endforeach()
 
     if(NOT "${bundle_executable}" STREQUAL "")
       if(EXISTS "${bundle}/Contents/MacOS/${bundle_executable}")
         set(result "${bundle}/Contents/MacOS/${bundle_executable}")
-      else(EXISTS "${bundle}/Contents/MacOS/${bundle_executable}")
+      else()
 
         # Ultimate goal:
         # If not in "Contents/MacOS" then scan the bundle for matching files. If
@@ -207,9 +207,9 @@ function(get_bundle_main_executable bundle result_var)
         # for the bundle to be in Contents/MacOS, it's an error if it's not:
         #
         set(result "error: '${bundle}/Contents/MacOS/${bundle_executable}' does not exist")
-      endif(EXISTS "${bundle}/Contents/MacOS/${bundle_executable}")
-    endif(NOT "${bundle_executable}" STREQUAL "")
-  else(EXISTS "${bundle}/Contents/Info.plist")
+      endif()
+    endif()
+  else()
     #
     # More inclusive technique... (This one would work on Windows and Linux
     # too, if a developer followed the typical Mac bundle naming convention...)
@@ -217,10 +217,10 @@ function(get_bundle_main_executable bundle result_var)
     # If there is no Info.plist file, try to find an executable with the same
     # base name as the .app directory:
     #
-  endif(EXISTS "${bundle}/Contents/Info.plist")
+  endif()
 
   set(${result_var} "${result}" PARENT_SCOPE)
-endfunction(get_bundle_main_executable)
+endfunction()
 
 
 function(get_dotapp_dir exe dotapp_dir_var)
@@ -240,9 +240,9 @@ function(get_dotapp_dir exe dotapp_dir_var)
       if(sname MATCHES "\\.app$")
         set(done 1)
         set(dotapp_dir "${sdir}/${sname}")
-      endif(sname MATCHES "\\.app$")
-    endwhile(NOT ${done})
-  else(s MATCHES "^.*/.*\\.app/.*$")
+      endif()
+    endwhile()
+  else()
     # Otherwise use a directory containing the exe
     #   (typical of a non-bundle executable on Mac, Windows or Linux)
     #
@@ -250,14 +250,14 @@ function(get_dotapp_dir exe dotapp_dir_var)
     if(is_executable)
       get_filename_component(sdir "${s}" PATH)
       set(dotapp_dir "${sdir}")
-    else(is_executable)
+    else()
       set(dotapp_dir "${s}")
-    endif(is_executable)
-  endif(s MATCHES "^.*/.*\\.app/.*$")
+    endif()
+  endif()
 
 
   set(${dotapp_dir_var} "${dotapp_dir}" PARENT_SCOPE)
-endfunction(get_dotapp_dir)
+endfunction()
 
 
 function(get_bundle_and_executable app bundle_var executable_var valid_var)
@@ -273,13 +273,13 @@ function(get_bundle_and_executable app bundle_var executable_var valid_var)
           set(${executable_var} "${executable}" PARENT_SCOPE)
           set(valid 1)
           #message(STATUS "info: handled .app directory case...")
-        else(EXISTS "${app}" AND EXISTS "${executable}")
+        else()
           message(STATUS "warning: *NOT* handled - .app directory case...")
-        endif(EXISTS "${app}" AND EXISTS "${executable}")
-      else(app MATCHES "\\.app$")
+        endif()
+      else()
         message(STATUS "warning: *NOT* handled - directory but not .app case...")
-      endif(app MATCHES "\\.app$")
-    else(IS_DIRECTORY "${app}")
+      endif()
+    else()
       # Is it an executable file?
       is_file_executable("${app}" is_executable)
       if(is_executable)
@@ -296,21 +296,21 @@ function(get_bundle_and_executable app bundle_var executable_var valid_var)
           set(valid 1)
           #message(STATUS "info: handled executable file in any dir case...")
         endif()
-      else(is_executable)
+      else()
         message(STATUS "warning: *NOT* handled - not .app dir, not executable file...")
-      endif(is_executable)
-    endif(IS_DIRECTORY "${app}")
-  else(EXISTS "${app}")
+      endif()
+    endif()
+  else()
     message(STATUS "warning: *NOT* handled - directory/file does not exist...")
-  endif(EXISTS "${app}")
+  endif()
 
   if(NOT valid)
     set(${bundle_var} "error: not a bundle" PARENT_SCOPE)
     set(${executable_var} "error: not a bundle" PARENT_SCOPE)
-  endif(NOT valid)
+  endif()
 
   set(${valid_var} ${valid} PARENT_SCOPE)
-endfunction(get_bundle_and_executable)
+endfunction()
 
 
 function(get_bundle_all_executables bundle exes_var)
@@ -321,11 +321,11 @@ function(get_bundle_all_executables bundle exes_var)
     is_file_executable("${f}" is_executable)
     if(is_executable)
       set(exes ${exes} "${f}")
-    endif(is_executable)
-  endforeach(f)
+    endif()
+  endforeach()
 
   set(${exes_var} "${exes}" PARENT_SCOPE)
-endfunction(get_bundle_all_executables)
+endfunction()
 
 
 function(get_item_key item key_var)
@@ -335,7 +335,7 @@ function(get_item_key item key_var)
   endif()
   string(REGEX REPLACE "\\." "_" ${key_var} "${item_name}")
   set(${key_var} ${${key_var}} PARENT_SCOPE)
-endfunction(get_item_key)
+endfunction()
 
 
 function(clear_bundle_keys keys_var)
@@ -346,9 +346,9 @@ function(clear_bundle_keys keys_var)
     set(${key}_EMBEDDED_ITEM PARENT_SCOPE)
     set(${key}_RESOLVED_EMBEDDED_ITEM PARENT_SCOPE)
     set(${key}_COPYFLAG PARENT_SCOPE)
-  endforeach(key)
+  endforeach()
   set(${keys_var} PARENT_SCOPE)
-endfunction(clear_bundle_keys)
+endfunction()
 
 
 function(set_bundle_key_values keys_var context item exepath dirs copyflag)
@@ -370,12 +370,12 @@ function(set_bundle_key_values keys_var context item exepath dirs copyflag)
       # opening "${item_name}.framework/" to the closing "/${item_name}":
       #
       string(REGEX REPLACE "^.*(${item_name}.framework/.*/${item_name}).*$" "${default_embedded_path}/\\1" embedded_item "${item}")
-    else(item MATCHES "[^/]+\\.framework/")
+    else()
       # For other items, just use the same name as the original, but in the
       # embedded path:
       #
       set(embedded_item "${default_embedded_path}/${item_name}")
-    endif(item MATCHES "[^/]+\\.framework/")
+    endif()
 
     # Replace @executable_path and resolve ".." references:
     #
@@ -391,7 +391,7 @@ function(set_bundle_key_values keys_var context item exepath dirs copyflag)
     #
     if(NOT copyflag)
       set(resolved_embedded_item "${resolved_item}")
-    endif(NOT copyflag)
+    endif()
 
     set(${keys_var} ${${keys_var}} PARENT_SCOPE)
     set(${key}_ITEM "${item}" PARENT_SCOPE)
@@ -400,10 +400,10 @@ function(set_bundle_key_values keys_var context item exepath dirs copyflag)
     set(${key}_EMBEDDED_ITEM "${embedded_item}" PARENT_SCOPE)
     set(${key}_RESOLVED_EMBEDDED_ITEM "${resolved_embedded_item}" PARENT_SCOPE)
     set(${key}_COPYFLAG "${copyflag}" PARENT_SCOPE)
-  else(NOT length_before EQUAL length_after)
+  else()
     #message("warning: item key '${key}' already in the list, subsequent references assumed identical to first")
-  endif(NOT length_before EQUAL length_after)
-endfunction(set_bundle_key_values)
+  endif()
+endfunction()
 
 
 function(get_bundle_keys app libs dirs keys_var)
@@ -432,8 +432,8 @@ function(get_bundle_keys app libs dirs keys_var)
       get_prerequisites("${lib}" prereqs 1 1 "${exepath}" "${dirs}")
       foreach(pr ${prereqs})
         set_bundle_key_values(${keys_var} "${lib}" "${pr}" "${exepath}" "${dirs}" 1)
-      endforeach(pr)
-    endforeach(lib)
+      endforeach()
+    endforeach()
 
     # For each executable found in the bundle, accumulate keys as we go.
     # The list of keys should be complete when all prerequisites of all
@@ -450,8 +450,8 @@ function(get_bundle_keys app libs dirs keys_var)
       get_prerequisites("${exe}" prereqs 1 1 "${exepath}" "${dirs}")
       foreach(pr ${prereqs})
         set_bundle_key_values(${keys_var} "${exe}" "${pr}" "${exepath}" "${dirs}" 1)
-      endforeach(pr)
-    endforeach(exe)
+      endforeach()
+    endforeach()
 
     # Propagate values to caller's scope:
     #
@@ -463,9 +463,9 @@ function(get_bundle_keys app libs dirs keys_var)
       set(${key}_EMBEDDED_ITEM "${${key}_EMBEDDED_ITEM}" PARENT_SCOPE)
       set(${key}_RESOLVED_EMBEDDED_ITEM "${${key}_RESOLVED_EMBEDDED_ITEM}" PARENT_SCOPE)
       set(${key}_COPYFLAG "${${key}_COPYFLAG}" PARENT_SCOPE)
-    endforeach(key)
-  endif(valid)
-endfunction(get_bundle_keys)
+    endforeach()
+  endif()
+endfunction()
 
 
 function(copy_resolved_item_into_bundle resolved_item resolved_embedded_item)
@@ -485,10 +485,10 @@ function(copy_resolved_item_into_bundle resolved_item resolved_embedded_item)
     execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}" "${resolved_embedded_item}")
     if(UNIX AND NOT APPLE)
       file(RPATH_REMOVE FILE "${resolved_embedded_item}")
-    endif(UNIX AND NOT APPLE)
+    endif()
   endif()
 
-endfunction(copy_resolved_item_into_bundle)
+endfunction()
 
 
 function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_item)
@@ -527,10 +527,10 @@ function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_ite
     endif()
     if(UNIX AND NOT APPLE)
       file(RPATH_REMOVE FILE "${resolved_embedded_item}")
-    endif(UNIX AND NOT APPLE)
+    endif()
   endif()
 
-endfunction(copy_resolved_framework_into_bundle)
+endfunction()
 
 
 function(fixup_bundle_item resolved_embedded_item exepath dirs)
@@ -580,10 +580,10 @@ function(fixup_bundle_item resolved_embedded_item exepath dirs)
 
     if(NOT "${${rkey}_EMBEDDED_ITEM}" STREQUAL "")
       set(changes ${changes} "-change" "${pr}" "${${rkey}_EMBEDDED_ITEM}")
-    else(NOT "${${rkey}_EMBEDDED_ITEM}" STREQUAL "")
+    else()
       message("warning: unexpected reference to '${pr}'")
-    endif(NOT "${${rkey}_EMBEDDED_ITEM}" STREQUAL "")
-  endforeach(pr)
+    endif()
+  endforeach()
 
   if(BU_CHMOD_BUNDLE_ITEMS)
     execute_process(COMMAND chmod u+w "${resolved_embedded_item}")
@@ -595,7 +595,7 @@ function(fixup_bundle_item resolved_embedded_item exepath dirs)
   execute_process(COMMAND install_name_tool
     ${changes} -id "${${ikey}_EMBEDDED_ITEM}" "${resolved_embedded_item}"
   )
-endfunction(fixup_bundle_item)
+endfunction()
 
 
 function(fixup_bundle app libs dirs)
@@ -620,9 +620,9 @@ function(fixup_bundle app libs dirs)
       math(EXPR i ${i}+1)
       if(${${key}_COPYFLAG})
         message(STATUS "${i}/${n}: copying '${${key}_RESOLVED_ITEM}'")
-      else(${${key}_COPYFLAG})
+      else()
         message(STATUS "${i}/${n}: *NOT* copying '${${key}_RESOLVED_ITEM}'")
-      endif(${${key}_COPYFLAG})
+      endif()
 
       set(show_status 0)
       if(show_status)
@@ -634,7 +634,7 @@ function(fixup_bundle app libs dirs)
         message(STATUS "resolved_embedded_item='${${key}_RESOLVED_EMBEDDED_ITEM}'")
         message(STATUS "copyflag='${${key}_COPYFLAG}'")
         message(STATUS "")
-      endif(show_status)
+      endif()
 
       if(${${key}_COPYFLAG})
         set(item "${${key}_ITEM}")
@@ -645,8 +645,8 @@ function(fixup_bundle app libs dirs)
           copy_resolved_item_into_bundle("${${key}_RESOLVED_ITEM}"
             "${${key}_RESOLVED_EMBEDDED_ITEM}")
         endif()
-      endif(${${key}_COPYFLAG})
-    endforeach(key)
+      endif()
+    endforeach()
 
     message(STATUS "fixup_bundle: fixing...")
     foreach(key ${keys})
@@ -654,28 +654,28 @@ function(fixup_bundle app libs dirs)
       if(APPLE)
         message(STATUS "${i}/${n}: fixing up '${${key}_RESOLVED_EMBEDDED_ITEM}'")
         fixup_bundle_item("${${key}_RESOLVED_EMBEDDED_ITEM}" "${exepath}" "${dirs}")
-      else(APPLE)
+      else()
         message(STATUS "${i}/${n}: fix-up not required on this platform '${${key}_RESOLVED_EMBEDDED_ITEM}'")
-      endif(APPLE)
-    endforeach(key)
+      endif()
+    endforeach()
 
     message(STATUS "fixup_bundle: cleaning up...")
     clear_bundle_keys(keys)
 
     message(STATUS "fixup_bundle: verifying...")
     verify_app("${app}")
-  else(valid)
+  else()
     message(SEND_ERROR "error: fixup_bundle: not a valid bundle")
-  endif(valid)
+  endif()
 
   message(STATUS "fixup_bundle: done")
-endfunction(fixup_bundle)
+endfunction()
 
 
 function(copy_and_fixup_bundle src dst libs dirs)
   execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${src}" "${dst}")
   fixup_bundle("${dst}" "${libs}" "${dirs}")
-endfunction(copy_and_fixup_bundle)
+endfunction()
 
 
 function(verify_bundle_prerequisites bundle result_var info_var)
@@ -720,23 +720,23 @@ function(verify_bundle_prerequisites bundle result_var info_var)
             set(external_prereqs ${external_prereqs} "${p}")
           endif()
         endif()
-      endforeach(p)
+      endforeach()
 
       if(external_prereqs)
         # Found non-system/somehow-unacceptable prerequisites:
         set(result 0)
         set(info ${info} "external prerequisites found:\nf='${f}'\nexternal_prereqs='${external_prereqs}'\n")
-      endif(external_prereqs)
-    endif(is_executable)
-  endforeach(f)
+      endif()
+    endif()
+  endforeach()
 
   if(result)
     set(info "Verified ${count} executable files in '${bundle}'")
-  endif(result)
+  endif()
 
   set(${result_var} "${result}" PARENT_SCOPE)
   set(${info_var} "${info}" PARENT_SCOPE)
-endfunction(verify_bundle_prerequisites)
+endfunction()
 
 
 function(verify_bundle_symlinks bundle result_var info_var)
@@ -749,7 +749,7 @@ function(verify_bundle_symlinks bundle result_var info_var)
 
   set(${result_var} "${result}" PARENT_SCOPE)
   set(${info_var} "${info}" PARENT_SCOPE)
-endfunction(verify_bundle_symlinks)
+endfunction()
 
 
 function(verify_app app)
@@ -778,9 +778,9 @@ function(verify_app app)
     message(STATUS "verified='${verified}'")
     message(STATUS "info='${info}'")
     message(STATUS "")
-  endif(verified)
+  endif()
 
   if(NOT verified)
     message(FATAL_ERROR "error: verify_app failed")
-  endif(NOT verified)
-endfunction(verify_app)
+  endif()
+endfunction()
diff --git a/Modules/CMakeASM-ATTInformation.cmake b/Modules/CMakeASM-ATTInformation.cmake
index cb1f5d69c..675c13bb3 100644
--- a/Modules/CMakeASM-ATTInformation.cmake
+++ b/Modules/CMakeASM-ATTInformation.cmake
@@ -14,12 +14,12 @@
 
 # support for AT&T syntax assemblers, e.g. GNU as
 
-SET(ASM_DIALECT "-ATT")
+set(ASM_DIALECT "-ATT")
 # *.S files are supposed to be preprocessed, so they should not be passed to
 # assembler but should be processed by gcc
-SET(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS s;asm)
+set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS s;asm)
 
-SET(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <FLAGS> -o <OBJECT> <SOURCE>")
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <FLAGS> -o <OBJECT> <SOURCE>")
 
-INCLUDE(CMakeASMInformation)
-SET(ASM_DIALECT)
+include(CMakeASMInformation)
+set(ASM_DIALECT)
diff --git a/Modules/CMakeASMCompiler.cmake.in b/Modules/CMakeASMCompiler.cmake.in
index 2dc24b06d..8e58307e9 100644
--- a/Modules/CMakeASMCompiler.cmake.in
+++ b/Modules/CMakeASMCompiler.cmake.in
@@ -1,12 +1,12 @@
-SET(CMAKE_ASM@ASM_DIALECT@_COMPILER "@_CMAKE_ASM_COMPILER@")
-SET(CMAKE_ASM@ASM_DIALECT@_COMPILER_ARG1 "@_CMAKE_ASM_COMPILER_ARG1@")
-SET(CMAKE_AR "@CMAKE_AR@")
-SET(CMAKE_RANLIB "@CMAKE_RANLIB@")
-SET(CMAKE_LINKER "@CMAKE_LINKER@")
-SET(CMAKE_ASM@ASM_DIALECT@_COMPILER_LOADED 1)
-SET(CMAKE_ASM@ASM_DIALECT@_COMPILER_ID "@_CMAKE_ASM_COMPILER_ID@")
-SET(CMAKE_ASM@ASM_DIALECT@_COMPILER_ENV_VAR "@_CMAKE_ASM_COMPILER_ENV_VAR@")
+set(CMAKE_ASM@ASM_DIALECT@_COMPILER "@_CMAKE_ASM_COMPILER@")
+set(CMAKE_ASM@ASM_DIALECT@_COMPILER_ARG1 "@_CMAKE_ASM_COMPILER_ARG1@")
+set(CMAKE_AR "@CMAKE_AR@")
+set(CMAKE_RANLIB "@CMAKE_RANLIB@")
+set(CMAKE_LINKER "@CMAKE_LINKER@")
+set(CMAKE_ASM@ASM_DIALECT@_COMPILER_LOADED 1)
+set(CMAKE_ASM@ASM_DIALECT@_COMPILER_ID "@_CMAKE_ASM_COMPILER_ID@")
+set(CMAKE_ASM@ASM_DIALECT@_COMPILER_ENV_VAR "@_CMAKE_ASM_COMPILER_ENV_VAR@")
 
-SET(CMAKE_ASM@ASM_DIALECT@_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
-SET(CMAKE_ASM@ASM_DIALECT@_LINKER_PREFERENCE 0)
+set(CMAKE_ASM@ASM_DIALECT@_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_ASM@ASM_DIALECT@_LINKER_PREFERENCE 0)
 
diff --git a/Modules/CMakeASMInformation.cmake b/Modules/CMakeASMInformation.cmake
index b5f242033..dce162496 100644
--- a/Modules/CMakeASMInformation.cmake
+++ b/Modules/CMakeASMInformation.cmake
@@ -12,76 +12,76 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
-IF(UNIX)
-  SET(CMAKE_ASM${ASM_DIALECT}_OUTPUT_EXTENSION .o)
-ELSE(UNIX)
-  SET(CMAKE_ASM${ASM_DIALECT}_OUTPUT_EXTENSION .obj)
-ENDIF(UNIX)
+if(UNIX)
+  set(CMAKE_ASM${ASM_DIALECT}_OUTPUT_EXTENSION .o)
+else()
+  set(CMAKE_ASM${ASM_DIALECT}_OUTPUT_EXTENSION .obj)
+endif()
 
-SET(CMAKE_INCLUDE_FLAG_ASM${ASM_DIALECT} "-I")       # -I
-SET(CMAKE_BASE_NAME)
-GET_FILENAME_COMPONENT(CMAKE_BASE_NAME "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" NAME_WE)
+set(CMAKE_INCLUDE_FLAG_ASM${ASM_DIALECT} "-I")       # -I
+set(CMAKE_BASE_NAME)
+get_filename_component(CMAKE_BASE_NAME "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" NAME_WE)
 
-IF("${CMAKE_BASE_NAME}" STREQUAL "as")
-  SET(CMAKE_BASE_NAME gas)
-ENDIF("${CMAKE_BASE_NAME}" STREQUAL "as")
+if("${CMAKE_BASE_NAME}" STREQUAL "as")
+  set(CMAKE_BASE_NAME gas)
+endif()
 
 # Load compiler-specific information.
-SET(_INCLUDED_FILE "")
-IF(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
-  INCLUDE(Compiler/${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT} OPTIONAL  RESULT_VARIABLE _INCLUDED_FILE)
-ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
-IF(NOT _INCLUDED_FILE)
-  IF("ASM${ASM_DIALECT}" STREQUAL "ASM")
-    MESSAGE(STATUS "Warning: Did not find file Compiler/${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT}")
-  ENDIF("ASM${ASM_DIALECT}" STREQUAL "ASM")
-  INCLUDE(Platform/${CMAKE_BASE_NAME} OPTIONAL)
-ENDIF(NOT _INCLUDED_FILE)
-
-IF(CMAKE_SYSTEM_PROCESSOR)
-  INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL  RESULT_VARIABLE _INCLUDED_FILE)
-  IF(NOT _INCLUDED_FILE)
-    INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
-  ENDIF(NOT _INCLUDED_FILE)
-ENDIF(CMAKE_SYSTEM_PROCESSOR)
-
-INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT} OPTIONAL  RESULT_VARIABLE _INCLUDED_FILE)
-IF(NOT _INCLUDED_FILE)
-  INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL)
-ENDIF(NOT _INCLUDED_FILE)
+set(_INCLUDED_FILE "")
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
+  include(Compiler/${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT} OPTIONAL  RESULT_VARIABLE _INCLUDED_FILE)
+endif()
+if(NOT _INCLUDED_FILE)
+  if("ASM${ASM_DIALECT}" STREQUAL "ASM")
+    message(STATUS "Warning: Did not find file Compiler/${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT}")
+  endif()
+  include(Platform/${CMAKE_BASE_NAME} OPTIONAL)
+endif()
+
+if(CMAKE_SYSTEM_PROCESSOR)
+  include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL  RESULT_VARIABLE _INCLUDED_FILE)
+  if(NOT _INCLUDED_FILE)
+    include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
+  endif()
+endif()
+
+include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}-ASM${ASM_DIALECT} OPTIONAL  RESULT_VARIABLE _INCLUDED_FILE)
+if(NOT _INCLUDED_FILE)
+  include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL)
+endif()
 
 # Set default assembler file extensions:
-IF(NOT CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS)
-  SET(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS s;S;asm)
-ENDIF(NOT CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS)
+if(NOT CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS)
+  set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS s;S;asm)
+endif()
 
 
 # Support for CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT and friends:
-SET(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT "$ENV{ASM${ASM_DIALECT}FLAGS} ${CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT}")
+set(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT "$ENV{ASM${ASM_DIALECT}FLAGS} ${CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT}")
 # avoid just having a space as the initial value for the cache
-IF(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT STREQUAL " ")
-  SET(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT)
-ENDIF(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT STREQUAL " ")
-SET (CMAKE_ASM${ASM_DIALECT}_FLAGS "${CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT}" CACHE STRING
+if(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT STREQUAL " ")
+  set(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT)
+endif()
+set (CMAKE_ASM${ASM_DIALECT}_FLAGS "${CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT}" CACHE STRING
      "Flags used by the assembler during all build types.")
 
-IF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
 # default build type is none
-  IF(NOT CMAKE_NO_BUILD_TYPE)
-    SET (CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE_INIT} CACHE STRING
+  if(NOT CMAKE_NO_BUILD_TYPE)
+    set (CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE_INIT} CACHE STRING
       "Choose the type of build, options are: None, Debug Release RelWithDebInfo MinSizeRel.")
-  ENDIF(NOT CMAKE_NO_BUILD_TYPE)
-  SET (CMAKE_ASM${ASM_DIALECT}_FLAGS_DEBUG "${CMAKE_ASM${ASM_DIALECT}_FLAGS_DEBUG_INIT}" CACHE STRING
+  endif()
+  set (CMAKE_ASM${ASM_DIALECT}_FLAGS_DEBUG "${CMAKE_ASM${ASM_DIALECT}_FLAGS_DEBUG_INIT}" CACHE STRING
     "Flags used by the assembler during debug builds.")
-  SET (CMAKE_ASM${ASM_DIALECT}_FLAGS_MINSIZEREL "${CMAKE_ASM${ASM_DIALECT}_FLAGS_MINSIZEREL_INIT}" CACHE STRING
+  set (CMAKE_ASM${ASM_DIALECT}_FLAGS_MINSIZEREL "${CMAKE_ASM${ASM_DIALECT}_FLAGS_MINSIZEREL_INIT}" CACHE STRING
     "Flags used by the assembler during release minsize builds.")
-  SET (CMAKE_ASM${ASM_DIALECT}_FLAGS_RELEASE "${CMAKE_ASM${ASM_DIALECT}_FLAGS_RELEASE_INIT}" CACHE STRING
+  set (CMAKE_ASM${ASM_DIALECT}_FLAGS_RELEASE "${CMAKE_ASM${ASM_DIALECT}_FLAGS_RELEASE_INIT}" CACHE STRING
     "Flags used by the assembler during release builds.")
-  SET (CMAKE_ASM${ASM_DIALECT}_FLAGS_RELWITHDEBINFO "${CMAKE_ASM${ASM_DIALECT}_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
+  set (CMAKE_ASM${ASM_DIALECT}_FLAGS_RELWITHDEBINFO "${CMAKE_ASM${ASM_DIALECT}_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
     "Flags used by the assembler during Release with Debug Info builds.")
-ENDIF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+endif()
 
-MARK_AS_ADVANCED(CMAKE_ASM${ASM_DIALECT}_FLAGS
+mark_as_advanced(CMAKE_ASM${ASM_DIALECT}_FLAGS
                  CMAKE_ASM${ASM_DIALECT}_FLAGS_DEBUG
                  CMAKE_ASM${ASM_DIALECT}_FLAGS_MINSIZEREL
                  CMAKE_ASM${ASM_DIALECT}_FLAGS_RELEASE
@@ -89,42 +89,42 @@ MARK_AS_ADVANCED(CMAKE_ASM${ASM_DIALECT}_FLAGS
                 )
 
 
-IF(NOT CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT)
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <DEFINES> <FLAGS> -o <OBJECT> -c <SOURCE>")
-ENDIF(NOT CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT)
+if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT)
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <DEFINES> <FLAGS> -o <OBJECT> -c <SOURCE>")
+endif()
 
-IF(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY)
-  SET(CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY
+if(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY)
+  set(CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY
       "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS> "
       "<CMAKE_RANLIB> <TARGET> ")
-ENDIF(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_STATIC_LIBRARY)
+endif()
 
-IF(NOT CMAKE_ASM${ASM_DIALECT}_LINK_EXECUTABLE)
-  SET(CMAKE_ASM${ASM_DIALECT}_LINK_EXECUTABLE
+if(NOT CMAKE_ASM${ASM_DIALECT}_LINK_EXECUTABLE)
+  set(CMAKE_ASM${ASM_DIALECT}_LINK_EXECUTABLE
     "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <FLAGS> <CMAKE_ASM${ASM_DIALECT}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
-ENDIF(NOT CMAKE_ASM${ASM_DIALECT}_LINK_EXECUTABLE)
+endif()
 
-IF(NOT CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG)
-  SET(CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_ASM${ASM_DIALECT}_FLAG})
-ENDIF()
+if(NOT CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG)
+  set(CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_ASM${ASM_DIALECT}_FLAG})
+endif()
 
-IF(NOT CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG_SEP)
-  SET(CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_ASM${ASM_DIALECT}_FLAG_SEP})
-ENDIF()
+if(NOT CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG_SEP)
+  set(CMAKE_EXECUTABLE_RUNTIME_ASM${ASM_DIALECT}_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_ASM${ASM_DIALECT}_FLAG_SEP})
+endif()
 
-IF(NOT CMAKE_EXECUTABLE_RPATH_LINK_ASM${ASM_DIALECT}_FLAG)
-  SET(CMAKE_EXECUTABLE_RPATH_LINK_ASM${ASM_DIALECT}_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_ASM${ASM_DIALECT}_FLAG})
-ENDIF()
+if(NOT CMAKE_EXECUTABLE_RPATH_LINK_ASM${ASM_DIALECT}_FLAG)
+  set(CMAKE_EXECUTABLE_RPATH_LINK_ASM${ASM_DIALECT}_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_ASM${ASM_DIALECT}_FLAG})
+endif()
 
 # to be done
-IF(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_LIBRARY)
-  SET(CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_LIBRARY)
-ENDIF(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_LIBRARY)
+if(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_LIBRARY)
+  set(CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_LIBRARY)
+endif()
 
-IF(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_MODULE)
-  SET(CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_MODULE)
-ENDIF(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_MODULE)
+if(NOT CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_MODULE)
+  set(CMAKE_ASM${ASM_DIALECT}_CREATE_SHARED_MODULE)
+endif()
 
 
-SET(CMAKE_ASM${ASM_DIALECT}_INFOMATION_LOADED 1)
+set(CMAKE_ASM${ASM_DIALECT}_INFOMATION_LOADED 1)
 
diff --git a/Modules/CMakeASM_MASMInformation.cmake b/Modules/CMakeASM_MASMInformation.cmake
index 4e1386fab..eb105ab10 100644
--- a/Modules/CMakeASM_MASMInformation.cmake
+++ b/Modules/CMakeASM_MASMInformation.cmake
@@ -14,11 +14,11 @@
 
 # support for the MS assembler, masm and masm64
 
-SET(ASM_DIALECT "_MASM")
+set(ASM_DIALECT "_MASM")
 
-SET(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS asm)
+set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS asm)
 
-SET(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <FLAGS> /c  /Fo <OBJECT> <SOURCE>")
+set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <FLAGS> /c  /Fo <OBJECT> <SOURCE>")
 
-INCLUDE(CMakeASMInformation)
-SET(ASM_DIALECT)
+include(CMakeASMInformation)
+set(ASM_DIALECT)
diff --git a/Modules/CMakeASM_NASMInformation.cmake b/Modules/CMakeASM_NASMInformation.cmake
index 9da7d306c..7058fc7ae 100644
--- a/Modules/CMakeASM_NASMInformation.cmake
+++ b/Modules/CMakeASM_NASMInformation.cmake
@@ -19,21 +19,21 @@ set(CMAKE_ASM_NASM_SOURCE_FILE_EXTENSIONS nasm asm)
 if(NOT CMAKE_ASM_NASM_OBJECT_FORMAT)
   if(WIN32)
     if(CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)
-      SET(CMAKE_ASM_NASM_OBJECT_FORMAT win64)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT win64)
     else()
-      SET(CMAKE_ASM_NASM_OBJECT_FORMAT win32)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT win32)
     endif()
   elseif(APPLE)
     if(CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)
-      SET(CMAKE_ASM_NASM_OBJECT_FORMAT macho64)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT macho64)
     else()
-      SET(CMAKE_ASM_NASM_OBJECT_FORMAT macho)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT macho)
     endif()
   else()
     if(CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)
-      SET(CMAKE_ASM_NASM_OBJECT_FORMAT elf64)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT elf64)
     else()
-      SET(CMAKE_ASM_NASM_OBJECT_FORMAT elf)
+      set(CMAKE_ASM_NASM_OBJECT_FORMAT elf)
     endif()
   endif()
 endif()
diff --git a/Modules/CMakeAddNewLanguage.txt b/Modules/CMakeAddNewLanguage.txt
index 203c39dfe..6a30dd88b 100644
--- a/Modules/CMakeAddNewLanguage.txt
+++ b/Modules/CMakeAddNewLanguage.txt
@@ -1,7 +1,7 @@
 CMakeDetermine(LANG)Compiler.cmake  -> this should find the compiler for LANG and configure CMake(LANG)Compiler.cmake.in
 
 CMake(LANG)Compiler.cmake.in  -> used by CMakeDetermine(LANG)Compiler.cmake
-    This file is used to store compiler information and is copied down into try 
+    This file is used to store compiler information and is copied down into try
     compile directories so that try compiles do not need to re-determine and test the LANG
 
 CMakeTest(LANG)Compiler.cmake -> test the compiler and set:
diff --git a/Modules/CMakeBackwardCompatibilityC.cmake b/Modules/CMakeBackwardCompatibilityC.cmake
index 00e568830..e3b6c823e 100644
--- a/Modules/CMakeBackwardCompatibilityC.cmake
+++ b/Modules/CMakeBackwardCompatibilityC.cmake
@@ -13,28 +13,28 @@
 #  License text for the above reference.)
 
 # Nothing here yet
-IF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
-  INCLUDE(CMakeVS7BackwardCompatibility)
-  SET(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
-ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
-IF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
-  INCLUDE(CMakeVS6BackwardCompatibility)
-  SET(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
-ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
-
-IF(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
+if(CMAKE_GENERATOR MATCHES "Visual Studio 7")
+  include(CMakeVS7BackwardCompatibility)
+  set(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
+endif()
+if(CMAKE_GENERATOR MATCHES "Visual Studio 6")
+  include(CMakeVS6BackwardCompatibility)
+  set(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
+endif()
+
+if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
   # Old CMake versions did not support OS X universal binaries anyway,
   # so just get through this with at least some size for the types.
-  LIST(LENGTH CMAKE_OSX_ARCHITECTURES NUM_ARCHS)
-  IF(${NUM_ARCHS} GREATER 1)
-    IF(NOT DEFINED CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
-      MESSAGE(WARNING "This module does not work with OS X universal binaries.")
-      SET(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES 1)
-      LIST(GET CMAKE_OSX_ARCHITECTURES 0 CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
-    ENDIF()
-  ENDIF()
-
-  INCLUDE (CheckTypeSize)
+  list(LENGTH CMAKE_OSX_ARCHITECTURES NUM_ARCHS)
+  if(${NUM_ARCHS} GREATER 1)
+    if(NOT DEFINED CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+      message(WARNING "This module does not work with OS X universal binaries.")
+      set(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES 1)
+      list(GET CMAKE_OSX_ARCHITECTURES 0 CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+    endif()
+  endif()
+
+  include (CheckTypeSize)
   CHECK_TYPE_SIZE(int      CMAKE_SIZEOF_INT)
   CHECK_TYPE_SIZE(long     CMAKE_SIZEOF_LONG)
   CHECK_TYPE_SIZE("void*"  CMAKE_SIZEOF_VOID_P)
@@ -43,52 +43,52 @@ IF(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
   CHECK_TYPE_SIZE(float    CMAKE_SIZEOF_FLOAT)
   CHECK_TYPE_SIZE(double   CMAKE_SIZEOF_DOUBLE)
 
-  INCLUDE (CheckIncludeFile)
+  include (CheckIncludeFile)
   CHECK_INCLUDE_FILE("limits.h"       CMAKE_HAVE_LIMITS_H)
   CHECK_INCLUDE_FILE("unistd.h"       CMAKE_HAVE_UNISTD_H)
   CHECK_INCLUDE_FILE("pthread.h"      CMAKE_HAVE_PTHREAD_H)
 
-  INCLUDE (CheckIncludeFiles)
+  include (CheckIncludeFiles)
   CHECK_INCLUDE_FILES("sys/types.h;sys/prctl.h"    CMAKE_HAVE_SYS_PRCTL_H)
 
-  INCLUDE (TestBigEndian)
+  include (TestBigEndian)
   TEST_BIG_ENDIAN(CMAKE_WORDS_BIGENDIAN)
-  INCLUDE (FindX11)
+  include (FindX11)
 
-  IF("${X11_X11_INCLUDE_PATH}" MATCHES "^/usr/include$")
-    SET (CMAKE_X_CFLAGS "" CACHE STRING "X11 extra flags.")
-  ELSE("${X11_X11_INCLUDE_PATH}" MATCHES "^/usr/include$")
-    SET (CMAKE_X_CFLAGS "-I${X11_X11_INCLUDE_PATH}" CACHE STRING
+  if("${X11_X11_INCLUDE_PATH}" MATCHES "^/usr/include$")
+    set (CMAKE_X_CFLAGS "" CACHE STRING "X11 extra flags.")
+  else()
+    set (CMAKE_X_CFLAGS "-I${X11_X11_INCLUDE_PATH}" CACHE STRING
          "X11 extra flags.")
-  ENDIF("${X11_X11_INCLUDE_PATH}" MATCHES "^/usr/include$")
-  SET (CMAKE_X_LIBS "${X11_LIBRARIES}" CACHE STRING
+  endif()
+  set (CMAKE_X_LIBS "${X11_LIBRARIES}" CACHE STRING
        "Libraries and options used in X11 programs.")
-  SET (CMAKE_HAS_X "${X11_FOUND}" CACHE INTERNAL "Is X11 around.")
+  set (CMAKE_HAS_X "${X11_FOUND}" CACHE INTERNAL "Is X11 around.")
 
-  INCLUDE (FindThreads)
+  include (FindThreads)
 
-  SET (CMAKE_THREAD_LIBS        "${CMAKE_THREAD_LIBS_INIT}" CACHE STRING 
+  set (CMAKE_THREAD_LIBS        "${CMAKE_THREAD_LIBS_INIT}" CACHE STRING
     "Thread library used.")
 
-  SET (CMAKE_USE_PTHREADS       "${CMAKE_USE_PTHREADS_INIT}" CACHE BOOL
+  set (CMAKE_USE_PTHREADS       "${CMAKE_USE_PTHREADS_INIT}" CACHE BOOL
      "Use the pthreads library.")
 
-  SET (CMAKE_USE_WIN32_THREADS  "${CMAKE_USE_WIN32_THREADS_INIT}" CACHE BOOL
+  set (CMAKE_USE_WIN32_THREADS  "${CMAKE_USE_WIN32_THREADS_INIT}" CACHE BOOL
        "Use the win32 thread library.")
 
-  SET (CMAKE_HP_PTHREADS        ${CMAKE_HP_PTHREADS_INIT} CACHE BOOL
+  set (CMAKE_HP_PTHREADS        ${CMAKE_HP_PTHREADS_INIT} CACHE BOOL
      "Use HP pthreads.")
 
-  SET (CMAKE_USE_SPROC          ${CMAKE_USE_SPROC_INIT} CACHE BOOL 
+  set (CMAKE_USE_SPROC          ${CMAKE_USE_SPROC_INIT} CACHE BOOL
      "Use sproc libs.")
 
-  IF(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
-    SET(CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
-    SET(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
-  ENDIF()
-ENDIF(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
+  if(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+    set(CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+    set(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
+  endif()
+endif()
 
-MARK_AS_ADVANCED(
+mark_as_advanced(
 CMAKE_HP_PTHREADS
 CMAKE_THREAD_LIBS
 CMAKE_USE_PTHREADS
diff --git a/Modules/CMakeBackwardCompatibilityCXX.cmake b/Modules/CMakeBackwardCompatibilityCXX.cmake
index 707bbde50..cfc1d91f9 100644
--- a/Modules/CMakeBackwardCompatibilityCXX.cmake
+++ b/Modules/CMakeBackwardCompatibilityCXX.cmake
@@ -1,10 +1,10 @@
 # - define a bunch of backwards compatibility variables
-#  CMAKE_ANSI_CXXFLAGS - flag for ansi c++ 
+#  CMAKE_ANSI_CXXFLAGS - flag for ansi c++
 #  CMAKE_HAS_ANSI_STRING_STREAM - has <strstream>
-#  INCLUDE(TestForANSIStreamHeaders)
-#  INCLUDE(CheckIncludeFileCXX)
-#  INCLUDE(TestForSTDNamespace)
-#  INCLUDE(TestForANSIForScope)
+#  include(TestForANSIStreamHeaders)
+#  include(CheckIncludeFileCXX)
+#  include(TestForSTDNamespace)
+#  include(TestForANSIForScope)
 
 #=============================================================================
 # Copyright 2002-2009 Kitware, Inc.
@@ -19,36 +19,36 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
-IF(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
+if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
   # check for some ANSI flags in the CXX compiler if it is not gnu
-  IF(NOT CMAKE_COMPILER_IS_GNUCXX)
-    INCLUDE(TestCXXAcceptsFlag)
-    SET(CMAKE_TRY_ANSI_CXX_FLAGS "")
-    IF(CMAKE_SYSTEM MATCHES "IRIX.*")
-      SET(CMAKE_TRY_ANSI_CXX_FLAGS "-LANG:std")
-    ENDIF(CMAKE_SYSTEM MATCHES "IRIX.*")
-    IF(CMAKE_SYSTEM MATCHES "OSF.*")
-      SET(CMAKE_TRY_ANSI_CXX_FLAGS "-std strict_ansi -nopure_cname")
-    ENDIF(CMAKE_SYSTEM MATCHES "OSF.*")
+  if(NOT CMAKE_COMPILER_IS_GNUCXX)
+    include(TestCXXAcceptsFlag)
+    set(CMAKE_TRY_ANSI_CXX_FLAGS "")
+    if(CMAKE_SYSTEM MATCHES "IRIX.*")
+      set(CMAKE_TRY_ANSI_CXX_FLAGS "-LANG:std")
+    endif()
+    if(CMAKE_SYSTEM MATCHES "OSF.*")
+      set(CMAKE_TRY_ANSI_CXX_FLAGS "-std strict_ansi -nopure_cname")
+    endif()
     # if CMAKE_TRY_ANSI_CXX_FLAGS has something in it, see
     # if the compiler accepts it
-    IF( CMAKE_TRY_ANSI_CXX_FLAGS MATCHES ".+")
+    if( CMAKE_TRY_ANSI_CXX_FLAGS MATCHES ".+")
       CHECK_CXX_ACCEPTS_FLAG(${CMAKE_TRY_ANSI_CXX_FLAGS} CMAKE_CXX_ACCEPTS_FLAGS)
       # if the compiler liked the flag then set CMAKE_ANSI_CXXFLAGS
       # to the flag
-      IF(CMAKE_CXX_ACCEPTS_FLAGS)
-        SET(CMAKE_ANSI_CXXFLAGS ${CMAKE_TRY_ANSI_CXX_FLAGS} CACHE INTERNAL 
+      if(CMAKE_CXX_ACCEPTS_FLAGS)
+        set(CMAKE_ANSI_CXXFLAGS ${CMAKE_TRY_ANSI_CXX_FLAGS} CACHE INTERNAL
         "What flags are required by the c++ compiler to make it ansi." )
-      ENDIF(CMAKE_CXX_ACCEPTS_FLAGS)
-    ENDIF( CMAKE_TRY_ANSI_CXX_FLAGS MATCHES ".+")
-  ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
-  SET(CMAKE_CXX_FLAGS_SAVE ${CMAKE_CXX_FLAGS})
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_ANSI_CXXFLAGS}")
-  INCLUDE(TestForANSIStreamHeaders)
-  INCLUDE(CheckIncludeFileCXX)
-  INCLUDE(TestForSTDNamespace)
-  INCLUDE(TestForANSIForScope)
-  INCLUDE(TestForSSTREAM)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_SAVE}")
-ENDIF(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
+      endif()
+    endif()
+  endif()
+  set(CMAKE_CXX_FLAGS_SAVE ${CMAKE_CXX_FLAGS})
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_ANSI_CXXFLAGS}")
+  include(TestForANSIStreamHeaders)
+  include(CheckIncludeFileCXX)
+  include(TestForSTDNamespace)
+  include(TestForANSIForScope)
+  include(TestForSSTREAM)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_SAVE}")
+endif()
 
diff --git a/Modules/CMakeBorlandFindMake.cmake b/Modules/CMakeBorlandFindMake.cmake
index 1ef28df83..43b31c695 100644
--- a/Modules/CMakeBorlandFindMake.cmake
+++ b/Modules/CMakeBorlandFindMake.cmake
@@ -12,6 +12,6 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
-SET (CMAKE_MAKE_PROGRAM "make" CACHE STRING
+set (CMAKE_MAKE_PROGRAM "make" CACHE STRING
      "Program used to build from makefiles.")
-MARK_AS_ADVANCED(CMAKE_MAKE_PROGRAM)
+mark_as_advanced(CMAKE_MAKE_PROGRAM)
diff --git a/Modules/CMakeCCompiler.cmake.in b/Modules/CMakeCCompiler.cmake.in
index ded8cf6ab..d74dcdcee 100644
--- a/Modules/CMakeCCompiler.cmake.in
+++ b/Modules/CMakeCCompiler.cmake.in
@@ -1,53 +1,55 @@
-SET(CMAKE_C_COMPILER "@CMAKE_C_COMPILER@")
-SET(CMAKE_C_COMPILER_ARG1 "@CMAKE_C_COMPILER_ARG1@")
-SET(CMAKE_C_COMPILER_ID "@CMAKE_C_COMPILER_ID@")
-SET(CMAKE_C_COMPILER_VERSION "@CMAKE_C_COMPILER_VERSION@")
-SET(CMAKE_C_PLATFORM_ID "@CMAKE_C_PLATFORM_ID@")
+set(CMAKE_C_COMPILER "@CMAKE_C_COMPILER@")
+set(CMAKE_C_COMPILER_ARG1 "@CMAKE_C_COMPILER_ARG1@")
+set(CMAKE_C_COMPILER_ID "@CMAKE_C_COMPILER_ID@")
+set(CMAKE_C_COMPILER_VERSION "@CMAKE_C_COMPILER_VERSION@")
+set(CMAKE_C_PLATFORM_ID "@CMAKE_C_PLATFORM_ID@")
 @SET_MSVC_C_ARCHITECTURE_ID@
-SET(CMAKE_AR "@CMAKE_AR@")
-SET(CMAKE_RANLIB "@CMAKE_RANLIB@")
-SET(CMAKE_LINKER "@CMAKE_LINKER@")
-SET(CMAKE_COMPILER_IS_GNUCC @CMAKE_COMPILER_IS_GNUCC@)
-SET(CMAKE_C_COMPILER_LOADED 1)
-SET(CMAKE_COMPILER_IS_MINGW @CMAKE_COMPILER_IS_MINGW@)
-SET(CMAKE_COMPILER_IS_CYGWIN @CMAKE_COMPILER_IS_CYGWIN@)
-IF(CMAKE_COMPILER_IS_CYGWIN)
-  SET(CYGWIN 1)
-  SET(UNIX 1)
-ENDIF(CMAKE_COMPILER_IS_CYGWIN)
-
-SET(CMAKE_C_COMPILER_ENV_VAR "CC")
-
-IF(CMAKE_COMPILER_IS_MINGW)
-  SET(MINGW 1)
-ENDIF(CMAKE_COMPILER_IS_MINGW)
-SET(CMAKE_C_COMPILER_ID_RUN 1)
-SET(CMAKE_C_SOURCE_FILE_EXTENSIONS c)
-SET(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
-SET(CMAKE_C_LINKER_PREFERENCE 10)
+set(CMAKE_AR "@CMAKE_AR@")
+set(CMAKE_RANLIB "@CMAKE_RANLIB@")
+set(CMAKE_LINKER "@CMAKE_LINKER@")
+set(CMAKE_COMPILER_IS_GNUCC @CMAKE_COMPILER_IS_GNUCC@)
+set(CMAKE_C_COMPILER_LOADED 1)
+set(CMAKE_C_COMPILER_WORKS @CMAKE_C_COMPILER_WORKS@)
+set(CMAKE_C_ABI_COMPILED @CMAKE_C_ABI_COMPILED@)
+set(CMAKE_COMPILER_IS_MINGW @CMAKE_COMPILER_IS_MINGW@)
+set(CMAKE_COMPILER_IS_CYGWIN @CMAKE_COMPILER_IS_CYGWIN@)
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_C_COMPILER_ENV_VAR "CC")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_C_COMPILER_ID_RUN 1)
+set(CMAKE_C_SOURCE_FILE_EXTENSIONS c)
+set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_C_LINKER_PREFERENCE 10)
 
 # Save compiler ABI information.
-SET(CMAKE_C_SIZEOF_DATA_PTR "@CMAKE_C_SIZEOF_DATA_PTR@")
-SET(CMAKE_C_COMPILER_ABI "@CMAKE_C_COMPILER_ABI@")
-SET(CMAKE_C_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@")
+set(CMAKE_C_SIZEOF_DATA_PTR "@CMAKE_C_SIZEOF_DATA_PTR@")
+set(CMAKE_C_COMPILER_ABI "@CMAKE_C_COMPILER_ABI@")
+set(CMAKE_C_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@")
 
-IF(CMAKE_C_SIZEOF_DATA_PTR)
-  SET(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
-ENDIF(CMAKE_C_SIZEOF_DATA_PTR)
+if(CMAKE_C_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
+endif()
 
-IF(CMAKE_C_COMPILER_ABI)
-  SET(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
-ENDIF(CMAKE_C_COMPILER_ABI)
+if(CMAKE_C_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
+endif()
 
-IF(CMAKE_C_LIBRARY_ARCHITECTURE)
-  SET(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@")
-ENDIF()
+if(CMAKE_C_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@")
+endif()
 
-SET(CMAKE_C_HAS_ISYSROOT "@CMAKE_C_HAS_ISYSROOT@")
+@CMAKE_C_SYSROOT_FLAG_CODE@
 @CMAKE_C_OSX_DEPLOYMENT_TARGET_FLAG_CODE@
 
-SET(CMAKE_C_IMPLICIT_LINK_LIBRARIES "@CMAKE_C_IMPLICIT_LINK_LIBRARIES@")
-SET(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "@CMAKE_C_IMPLICIT_LINK_DIRECTORIES@")
+set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "@CMAKE_C_IMPLICIT_LINK_LIBRARIES@")
+set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "@CMAKE_C_IMPLICIT_LINK_DIRECTORIES@")
 
 @SET_CMAKE_CMCLDEPS_EXECUTABLE@
 @SET_CMAKE_CL_SHOWINCLUDE_PREFIX@
diff --git a/Modules/CMakeCCompilerId.c.in b/Modules/CMakeCCompilerId.c.in
index 06aa9bf06..2d76c7a34 100644
--- a/Modules/CMakeCCompilerId.c.in
+++ b/Modules/CMakeCCompilerId.c.in
@@ -20,6 +20,14 @@
 #  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
 # endif
 
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
 #elif defined(__clang__)
 # define COMPILER_ID "Clang"
 # define COMPILER_VERSION_MAJOR DEC(__clang_major__)
@@ -67,6 +75,10 @@
 
 #elif defined(__DECC)
 # define COMPILER_ID "Compaq"
+  /* __DECC_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECC_VER         % 10000)
 
 #elif defined(__IBMC__)
 # if defined(__COMPILER_VER__)
@@ -91,14 +103,17 @@
 #  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
 # endif
 
-#elif defined(__PATHSCALE__)
-# define COMPILER_ID "PathScale"
-
 #elif defined(_CRAYC)
 # define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
 
 #elif defined(__TI_COMPILER_VERSION__)
 # define COMPILER_ID "TI_DSP"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
 
 #elif defined(__TINYC__)
 # define COMPILER_ID "TinyCC"
@@ -132,9 +147,16 @@
 #  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
 # endif
 
+/* Analog VisualDSP++ >= 4.5.6 */
+#elif defined(__VISUALDSPVERSION__)
+# define COMPILER_ID "ADSP"
+  /* __VISUALDSPVERSION__ = 0xVVRRPP00 */
+# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
+# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
+# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8  & 0xFF)
+
+/* Analog VisualDSP++ < 4.5.6 */
 #elif defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
-/* Analog Devices C++ compiler for Blackfin, TigerSHARC and
-   SHARC (21000) DSPs */
 # define COMPILER_ID "ADSP"
 
 /* IAR Systems compiler for embedded systems.
@@ -147,6 +169,10 @@
    http://sdcc.sourceforge.net  */
 #elif defined(SDCC)
 # define COMPILER_ID "SDCC"
+  /* SDCC = VRP */
+#  define COMPILER_VERSION_MAJOR DEC(SDCC/100)
+#  define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10)
+#  define COMPILER_VERSION_PATCH DEC(SDCC    % 10)
 
 #elif defined(_SGI_COMPILER_VERSION) || defined(_COMPILER_VERSION)
 # define COMPILER_ID "MIPSpro"
diff --git a/Modules/CMakeCInformation.cmake b/Modules/CMakeCInformation.cmake
index afac7a452..ce5ce4409 100644
--- a/Modules/CMakeCInformation.cmake
+++ b/Modules/CMakeCInformation.cmake
@@ -20,119 +20,119 @@
 
 # some compilers use different extensions (e.g. sdcc uses .rel)
 # so set the extension here first so it can be overridden by the compiler specific file
-IF(UNIX)
-  SET(CMAKE_C_OUTPUT_EXTENSION .o)
-ELSE(UNIX)
-  SET(CMAKE_C_OUTPUT_EXTENSION .obj)
-ENDIF(UNIX)
+if(UNIX)
+  set(CMAKE_C_OUTPUT_EXTENSION .o)
+else()
+  set(CMAKE_C_OUTPUT_EXTENSION .obj)
+endif()
 
-SET(_INCLUDED_FILE 0)
+set(_INCLUDED_FILE 0)
 
 # Load compiler-specific information.
-IF(CMAKE_C_COMPILER_ID)
-  INCLUDE(Compiler/${CMAKE_C_COMPILER_ID}-C OPTIONAL)
-ENDIF(CMAKE_C_COMPILER_ID)
+if(CMAKE_C_COMPILER_ID)
+  include(Compiler/${CMAKE_C_COMPILER_ID}-C OPTIONAL)
+endif()
 
-SET(CMAKE_BASE_NAME)
-GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_C_COMPILER} NAME_WE)
-IF(CMAKE_COMPILER_IS_GNUCC)
-  SET(CMAKE_BASE_NAME gcc)
-ENDIF(CMAKE_COMPILER_IS_GNUCC)
+set(CMAKE_BASE_NAME)
+get_filename_component(CMAKE_BASE_NAME ${CMAKE_C_COMPILER} NAME_WE)
+if(CMAKE_COMPILER_IS_GNUCC)
+  set(CMAKE_BASE_NAME gcc)
+endif()
 
 
 # load a hardware specific file, mostly useful for embedded compilers
-IF(CMAKE_SYSTEM_PROCESSOR)
-  IF(CMAKE_C_COMPILER_ID)
-    INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
-  ENDIF(CMAKE_C_COMPILER_ID)
-  IF (NOT _INCLUDED_FILE)
-    INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
-  ENDIF (NOT _INCLUDED_FILE)
-ENDIF(CMAKE_SYSTEM_PROCESSOR)
+if(CMAKE_SYSTEM_PROCESSOR)
+  if(CMAKE_C_COMPILER_ID)
+    include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
+  endif()
+  if (NOT _INCLUDED_FILE)
+    include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
+  endif ()
+endif()
 
 
 # load the system- and compiler specific files
-IF(CMAKE_C_COMPILER_ID)
-  INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C
+if(CMAKE_C_COMPILER_ID)
+  include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_C_COMPILER_ID}-C
     OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
-ENDIF(CMAKE_C_COMPILER_ID)
-IF (NOT _INCLUDED_FILE)
-  INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} 
+endif()
+if (NOT _INCLUDED_FILE)
+  include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}
     OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
-ENDIF (NOT _INCLUDED_FILE)
+endif ()
 # We specify the compiler information in the system file for some
 # platforms, but this language may not have been enabled when the file
 # was first included.  Include it again to get the language info.
 # Remove this when all compiler info is removed from system files.
-IF (NOT _INCLUDED_FILE)
-  INCLUDE(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL)
-ENDIF (NOT _INCLUDED_FILE)
+if (NOT _INCLUDED_FILE)
+  include(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL)
+endif ()
 
-IF(CMAKE_C_SIZEOF_DATA_PTR)
-  FOREACH(f ${CMAKE_C_ABI_FILES})
-    INCLUDE(${f})
-  ENDFOREACH()
-  UNSET(CMAKE_C_ABI_FILES)
-ENDIF()
+if(CMAKE_C_SIZEOF_DATA_PTR)
+  foreach(f ${CMAKE_C_ABI_FILES})
+    include(${f})
+  endforeach()
+  unset(CMAKE_C_ABI_FILES)
+endif()
 
 # This should be included before the _INIT variables are
-# used to initialize the cache.  Since the rule variables 
+# used to initialize the cache.  Since the rule variables
 # have if blocks on them, users can still define them here.
 # But, it should still be after the platform file so changes can
 # be made to those values.
 
-IF(CMAKE_USER_MAKE_RULES_OVERRIDE)
+if(CMAKE_USER_MAKE_RULES_OVERRIDE)
   # Save the full path of the file so try_compile can use it.
-  INCLUDE(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
-  SET(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
-ENDIF()
+  include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
+endif()
 
-IF(CMAKE_USER_MAKE_RULES_OVERRIDE_C)
+if(CMAKE_USER_MAKE_RULES_OVERRIDE_C)
   # Save the full path of the file so try_compile can use it.
-  INCLUDE(${CMAKE_USER_MAKE_RULES_OVERRIDE_C} RESULT_VARIABLE _override)
-  SET(CMAKE_USER_MAKE_RULES_OVERRIDE_C "${_override}")
-ENDIF()
+  include(${CMAKE_USER_MAKE_RULES_OVERRIDE_C} RESULT_VARIABLE _override)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE_C "${_override}")
+endif()
 
 
 # for most systems a module is the same as a shared library
 # so unless the variable CMAKE_MODULE_EXISTS is set just
 # copy the values from the LIBRARY variables
-IF(NOT CMAKE_MODULE_EXISTS)
-  SET(CMAKE_SHARED_MODULE_C_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
-  SET(CMAKE_SHARED_MODULE_CREATE_C_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
-ENDIF(NOT CMAKE_MODULE_EXISTS)
-
-SET(CMAKE_C_FLAGS_INIT "$ENV{CFLAGS} ${CMAKE_C_FLAGS_INIT}")
-# avoid just having a space as the initial value for the cache 
-IF(CMAKE_C_FLAGS_INIT STREQUAL " ")
-  SET(CMAKE_C_FLAGS_INIT)
-ENDIF(CMAKE_C_FLAGS_INIT STREQUAL " ")
-SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS_INIT}" CACHE STRING
+if(NOT CMAKE_MODULE_EXISTS)
+  set(CMAKE_SHARED_MODULE_C_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
+  set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
+endif()
+
+set(CMAKE_C_FLAGS_INIT "$ENV{CFLAGS} ${CMAKE_C_FLAGS_INIT}")
+# avoid just having a space as the initial value for the cache
+if(CMAKE_C_FLAGS_INIT STREQUAL " ")
+  set(CMAKE_C_FLAGS_INIT)
+endif()
+set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS_INIT}" CACHE STRING
      "Flags used by the compiler during all build types.")
 
-IF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
 # default build type is none
-  IF(NOT CMAKE_NO_BUILD_TYPE)
-    SET (CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE_INIT} CACHE STRING 
+  if(NOT CMAKE_NO_BUILD_TYPE)
+    set (CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE_INIT} CACHE STRING
       "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
-  ENDIF(NOT CMAKE_NO_BUILD_TYPE)
-  SET (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG_INIT}" CACHE STRING
+  endif()
+  set (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG_INIT}" CACHE STRING
     "Flags used by the compiler during debug builds.")
-  SET (CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL_INIT}" CACHE STRING
+  set (CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL_INIT}" CACHE STRING
     "Flags used by the compiler during release minsize builds.")
-  SET (CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE_INIT}" CACHE STRING
+  set (CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE_INIT}" CACHE STRING
     "Flags used by the compiler during release builds (/MD /Ob1 /Oi /Ot /Oy /Gs will produce slightly less optimized but smaller files).")
-  SET (CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
+  set (CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
     "Flags used by the compiler during Release with Debug Info builds.")
-ENDIF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+endif()
 
-IF(CMAKE_C_STANDARD_LIBRARIES_INIT)
-  SET(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES_INIT}"
+if(CMAKE_C_STANDARD_LIBRARIES_INIT)
+  set(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES_INIT}"
     CACHE STRING "Libraries linked by defalut with all C applications.")
-  MARK_AS_ADVANCED(CMAKE_C_STANDARD_LIBRARIES)
-ENDIF(CMAKE_C_STANDARD_LIBRARIES_INIT)
+  mark_as_advanced(CMAKE_C_STANDARD_LIBRARIES)
+endif()
 
-INCLUDE(CMakeCommonLanguageInclude)
+include(CMakeCommonLanguageInclude)
 
 # now define the following rule variables
 
@@ -151,69 +151,69 @@ INCLUDE(CMakeCommonLanguageInclude)
 # <LINK_FLAGS>
 
 # C compiler information
-# <CMAKE_C_COMPILER>  
+# <CMAKE_C_COMPILER>
 # <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS>
 # <CMAKE_SHARED_MODULE_CREATE_C_FLAGS>
 # <CMAKE_C_LINK_FLAGS>
 
 # Static library tools
-# <CMAKE_AR> 
+# <CMAKE_AR>
 # <CMAKE_RANLIB>
 
 
 # create a C shared library
-IF(NOT CMAKE_C_CREATE_SHARED_LIBRARY)
-  SET(CMAKE_C_CREATE_SHARED_LIBRARY
+if(NOT CMAKE_C_CREATE_SHARED_LIBRARY)
+  set(CMAKE_C_CREATE_SHARED_LIBRARY
       "<CMAKE_C_COMPILER> <CMAKE_SHARED_LIBRARY_C_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
-ENDIF(NOT CMAKE_C_CREATE_SHARED_LIBRARY)
+endif()
 
 # create a C shared module just copy the shared library rule
-IF(NOT CMAKE_C_CREATE_SHARED_MODULE)
-  SET(CMAKE_C_CREATE_SHARED_MODULE ${CMAKE_C_CREATE_SHARED_LIBRARY})
-ENDIF(NOT CMAKE_C_CREATE_SHARED_MODULE)
+if(NOT CMAKE_C_CREATE_SHARED_MODULE)
+  set(CMAKE_C_CREATE_SHARED_MODULE ${CMAKE_C_CREATE_SHARED_LIBRARY})
+endif()
 
 # Create a static archive incrementally for large object file counts.
 # If CMAKE_C_CREATE_STATIC_LIBRARY is set it will override these.
-IF(NOT DEFINED CMAKE_C_ARCHIVE_CREATE)
-  SET(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS>")
-ENDIF()
-IF(NOT DEFINED CMAKE_C_ARCHIVE_APPEND)
-  SET(CMAKE_C_ARCHIVE_APPEND "<CMAKE_AR> r  <TARGET> <LINK_FLAGS> <OBJECTS>")
-ENDIF()
-IF(NOT DEFINED CMAKE_C_ARCHIVE_FINISH)
-  SET(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
-ENDIF()
+if(NOT DEFINED CMAKE_C_ARCHIVE_CREATE)
+  set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS>")
+endif()
+if(NOT DEFINED CMAKE_C_ARCHIVE_APPEND)
+  set(CMAKE_C_ARCHIVE_APPEND "<CMAKE_AR> r  <TARGET> <LINK_FLAGS> <OBJECTS>")
+endif()
+if(NOT DEFINED CMAKE_C_ARCHIVE_FINISH)
+  set(CMAKE_C_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
+endif()
 
 # compile a C file into an object file
-IF(NOT CMAKE_C_COMPILE_OBJECT)
-  SET(CMAKE_C_COMPILE_OBJECT
+if(NOT CMAKE_C_COMPILE_OBJECT)
+  set(CMAKE_C_COMPILE_OBJECT
     "<CMAKE_C_COMPILER> <DEFINES> <FLAGS> -o <OBJECT>   -c <SOURCE>")
-ENDIF(NOT CMAKE_C_COMPILE_OBJECT)
+endif()
 
-IF(NOT CMAKE_C_LINK_EXECUTABLE)
-  SET(CMAKE_C_LINK_EXECUTABLE
+if(NOT CMAKE_C_LINK_EXECUTABLE)
+  set(CMAKE_C_LINK_EXECUTABLE
     "<CMAKE_C_COMPILER> <FLAGS> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
-ENDIF(NOT CMAKE_C_LINK_EXECUTABLE)
+endif()
 
-IF(NOT CMAKE_EXECUTABLE_RUNTIME_C_FLAG)
-  SET(CMAKE_EXECUTABLE_RUNTIME_C_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG})
-ENDIF(NOT CMAKE_EXECUTABLE_RUNTIME_C_FLAG)
+if(NOT CMAKE_EXECUTABLE_RUNTIME_C_FLAG)
+  set(CMAKE_EXECUTABLE_RUNTIME_C_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG})
+endif()
 
-IF(NOT CMAKE_EXECUTABLE_RUNTIME_C_FLAG_SEP)
-  SET(CMAKE_EXECUTABLE_RUNTIME_C_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP})
-ENDIF(NOT CMAKE_EXECUTABLE_RUNTIME_C_FLAG_SEP)
+if(NOT CMAKE_EXECUTABLE_RUNTIME_C_FLAG_SEP)
+  set(CMAKE_EXECUTABLE_RUNTIME_C_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP})
+endif()
 
-IF(NOT CMAKE_EXECUTABLE_RPATH_LINK_C_FLAG)
-  SET(CMAKE_EXECUTABLE_RPATH_LINK_C_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_C_FLAG})
-ENDIF(NOT CMAKE_EXECUTABLE_RPATH_LINK_C_FLAG)
+if(NOT CMAKE_EXECUTABLE_RPATH_LINK_C_FLAG)
+  set(CMAKE_EXECUTABLE_RPATH_LINK_C_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_C_FLAG})
+endif()
 
-MARK_AS_ADVANCED(
+mark_as_advanced(
 CMAKE_C_FLAGS
 CMAKE_C_FLAGS_DEBUG
 CMAKE_C_FLAGS_MINSIZEREL
 CMAKE_C_FLAGS_RELEASE
 CMAKE_C_FLAGS_RELWITHDEBINFO
 )
-SET(CMAKE_C_INFORMATION_LOADED 1)
+set(CMAKE_C_INFORMATION_LOADED 1)
 
 
diff --git a/Modules/CMakeCXXCompiler.cmake.in b/Modules/CMakeCXXCompiler.cmake.in
index 5b6376a32..8c5d84e6c 100644
--- a/Modules/CMakeCXXCompiler.cmake.in
+++ b/Modules/CMakeCXXCompiler.cmake.in
@@ -1,54 +1,56 @@
-SET(CMAKE_CXX_COMPILER "@CMAKE_CXX_COMPILER@")
-SET(CMAKE_CXX_COMPILER_ARG1 "@CMAKE_CXX_COMPILER_ARG1@")
-SET(CMAKE_CXX_COMPILER_ID "@CMAKE_CXX_COMPILER_ID@")
-SET(CMAKE_CXX_COMPILER_VERSION "@CMAKE_CXX_COMPILER_VERSION@")
-SET(CMAKE_CXX_PLATFORM_ID "@CMAKE_CXX_PLATFORM_ID@")
+set(CMAKE_CXX_COMPILER "@CMAKE_CXX_COMPILER@")
+set(CMAKE_CXX_COMPILER_ARG1 "@CMAKE_CXX_COMPILER_ARG1@")
+set(CMAKE_CXX_COMPILER_ID "@CMAKE_CXX_COMPILER_ID@")
+set(CMAKE_CXX_COMPILER_VERSION "@CMAKE_CXX_COMPILER_VERSION@")
+set(CMAKE_CXX_PLATFORM_ID "@CMAKE_CXX_PLATFORM_ID@")
 @SET_MSVC_CXX_ARCHITECTURE_ID@
-SET(CMAKE_AR "@CMAKE_AR@")
-SET(CMAKE_RANLIB "@CMAKE_RANLIB@")
-SET(CMAKE_LINKER "@CMAKE_LINKER@")
-SET(CMAKE_COMPILER_IS_GNUCXX @CMAKE_COMPILER_IS_GNUCXX@)
-SET(CMAKE_CXX_COMPILER_LOADED 1)
-SET(CMAKE_COMPILER_IS_MINGW @CMAKE_COMPILER_IS_MINGW@)
-SET(CMAKE_COMPILER_IS_CYGWIN @CMAKE_COMPILER_IS_CYGWIN@)
-IF(CMAKE_COMPILER_IS_CYGWIN)
-  SET(CYGWIN 1)
-  SET(UNIX 1)
-ENDIF(CMAKE_COMPILER_IS_CYGWIN)
-
-SET(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
-
-IF(CMAKE_COMPILER_IS_MINGW)
-  SET(MINGW 1)
-ENDIF(CMAKE_COMPILER_IS_MINGW)
-SET(CMAKE_CXX_COMPILER_ID_RUN 1)
-SET(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
-SET(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;CPP)
-SET(CMAKE_CXX_LINKER_PREFERENCE 30)
-SET(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
+set(CMAKE_AR "@CMAKE_AR@")
+set(CMAKE_RANLIB "@CMAKE_RANLIB@")
+set(CMAKE_LINKER "@CMAKE_LINKER@")
+set(CMAKE_COMPILER_IS_GNUCXX @CMAKE_COMPILER_IS_GNUCXX@)
+set(CMAKE_CXX_COMPILER_LOADED 1)
+set(CMAKE_CXX_COMPILER_WORKS @CMAKE_CXX_COMPILER_WORKS@)
+set(CMAKE_CXX_ABI_COMPILED @CMAKE_CXX_ABI_COMPILED@)
+set(CMAKE_COMPILER_IS_MINGW @CMAKE_COMPILER_IS_MINGW@)
+set(CMAKE_COMPILER_IS_CYGWIN @CMAKE_COMPILER_IS_CYGWIN@)
+if(CMAKE_COMPILER_IS_CYGWIN)
+  set(CYGWIN 1)
+  set(UNIX 1)
+endif()
+
+set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
+
+if(CMAKE_COMPILER_IS_MINGW)
+  set(MINGW 1)
+endif()
+set(CMAKE_CXX_COMPILER_ID_RUN 1)
+set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
+set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;CPP)
+set(CMAKE_CXX_LINKER_PREFERENCE 30)
+set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
 
 # Save compiler ABI information.
-SET(CMAKE_CXX_SIZEOF_DATA_PTR "@CMAKE_CXX_SIZEOF_DATA_PTR@")
-SET(CMAKE_CXX_COMPILER_ABI "@CMAKE_CXX_COMPILER_ABI@")
-SET(CMAKE_CXX_LIBRARY_ARCHITECTURE "@CMAKE_CXX_LIBRARY_ARCHITECTURE@")
+set(CMAKE_CXX_SIZEOF_DATA_PTR "@CMAKE_CXX_SIZEOF_DATA_PTR@")
+set(CMAKE_CXX_COMPILER_ABI "@CMAKE_CXX_COMPILER_ABI@")
+set(CMAKE_CXX_LIBRARY_ARCHITECTURE "@CMAKE_CXX_LIBRARY_ARCHITECTURE@")
 
-IF(CMAKE_CXX_SIZEOF_DATA_PTR)
-  SET(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
-ENDIF(CMAKE_CXX_SIZEOF_DATA_PTR)
+if(CMAKE_CXX_SIZEOF_DATA_PTR)
+  set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
+endif()
 
-IF(CMAKE_CXX_COMPILER_ABI)
-  SET(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
-ENDIF(CMAKE_CXX_COMPILER_ABI)
+if(CMAKE_CXX_COMPILER_ABI)
+  set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
+endif()
 
-IF(CMAKE_CXX_LIBRARY_ARCHITECTURE)
-  SET(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_CXX_LIBRARY_ARCHITECTURE@")
-ENDIF()
+if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
+  set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_CXX_LIBRARY_ARCHITECTURE@")
+endif()
 
-SET(CMAKE_CXX_HAS_ISYSROOT "@CMAKE_CXX_HAS_ISYSROOT@")
+@CMAKE_CXX_SYSROOT_FLAG_CODE@
 @CMAKE_CXX_OSX_DEPLOYMENT_TARGET_FLAG_CODE@
 
-SET(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "@CMAKE_CXX_IMPLICIT_LINK_LIBRARIES@")
-SET(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "@CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES@")
+set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "@CMAKE_CXX_IMPLICIT_LINK_LIBRARIES@")
+set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "@CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES@")
 
 @SET_CMAKE_CMCLDEPS_EXECUTABLE@
 @SET_CMAKE_CL_SHOWINCLUDE_PREFIX@
diff --git a/Modules/CMakeCXXCompilerId.cpp.in b/Modules/CMakeCXXCompilerId.cpp.in
index 95fc852d6..5e70a4196 100644
--- a/Modules/CMakeCXXCompilerId.cpp.in
+++ b/Modules/CMakeCXXCompilerId.cpp.in
@@ -10,6 +10,9 @@
 
 #if defined(__COMO__)
 # define COMPILER_ID "Comeau"
+  /* __COMO_VERSION__ = VRR */
+# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100)
+# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100)
 
 #elif defined(__INTEL_COMPILER) || defined(__ICC)
 # define COMPILER_ID "Intel"
@@ -22,6 +25,14 @@
 #  define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
 # endif
 
+#elif defined(__PATHCC__)
+# define COMPILER_ID "PathScale"
+# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
+# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
+# if defined(__PATHCC_PATCHLEVEL__)
+#  define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
+# endif
+
 #elif defined(__clang__)
 # define COMPILER_ID "Clang"
 # define COMPILER_VERSION_MAJOR DEC(__clang_major__)
@@ -69,6 +80,10 @@
 
 #elif defined(__DECCXX)
 # define COMPILER_ID "Compaq"
+  /* __DECCXX_VER = VVRRTPPPP */
+# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000)
+# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000  % 100)
+# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER         % 10000)
 
 #elif defined(__IBMCPP__)
 # if defined(__COMPILER_VER__)
@@ -93,14 +108,17 @@
 #  define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
 # endif
 
-#elif defined(__PATHSCALE__)
-# define COMPILER_ID "PathScale"
-
 #elif defined(_CRAYC)
 # define COMPILER_ID "Cray"
+# define COMPILER_VERSION_MAJOR DEC(_RELEASE)
+# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
 
 #elif defined(__TI_COMPILER_VERSION__)
 # define COMPILER_ID "TI_DSP"
+  /* __TI_COMPILER_VERSION__ = VVVRRRPPP */
+# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
+# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000   % 1000)
+# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__        % 1000)
 
 #elif defined(__SCO_VERSION__)
 # define COMPILER_ID "SCO"
@@ -131,9 +149,16 @@
 #  define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
 # endif
 
+/* Analog VisualDSP++ >= 4.5.6 */
+#elif defined(__VISUALDSPVERSION__)
+# define COMPILER_ID "ADSP"
+  /* __VISUALDSPVERSION__ = 0xVVRRPP00 */
+# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24)
+# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF)
+# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8  & 0xFF)
+
+/* Analog VisualDSP++ < 4.5.6 */
 #elif defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__)
-/* Analog Devices C++ compiler for Blackfin, TigerSHARC and
-   SHARC (21000) DSPs */
 # define COMPILER_ID "ADSP"
 
 #elif defined(_SGI_COMPILER_VERSION) || defined(_COMPILER_VERSION)
diff --git a/Modules/CMakeCXXInformation.cmake b/Modules/CMakeCXXInformation.cmake
index 9dc9cbd30..933c15a82 100644
--- a/Modules/CMakeCXXInformation.cmake
+++ b/Modules/CMakeCXXInformation.cmake
@@ -20,210 +20,210 @@
 
 # some compilers use different extensions (e.g. sdcc uses .rel)
 # so set the extension here first so it can be overridden by the compiler specific file
-IF(UNIX)
-  SET(CMAKE_CXX_OUTPUT_EXTENSION .o)
-ELSE(UNIX)
-  SET(CMAKE_CXX_OUTPUT_EXTENSION .obj)
-ENDIF(UNIX)
+if(UNIX)
+  set(CMAKE_CXX_OUTPUT_EXTENSION .o)
+else()
+  set(CMAKE_CXX_OUTPUT_EXTENSION .obj)
+endif()
 
-SET(_INCLUDED_FILE 0)
+set(_INCLUDED_FILE 0)
 
 # Load compiler-specific information.
-IF(CMAKE_CXX_COMPILER_ID)
-  INCLUDE(Compiler/${CMAKE_CXX_COMPILER_ID}-CXX OPTIONAL)
-ENDIF(CMAKE_CXX_COMPILER_ID)
+if(CMAKE_CXX_COMPILER_ID)
+  include(Compiler/${CMAKE_CXX_COMPILER_ID}-CXX OPTIONAL)
+endif()
 
-SET(CMAKE_BASE_NAME)
-GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_CXX_COMPILER} NAME_WE)
+set(CMAKE_BASE_NAME)
+get_filename_component(CMAKE_BASE_NAME ${CMAKE_CXX_COMPILER} NAME_WE)
 # since the gnu compiler has several names force g++
-IF(CMAKE_COMPILER_IS_GNUCXX)
-  SET(CMAKE_BASE_NAME g++)
-ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+if(CMAKE_COMPILER_IS_GNUCXX)
+  set(CMAKE_BASE_NAME g++)
+endif()
 
 
 # load a hardware specific file, mostly useful for embedded compilers
-IF(CMAKE_SYSTEM_PROCESSOR)
-  IF(CMAKE_CXX_COMPILER_ID)
-    INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
-  ENDIF(CMAKE_CXX_COMPILER_ID)
-  IF (NOT _INCLUDED_FILE)
-    INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
-  ENDIF (NOT _INCLUDED_FILE)
-ENDIF(CMAKE_SYSTEM_PROCESSOR)
+if(CMAKE_SYSTEM_PROCESSOR)
+  if(CMAKE_CXX_COMPILER_ID)
+    include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
+  endif()
+  if (NOT _INCLUDED_FILE)
+    include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
+  endif ()
+endif()
 
 # load the system- and compiler specific files
-IF(CMAKE_CXX_COMPILER_ID)
-  INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
-ENDIF(CMAKE_CXX_COMPILER_ID)
-IF (NOT _INCLUDED_FILE)
-  INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL
+if(CMAKE_CXX_COMPILER_ID)
+  include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_CXX_COMPILER_ID}-CXX OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
+endif()
+if (NOT _INCLUDED_FILE)
+  include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL
           RESULT_VARIABLE _INCLUDED_FILE)
-ENDIF (NOT _INCLUDED_FILE)
+endif ()
 # We specify the compiler information in the system file for some
 # platforms, but this language may not have been enabled when the file
 # was first included.  Include it again to get the language info.
 # Remove this when all compiler info is removed from system files.
-IF (NOT _INCLUDED_FILE)
-  INCLUDE(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL)
-ENDIF (NOT _INCLUDED_FILE)
+if (NOT _INCLUDED_FILE)
+  include(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL)
+endif ()
 
-IF(CMAKE_CXX_SIZEOF_DATA_PTR)
-  FOREACH(f ${CMAKE_CXX_ABI_FILES})
-    INCLUDE(${f})
-  ENDFOREACH()
-  UNSET(CMAKE_CXX_ABI_FILES)
-ENDIF()
+if(CMAKE_CXX_SIZEOF_DATA_PTR)
+  foreach(f ${CMAKE_CXX_ABI_FILES})
+    include(${f})
+  endforeach()
+  unset(CMAKE_CXX_ABI_FILES)
+endif()
 
 # This should be included before the _INIT variables are
-# used to initialize the cache.  Since the rule variables 
+# used to initialize the cache.  Since the rule variables
 # have if blocks on them, users can still define them here.
 # But, it should still be after the platform file so changes can
 # be made to those values.
 
-IF(CMAKE_USER_MAKE_RULES_OVERRIDE)
+if(CMAKE_USER_MAKE_RULES_OVERRIDE)
   # Save the full path of the file so try_compile can use it.
-  INCLUDE(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
-  SET(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
-ENDIF()
+  include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
+endif()
 
-IF(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX)
+if(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX)
   # Save the full path of the file so try_compile can use it.
-  INCLUDE(${CMAKE_USER_MAKE_RULES_OVERRIDE_CXX} RESULT_VARIABLE _override)
-  SET(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX "${_override}")
-ENDIF()
+  include(${CMAKE_USER_MAKE_RULES_OVERRIDE_CXX} RESULT_VARIABLE _override)
+  set(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX "${_override}")
+endif()
 
 
 # Create a set of shared library variable specific to C++
 # For 90% of the systems, these are the same flags as the C versions
 # so if these are not set just copy the flags from the c version
-IF(NOT CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS)
-  SET(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
-ENDIF(NOT CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS)
+if(NOT CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS)
+  set(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
+endif()
 
-IF(NOT CMAKE_CXX_COMPILE_OPTIONS_PIC)
-  SET(CMAKE_CXX_COMPILE_OPTIONS_PIC ${CMAKE_C_COMPILE_OPTIONS_PIC})
-ENDIF(NOT CMAKE_CXX_COMPILE_OPTIONS_PIC)
+if(NOT CMAKE_CXX_COMPILE_OPTIONS_PIC)
+  set(CMAKE_CXX_COMPILE_OPTIONS_PIC ${CMAKE_C_COMPILE_OPTIONS_PIC})
+endif()
 
-IF(NOT CMAKE_CXX_COMPILE_OPTIONS_PIE)
-  SET(CMAKE_CXX_COMPILE_OPTIONS_PIE ${CMAKE_C_COMPILE_OPTIONS_PIE})
-ENDIF(NOT CMAKE_CXX_COMPILE_OPTIONS_PIE)
+if(NOT CMAKE_CXX_COMPILE_OPTIONS_PIE)
+  set(CMAKE_CXX_COMPILE_OPTIONS_PIE ${CMAKE_C_COMPILE_OPTIONS_PIE})
+endif()
 
-IF(NOT CMAKE_CXX_COMPILE_OPTIONS_DLL)
-  SET(CMAKE_CXX_COMPILE_OPTIONS_DLL ${CMAKE_C_COMPILE_OPTIONS_DLL})
-ENDIF(NOT CMAKE_CXX_COMPILE_OPTIONS_DLL)
+if(NOT CMAKE_CXX_COMPILE_OPTIONS_DLL)
+  set(CMAKE_CXX_COMPILE_OPTIONS_DLL ${CMAKE_C_COMPILE_OPTIONS_DLL})
+endif()
 
-IF(NOT CMAKE_SHARED_LIBRARY_CXX_FLAGS)
-  SET(CMAKE_SHARED_LIBRARY_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
-ENDIF(NOT CMAKE_SHARED_LIBRARY_CXX_FLAGS)
+if(NOT CMAKE_SHARED_LIBRARY_CXX_FLAGS)
+  set(CMAKE_SHARED_LIBRARY_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
+endif()
 
-IF(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
-  SET(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS})
-ENDIF(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
+if(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
+  set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS})
+endif()
 
-IF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG)
-  SET(CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG}) 
-ENDIF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG)
+if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG)
+  set(CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG})
+endif()
 
-IF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP)
-  SET(CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP})
-ENDIF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP)
+if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP)
+  set(CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP})
+endif()
 
-IF(NOT CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG)
-  SET(CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_C_FLAG})
-ENDIF(NOT CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG)
+if(NOT CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG)
+  set(CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_C_FLAG})
+endif()
 
-IF(NOT DEFINED CMAKE_EXE_EXPORTS_CXX_FLAG)
-  SET(CMAKE_EXE_EXPORTS_CXX_FLAG ${CMAKE_EXE_EXPORTS_C_FLAG})
-ENDIF()
+if(NOT DEFINED CMAKE_EXE_EXPORTS_CXX_FLAG)
+  set(CMAKE_EXE_EXPORTS_CXX_FLAG ${CMAKE_EXE_EXPORTS_C_FLAG})
+endif()
 
-IF(NOT DEFINED CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG)
-  SET(CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_SONAME_C_FLAG})
-ENDIF()
+if(NOT DEFINED CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG)
+  set(CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_SONAME_C_FLAG})
+endif()
 
-IF(NOT CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG)
-  SET(CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG})
-ENDIF(NOT CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG)
+if(NOT CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG)
+  set(CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG})
+endif()
 
-IF(NOT CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG_SEP)
-  SET(CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP})
-ENDIF(NOT CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG_SEP)
+if(NOT CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG_SEP)
+  set(CMAKE_EXECUTABLE_RUNTIME_CXX_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP})
+endif()
 
-IF(NOT CMAKE_EXECUTABLE_RPATH_LINK_CXX_FLAG)
-  SET(CMAKE_EXECUTABLE_RPATH_LINK_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG})
-ENDIF(NOT CMAKE_EXECUTABLE_RPATH_LINK_CXX_FLAG)
+if(NOT CMAKE_EXECUTABLE_RPATH_LINK_CXX_FLAG)
+  set(CMAKE_EXECUTABLE_RPATH_LINK_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_CXX_FLAG})
+endif()
 
-IF(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_CXX_WITH_RUNTIME_PATH)
-  SET(CMAKE_SHARED_LIBRARY_LINK_CXX_WITH_RUNTIME_PATH ${CMAKE_SHARED_LIBRARY_LINK_C_WITH_RUNTIME_PATH})
-ENDIF(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_CXX_WITH_RUNTIME_PATH)
+if(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_CXX_WITH_RUNTIME_PATH)
+  set(CMAKE_SHARED_LIBRARY_LINK_CXX_WITH_RUNTIME_PATH ${CMAKE_SHARED_LIBRARY_LINK_C_WITH_RUNTIME_PATH})
+endif()
 
-IF(NOT CMAKE_INCLUDE_FLAG_CXX)
-  SET(CMAKE_INCLUDE_FLAG_CXX ${CMAKE_INCLUDE_FLAG_C})
-ENDIF(NOT CMAKE_INCLUDE_FLAG_CXX)
+if(NOT CMAKE_INCLUDE_FLAG_CXX)
+  set(CMAKE_INCLUDE_FLAG_CXX ${CMAKE_INCLUDE_FLAG_C})
+endif()
 
-IF(NOT CMAKE_INCLUDE_FLAG_SEP_CXX)
-  SET(CMAKE_INCLUDE_FLAG_SEP_CXX ${CMAKE_INCLUDE_FLAG_SEP_C})
-ENDIF(NOT CMAKE_INCLUDE_FLAG_SEP_CXX)
+if(NOT CMAKE_INCLUDE_FLAG_SEP_CXX)
+  set(CMAKE_INCLUDE_FLAG_SEP_CXX ${CMAKE_INCLUDE_FLAG_SEP_C})
+endif()
 
 # for most systems a module is the same as a shared library
 # so unless the variable CMAKE_MODULE_EXISTS is set just
 # copy the values from the LIBRARY variables
-IF(NOT CMAKE_MODULE_EXISTS)
-  SET(CMAKE_SHARED_MODULE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS})
-  SET(CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS})
-ENDIF(NOT CMAKE_MODULE_EXISTS)
+if(NOT CMAKE_MODULE_EXISTS)
+  set(CMAKE_SHARED_MODULE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS})
+  set(CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS})
+endif()
 
 # repeat for modules
-IF(NOT CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS)
-  SET(CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS ${CMAKE_SHARED_MODULE_CREATE_C_FLAGS})
-ENDIF(NOT CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS)
+if(NOT CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS)
+  set(CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS ${CMAKE_SHARED_MODULE_CREATE_C_FLAGS})
+endif()
 
-IF(NOT CMAKE_SHARED_MODULE_CXX_FLAGS)
-  SET(CMAKE_SHARED_MODULE_CXX_FLAGS ${CMAKE_SHARED_MODULE_C_FLAGS})
-ENDIF(NOT CMAKE_SHARED_MODULE_CXX_FLAGS)
+if(NOT CMAKE_SHARED_MODULE_CXX_FLAGS)
+  set(CMAKE_SHARED_MODULE_CXX_FLAGS ${CMAKE_SHARED_MODULE_C_FLAGS})
+endif()
 
 # Initialize CXX link type selection flags from C versions.
-FOREACH(type SHARED_LIBRARY SHARED_MODULE EXE)
-  IF(NOT CMAKE_${type}_LINK_STATIC_CXX_FLAGS)
-    SET(CMAKE_${type}_LINK_STATIC_CXX_FLAGS
+foreach(type SHARED_LIBRARY SHARED_MODULE EXE)
+  if(NOT CMAKE_${type}_LINK_STATIC_CXX_FLAGS)
+    set(CMAKE_${type}_LINK_STATIC_CXX_FLAGS
       ${CMAKE_${type}_LINK_STATIC_C_FLAGS})
-  ENDIF(NOT CMAKE_${type}_LINK_STATIC_CXX_FLAGS)
-  IF(NOT CMAKE_${type}_LINK_DYNAMIC_CXX_FLAGS)
-    SET(CMAKE_${type}_LINK_DYNAMIC_CXX_FLAGS
+  endif()
+  if(NOT CMAKE_${type}_LINK_DYNAMIC_CXX_FLAGS)
+    set(CMAKE_${type}_LINK_DYNAMIC_CXX_FLAGS
       ${CMAKE_${type}_LINK_DYNAMIC_C_FLAGS})
-  ENDIF(NOT CMAKE_${type}_LINK_DYNAMIC_CXX_FLAGS)
-ENDFOREACH(type)
+  endif()
+endforeach()
 
 # add the flags to the cache based
 # on the initial values computed in the platform/*.cmake files
 # use _INIT variables so that this only happens the first time
 # and you can set these flags in the cmake cache
-SET(CMAKE_CXX_FLAGS_INIT "$ENV{CXXFLAGS} ${CMAKE_CXX_FLAGS_INIT}")
-# avoid just having a space as the initial value for the cache 
-IF(CMAKE_CXX_FLAGS_INIT STREQUAL " ")
-  SET(CMAKE_CXX_FLAGS_INIT)
-ENDIF(CMAKE_CXX_FLAGS_INIT STREQUAL " ")
-SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_INIT}" CACHE STRING
+set(CMAKE_CXX_FLAGS_INIT "$ENV{CXXFLAGS} ${CMAKE_CXX_FLAGS_INIT}")
+# avoid just having a space as the initial value for the cache
+if(CMAKE_CXX_FLAGS_INIT STREQUAL " ")
+  set(CMAKE_CXX_FLAGS_INIT)
+endif()
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_INIT}" CACHE STRING
      "Flags used by the compiler during all build types.")
 
-IF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
-  SET (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG_INIT}" CACHE STRING
+if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+  set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG_INIT}" CACHE STRING
      "Flags used by the compiler during debug builds.")
-  SET (CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL_INIT}" CACHE STRING
+  set (CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL_INIT}" CACHE STRING
       "Flags used by the compiler during release minsize builds.")
-  SET (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE_INIT}" CACHE STRING
+  set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE_INIT}" CACHE STRING
      "Flags used by the compiler during release builds (/MD /Ob1 /Oi /Ot /Oy /Gs will produce slightly less optimized but smaller files).")
-  SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
+  set (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
      "Flags used by the compiler during Release with Debug Info builds.")
 
-ENDIF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+endif()
 
-IF(CMAKE_CXX_STANDARD_LIBRARIES_INIT)
-  SET(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES_INIT}"
+if(CMAKE_CXX_STANDARD_LIBRARIES_INIT)
+  set(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES_INIT}"
     CACHE STRING "Libraries linked by defalut with all C++ applications.")
-  MARK_AS_ADVANCED(CMAKE_CXX_STANDARD_LIBRARIES)
-ENDIF(CMAKE_CXX_STANDARD_LIBRARIES_INIT)
+  mark_as_advanced(CMAKE_CXX_STANDARD_LIBRARIES)
+endif()
 
-INCLUDE(CMakeCommonLanguageInclude)
+include(CMakeCommonLanguageInclude)
 
 # now define the following rules:
 # CMAKE_CXX_CREATE_SHARED_LIBRARY
@@ -241,59 +241,59 @@ INCLUDE(CMakeCommonLanguageInclude)
 # <LINK_FLAGS>
 
 # CXX compiler information
-# <CMAKE_CXX_COMPILER>  
+# <CMAKE_CXX_COMPILER>
 # <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS>
 # <CMAKE_CXX_SHARED_MODULE_CREATE_FLAGS>
 # <CMAKE_CXX_LINK_FLAGS>
 
 # Static library tools
-# <CMAKE_AR> 
+# <CMAKE_AR>
 # <CMAKE_RANLIB>
 
 
 # create a shared C++ library
-IF(NOT CMAKE_CXX_CREATE_SHARED_LIBRARY)
-  SET(CMAKE_CXX_CREATE_SHARED_LIBRARY
+if(NOT CMAKE_CXX_CREATE_SHARED_LIBRARY)
+  set(CMAKE_CXX_CREATE_SHARED_LIBRARY
       "<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
-ENDIF(NOT CMAKE_CXX_CREATE_SHARED_LIBRARY)
+endif()
 
 # create a c++ shared module copy the shared library rule by default
-IF(NOT CMAKE_CXX_CREATE_SHARED_MODULE)
-  SET(CMAKE_CXX_CREATE_SHARED_MODULE ${CMAKE_CXX_CREATE_SHARED_LIBRARY})
-ENDIF(NOT CMAKE_CXX_CREATE_SHARED_MODULE)
+if(NOT CMAKE_CXX_CREATE_SHARED_MODULE)
+  set(CMAKE_CXX_CREATE_SHARED_MODULE ${CMAKE_CXX_CREATE_SHARED_LIBRARY})
+endif()
 
 
 # Create a static archive incrementally for large object file counts.
 # If CMAKE_CXX_CREATE_STATIC_LIBRARY is set it will override these.
-IF(NOT DEFINED CMAKE_CXX_ARCHIVE_CREATE)
-  SET(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS>")
-ENDIF()
-IF(NOT DEFINED CMAKE_CXX_ARCHIVE_APPEND)
-  SET(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> r  <TARGET> <LINK_FLAGS> <OBJECTS>")
-ENDIF()
-IF(NOT DEFINED CMAKE_CXX_ARCHIVE_FINISH)
-  SET(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
-ENDIF()
+if(NOT DEFINED CMAKE_CXX_ARCHIVE_CREATE)
+  set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS>")
+endif()
+if(NOT DEFINED CMAKE_CXX_ARCHIVE_APPEND)
+  set(CMAKE_CXX_ARCHIVE_APPEND "<CMAKE_AR> r  <TARGET> <LINK_FLAGS> <OBJECTS>")
+endif()
+if(NOT DEFINED CMAKE_CXX_ARCHIVE_FINISH)
+  set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
+endif()
 
 # compile a C++ file into an object file
-IF(NOT CMAKE_CXX_COMPILE_OBJECT)
-  SET(CMAKE_CXX_COMPILE_OBJECT
+if(NOT CMAKE_CXX_COMPILE_OBJECT)
+  set(CMAKE_CXX_COMPILE_OBJECT
     "<CMAKE_CXX_COMPILER>  <DEFINES> <FLAGS> -o <OBJECT> -c <SOURCE>")
-ENDIF(NOT CMAKE_CXX_COMPILE_OBJECT)
+endif()
 
-IF(NOT CMAKE_CXX_LINK_EXECUTABLE)
-  SET(CMAKE_CXX_LINK_EXECUTABLE
+if(NOT CMAKE_CXX_LINK_EXECUTABLE)
+  set(CMAKE_CXX_LINK_EXECUTABLE
     "<CMAKE_CXX_COMPILER>  <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
-ENDIF(NOT CMAKE_CXX_LINK_EXECUTABLE)
+endif()
 
-MARK_AS_ADVANCED(
+mark_as_advanced(
 CMAKE_BUILD_TOOL
-CMAKE_VERBOSE_MAKEFILE 
+CMAKE_VERBOSE_MAKEFILE
 CMAKE_CXX_FLAGS
 CMAKE_CXX_FLAGS_RELEASE
 CMAKE_CXX_FLAGS_RELWITHDEBINFO
 CMAKE_CXX_FLAGS_MINSIZEREL
 CMAKE_CXX_FLAGS_DEBUG)
 
-SET(CMAKE_CXX_INFORMATION_LOADED 1)
+set(CMAKE_CXX_INFORMATION_LOADED 1)
 
diff --git a/Modules/CMakeClDeps.cmake b/Modules/CMakeClDeps.cmake
index 6815e2b75..0214ead2b 100644
--- a/Modules/CMakeClDeps.cmake
+++ b/Modules/CMakeClDeps.cmake
@@ -20,18 +20,15 @@
 # in front of each include path, so it can remove it.
 #
 
-IF(MSVC_C_ARCHITECTURE_ID AND CMAKE_GENERATOR MATCHES "Ninja" AND CMAKE_C_COMPILER AND CMAKE_COMMAND)
-  STRING(REPLACE "cmake.exe" "cmcldeps.exe"  CMAKE_CMCLDEPS_EXECUTABLE ${CMAKE_COMMAND})
-  SET(showdir ${CMAKE_BINARY_DIR}/CMakeFiles/ShowIncludes)
-  FILE(WRITE ${showdir}/foo.h "\n")
-  FILE(WRITE ${showdir}/main.c "#include \"foo.h\" \nint main(){}\n")
-  EXECUTE_PROCESS(COMMAND ${CMAKE_C_COMPILER} /nologo /showIncludes ${showdir}/main.c
-                  WORKING_DIRECTORY ${showdir} OUTPUT_VARIABLE showOut)
-  STRING(REPLACE main.c "" showOut1 ${showOut})
-  STRING(REPLACE "/" "\\" header1 ${showdir}/foo.h)
-  STRING(TOLOWER ${header1} header2)
-  STRING(REPLACE ${header2} "" showOut2 ${showOut1})
-  STRING(REPLACE "\n" "" showOut3 ${showOut2})
-  SET(SET_CMAKE_CMCLDEPS_EXECUTABLE   "SET(CMAKE_CMCLDEPS_EXECUTABLE \"${CMAKE_CMCLDEPS_EXECUTABLE}\")")
-  SET(SET_CMAKE_CL_SHOWINCLUDE_PREFIX "SET(CMAKE_CL_SHOWINCLUDE_PREFIX \"${showOut3}\")")
-ENDIF()
+if(MSVC_C_ARCHITECTURE_ID AND CMAKE_GENERATOR MATCHES "Ninja" AND CMAKE_C_COMPILER AND CMAKE_COMMAND)
+  string(REPLACE "cmake.exe" "cmcldeps.exe"  CMAKE_CMCLDEPS_EXECUTABLE ${CMAKE_COMMAND})
+  set(showdir ${CMAKE_BINARY_DIR}/CMakeFiles/ShowIncludes)
+  file(WRITE ${showdir}/foo.h "\n")
+  file(WRITE ${showdir}/main.c "#include \"foo.h\" \nint main(){}\n")
+  execute_process(COMMAND ${CMAKE_C_COMPILER} /nologo /showIncludes ${showdir}/main.c
+                  WORKING_DIRECTORY ${showdir} OUTPUT_VARIABLE outLine)
+  string(REGEX MATCH "\n([^:]*:[^:]*:[ \t]*)" tmp "${outLine}")
+  set(localizedPrefix "${CMAKE_MATCH_1}")
+  set(SET_CMAKE_CMCLDEPS_EXECUTABLE   "set(CMAKE_CMCLDEPS_EXECUTABLE \"${CMAKE_CMCLDEPS_EXECUTABLE}\")")
+  set(SET_CMAKE_CL_SHOWINCLUDE_PREFIX "set(CMAKE_CL_SHOWINCLUDE_PREFIX \"${localizedPrefix}\")")
+endif()
diff --git a/Modules/CMakeCommonLanguageInclude.cmake b/Modules/CMakeCommonLanguageInclude.cmake
index a2929f1ea..bf94f9ff6 100644
--- a/Modules/CMakeCommonLanguageInclude.cmake
+++ b/Modules/CMakeCommonLanguageInclude.cmake
@@ -16,74 +16,74 @@
 # cache values that can be initialized in the platform-compiler.cmake file
 # it may be included by more than one language.
 
-SET (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
+set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
      CACHE STRING "Flags used by the linker.")
 
 
-IF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
 # default build type is none
-  IF(NOT CMAKE_NO_BUILD_TYPE)
-    SET (CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE_INIT} CACHE STRING 
+  if(NOT CMAKE_NO_BUILD_TYPE)
+    set (CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE_INIT} CACHE STRING
       "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
-  ENDIF(NOT CMAKE_NO_BUILD_TYPE)
-  
-  SET (CMAKE_EXE_LINKER_FLAGS_DEBUG ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
+  endif()
+
+  set (CMAKE_EXE_LINKER_FLAGS_DEBUG ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
      "Flags used by the linker during debug builds.")
 
-  SET (CMAKE_EXE_LINKER_FLAGS_MINSIZEREL ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL_INIT} CACHE STRING
+  set (CMAKE_EXE_LINKER_FLAGS_MINSIZEREL ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL_INIT} CACHE STRING
      "Flags used by the linker during release minsize builds.")
 
-  SET (CMAKE_EXE_LINKER_FLAGS_RELEASE ${CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT} CACHE STRING
+  set (CMAKE_EXE_LINKER_FLAGS_RELEASE ${CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT} CACHE STRING
      "Flags used by the linker during release builds.")
 
-  SET (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO 
+  set (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
      ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING
      "Flags used by the linker during Release with Debug Info builds.")
-  
-  SET (CMAKE_SHARED_LINKER_FLAGS_DEBUG ${CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
+
+  set (CMAKE_SHARED_LINKER_FLAGS_DEBUG ${CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
      "Flags used by the linker during debug builds.")
 
-  SET (CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL ${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL_INIT}
+  set (CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL ${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL_INIT}
      CACHE STRING
      "Flags used by the linker during release minsize builds.")
 
-  SET (CMAKE_SHARED_LINKER_FLAGS_RELEASE ${CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT} CACHE STRING
+  set (CMAKE_SHARED_LINKER_FLAGS_RELEASE ${CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT} CACHE STRING
      "Flags used by the linker during release builds.")
 
-  SET (CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO 
+  set (CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
      ${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING
      "Flags used by the linker during Release with Debug Info builds.")
 
-  SET (CMAKE_MODULE_LINKER_FLAGS_DEBUG ${CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
+  set (CMAKE_MODULE_LINKER_FLAGS_DEBUG ${CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
      "Flags used by the linker during debug builds.")
 
-  SET (CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL ${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL_INIT}
+  set (CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL ${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL_INIT}
      CACHE STRING
      "Flags used by the linker during release minsize builds.")
 
-  SET (CMAKE_MODULE_LINKER_FLAGS_RELEASE ${CMAKE_MODULE_LINKER_FLAGS_RELEASE_INIT} CACHE STRING
+  set (CMAKE_MODULE_LINKER_FLAGS_RELEASE ${CMAKE_MODULE_LINKER_FLAGS_RELEASE_INIT} CACHE STRING
      "Flags used by the linker during release builds.")
 
-  SET (CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO 
+  set (CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
      ${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING
      "Flags used by the linker during Release with Debug Info builds.")
 
-ENDIF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+endif()
 # shared linker flags
-SET (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
+set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
      CACHE STRING "Flags used by the linker during the creation of dll's.")
 
 # module linker flags
-SET (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
+set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
      CACHE STRING "Flags used by the linker during the creation of modules.")
 
-SET(CMAKE_BUILD_TOOL ${CMAKE_MAKE_PROGRAM} CACHE INTERNAL 
+set(CMAKE_BUILD_TOOL ${CMAKE_MAKE_PROGRAM} CACHE INTERNAL
      "What is the target build tool cmake is generating for.")
 
 
-MARK_AS_ADVANCED(
+mark_as_advanced(
 CMAKE_BUILD_TOOL
-CMAKE_VERBOSE_MAKEFILE 
+CMAKE_VERBOSE_MAKEFILE
 
 CMAKE_EXE_LINKER_FLAGS
 CMAKE_EXE_LINKER_FLAGS_DEBUG
diff --git a/Modules/CMakeDependentOption.cmake b/Modules/CMakeDependentOption.cmake
index 8b8dc07fb..990728f9f 100644
--- a/Modules/CMakeDependentOption.cmake
+++ b/Modules/CMakeDependentOption.cmake
@@ -25,27 +25,27 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
-MACRO(CMAKE_DEPENDENT_OPTION option doc default depends force)
-  IF(${option}_ISSET MATCHES "^${option}_ISSET$")
-    SET(${option}_AVAILABLE 1)
-    FOREACH(d ${depends})
-      STRING(REGEX REPLACE " +" ";" CMAKE_DEPENDENT_OPTION_DEP "${d}")
-      IF(${CMAKE_DEPENDENT_OPTION_DEP})
-      ELSE(${CMAKE_DEPENDENT_OPTION_DEP})
-        SET(${option}_AVAILABLE 0)
-      ENDIF(${CMAKE_DEPENDENT_OPTION_DEP})
-    ENDFOREACH(d)
-    IF(${option}_AVAILABLE)
-      OPTION(${option} "${doc}" "${default}")
-      SET(${option} "${${option}}" CACHE BOOL "${doc}" FORCE)
-    ELSE(${option}_AVAILABLE)
-      IF(${option} MATCHES "^${option}$")
-      ELSE(${option} MATCHES "^${option}$")
-        SET(${option} "${${option}}" CACHE INTERNAL "${doc}")
-      ENDIF(${option} MATCHES "^${option}$")
-      SET(${option} ${force})
-    ENDIF(${option}_AVAILABLE)
-  ELSE(${option}_ISSET MATCHES "^${option}_ISSET$")
-    SET(${option} "${${option}_ISSET}")
-  ENDIF(${option}_ISSET MATCHES "^${option}_ISSET$")
-ENDMACRO(CMAKE_DEPENDENT_OPTION)
+macro(CMAKE_DEPENDENT_OPTION option doc default depends force)
+  if(${option}_ISSET MATCHES "^${option}_ISSET$")
+    set(${option}_AVAILABLE 1)
+    foreach(d ${depends})
+      string(REGEX REPLACE " +" ";" CMAKE_DEPENDENT_OPTION_DEP "${d}")
+      if(${CMAKE_DEPENDENT_OPTION_DEP})
+      else()
+        set(${option}_AVAILABLE 0)
+      endif()
+    endforeach()
+    if(${option}_AVAILABLE)
+      option(${option} "${doc}" "${default}")
+      set(${option} "${${option}}" CACHE BOOL "${doc}" FORCE)
+    else()
+      if(${option} MATCHES "^${option}$")
+      else()
+        set(${option} "${${option}}" CACHE INTERNAL "${doc}")
+      endif()
+      set(${option} ${force})
+    endif()
+  else()
+    set(${option} "${${option}_ISSET}")
+  endif()
+endmacro()
diff --git a/Modules/CMakeDetermineASM-ATTCompiler.cmake b/Modules/CMakeDetermineASM-ATTCompiler.cmake
index 9dd2f11de..cec09e985 100644
--- a/Modules/CMakeDetermineASM-ATTCompiler.cmake
+++ b/Modules/CMakeDetermineASM-ATTCompiler.cmake
@@ -14,7 +14,7 @@
 
 # determine the compiler to use for ASM using AT&T syntax, e.g. GNU as
 
-SET(ASM_DIALECT "-ATT")
-SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ${_CMAKE_TOOLCHAIN_PREFIX}gas ${_CMAKE_TOOLCHAIN_PREFIX}as)
-INCLUDE(CMakeDetermineASMCompiler)
-SET(ASM_DIALECT)
+set(ASM_DIALECT "-ATT")
+set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ${_CMAKE_TOOLCHAIN_PREFIX}gas ${_CMAKE_TOOLCHAIN_PREFIX}as)
+include(CMakeDetermineASMCompiler)
+set(ASM_DIALECT)
diff --git a/Modules/CMakeDetermineASMCompiler.cmake b/Modules/CMakeDetermineASMCompiler.cmake
index 0a70d0a82..9f0b30ab4 100644
--- a/Modules/CMakeDetermineASMCompiler.cmake
+++ b/Modules/CMakeDetermineASMCompiler.cmake
@@ -14,52 +14,40 @@
 
 # determine the compiler to use for ASM programs
 
-IF(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
+include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
+
+if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
   # prefer the environment variable ASM
-  IF($ENV{ASM${ASM_DIALECT}} MATCHES ".+")
-    SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT "$ENV{ASM${ASM_DIALECT}}")
-  ENDIF($ENV{ASM${ASM_DIALECT}} MATCHES ".+")
+  if($ENV{ASM${ASM_DIALECT}} MATCHES ".+")
+    set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT "$ENV{ASM${ASM_DIALECT}}")
+  endif()
 
   # finally list compilers to try
-  IF("ASM${ASM_DIALECT}" STREQUAL "ASM") # the generic assembler support
-
-    IF(CMAKE_ASM_COMPILER_INIT)
-      SET(CMAKE_ASM_COMPILER_LIST ${CMAKE_ASM_COMPILER_INIT})
-    ELSE(CMAKE_ASM_COMPILER_INIT)
-
-      IF(CMAKE_C_COMPILER)
-        SET(CMAKE_ASM_COMPILER "${CMAKE_C_COMPILER}" CACHE FILEPATH "The ASM compiler")
-        SET(CMAKE_ASM_COMPILER_ID "${CMAKE_C_COMPILER_ID}")
-      ELSEIF(CMAKE_CXX_COMPILER)
-        SET(CMAKE_ASM_COMPILER "${CMAKE_CXX_COMPILER}" CACHE FILEPATH "The ASM compiler")
-        SET(CMAKE_ASM_COMPILER_ID "${CMAKE_CXX_COMPILER_ID}")
-      ELSE(CMAKE_CXX_COMPILER)
+  if("ASM${ASM_DIALECT}" STREQUAL "ASM") # the generic assembler support
+    if(NOT CMAKE_ASM_COMPILER_INIT)
+      if(CMAKE_C_COMPILER)
+        set(CMAKE_ASM_COMPILER "${CMAKE_C_COMPILER}" CACHE FILEPATH "The ASM compiler")
+        set(CMAKE_ASM_COMPILER_ID "${CMAKE_C_COMPILER_ID}")
+      elseif(CMAKE_CXX_COMPILER)
+        set(CMAKE_ASM_COMPILER "${CMAKE_CXX_COMPILER}" CACHE FILEPATH "The ASM compiler")
+        set(CMAKE_ASM_COMPILER_ID "${CMAKE_CXX_COMPILER_ID}")
+      else()
         # List all default C and CXX compilers
-        SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}gcc ${_CMAKE_TOOLCHAIN_PREFIX}cc cl bcc xlc
-                                                  ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ CC aCC cl bcc xlC)
-      ENDIF(CMAKE_C_COMPILER)
-
-    ENDIF(CMAKE_ASM_COMPILER_INIT)
-
-
-  ELSE("ASM${ASM_DIALECT}" STREQUAL "ASM") # some specific assembler "dialect"
-
-    IF(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT)
-      SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST ${CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT})
-    ELSE(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT)
-      MESSAGE(FATAL_ERROR "CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT must be preset !")
-    ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT)
-
-  ENDIF("ASM${ASM_DIALECT}" STREQUAL "ASM")
-
+        set(CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST
+             ${_CMAKE_TOOLCHAIN_PREFIX}cc  ${_CMAKE_TOOLCHAIN_PREFIX}gcc cl bcc xlc
+          CC ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ aCC cl bcc xlC)
+      endif()
+    endif()
+  else() # some specific assembler "dialect"
+    if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT)
+      message(FATAL_ERROR "CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT must be preset !")
+    endif()
+  endif()
 
   # Find the compiler.
-  IF (_CMAKE_USER_CXX_COMPILER_PATH OR _CMAKE_USER_C_COMPILER_PATH)
-    FIND_PROGRAM(CMAKE_ASM${ASM_DIALECT}_COMPILER NAMES ${CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST} PATHS ${_CMAKE_USER_C_COMPILER_PATH} ${_CMAKE_USER_CXX_COMPILER_PATH} DOC "Assembler" NO_DEFAULT_PATH)
-  ENDIF (_CMAKE_USER_CXX_COMPILER_PATH OR _CMAKE_USER_C_COMPILER_PATH)
-  FIND_PROGRAM(CMAKE_ASM${ASM_DIALECT}_COMPILER NAMES ${CMAKE_ASM${ASM_DIALECT}_COMPILER_LIST} PATHS ${_CMAKE_TOOLCHAIN_LOCATION} DOC "Assembler")
+  _cmake_find_compiler(ASM${ASM_DIALECT})
 
-ELSE(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
+else()
 
   # we only get here if CMAKE_ASM${ASM_DIALECT}_COMPILER was specified using -D or a pre-made CMakeCache.txt
   # (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
@@ -68,63 +56,63 @@ ELSE(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
   # 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"
-  GET_FILENAME_COMPONENT(_CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
-  IF(NOT _CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH)
-    FIND_PROGRAM(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH NAMES ${CMAKE_ASM${ASM_DIALECT}_COMPILER})
-    MARK_AS_ADVANCED(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
-    IF(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
-      SET(CMAKE_ASM${ASM_DIALECT}_COMPILER ${CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH} CACHE FILEPATH "Assembler" FORCE)
-    ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
-  ENDIF(NOT _CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH)
-ENDIF(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
-MARK_AS_ADVANCED(CMAKE_ASM${ASM_DIALECT}_COMPILER)
+  get_filename_component(_CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
+  if(NOT _CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH)
+    find_program(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH NAMES ${CMAKE_ASM${ASM_DIALECT}_COMPILER})
+    mark_as_advanced(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
+    if(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
+      set(CMAKE_ASM${ASM_DIALECT}_COMPILER ${CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH} CACHE FILEPATH "Assembler" FORCE)
+    endif()
+  endif()
+endif()
+mark_as_advanced(CMAKE_ASM${ASM_DIALECT}_COMPILER)
 
-IF (NOT _CMAKE_TOOLCHAIN_LOCATION)
-  GET_FILENAME_COMPONENT(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
-ENDIF (NOT _CMAKE_TOOLCHAIN_LOCATION)
+if (NOT _CMAKE_TOOLCHAIN_LOCATION)
+  get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
+endif ()
 
 
-IF(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
+if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
 
   # Table of per-vendor compiler id flags with expected output.
-  LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS GNU )
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_GNU "--version")
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_GNU "(GNU assembler)|(GCC)|(Free Software Foundation)")
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS GNU )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_GNU "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_GNU "(GNU assembler)|(GCC)|(Free Software Foundation)")
 
-  LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS HP )
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_HP "-V")
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_HP "HP C")
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS HP )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_HP "-V")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_HP "HP C")
 
-  LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS Intel )
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_Intel "--version")
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_Intel "(ICC)")
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS Intel )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_Intel "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_Intel "(ICC)")
 
-  LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS SunPro )
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_SunPro "-V")
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_SunPro "Sun C")
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS SunPro )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_SunPro "-V")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_SunPro "Sun C")
 
-  LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS XL )
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_XL "-qversion")
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_XL "XL C")
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS XL )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_XL "-qversion")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_XL "XL C")
 
-  LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS MSVC )
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_MSVC "/?")
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_MSVC "Microsoft")
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS MSVC )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_MSVC "/?")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_MSVC "Microsoft")
 
-  LIST(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TI_DSP )
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TI_DSP "-h")
-  SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TI_DSP "Texas Instruments")
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TI_DSP )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TI_DSP "-h")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TI_DSP "Texas Instruments")
 
-  INCLUDE(CMakeDetermineCompilerId)
+  include(CMakeDetermineCompilerId)
   CMAKE_DETERMINE_COMPILER_ID_VENDOR(ASM${ASM_DIALECT})
 
-ENDIF()
+endif()
 
-IF(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
-  MESSAGE(STATUS "The ASM${ASM_DIALECT} compiler identification is ${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}")
-ELSE(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
-  MESSAGE(STATUS "The ASM${ASM_DIALECT} compiler identification is unknown")
-ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
+  message(STATUS "The ASM${ASM_DIALECT} compiler identification is ${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}")
+else()
+  message(STATUS "The ASM${ASM_DIALECT} compiler identification is unknown")
+endif()
 
 
 
@@ -135,48 +123,48 @@ ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
 # NAME_WE cannot be used since then this test will fail for names lile
 # "arm-unknown-nto-qnx6.3.0-gas.exe", where BASENAME would be
 # "arm-unknown-nto-qnx6" instead of the correct "arm-unknown-nto-qnx6.3.0-"
-IF (NOT _CMAKE_TOOLCHAIN_PREFIX)
-  GET_FILENAME_COMPONENT(COMPILER_BASENAME "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" NAME)
-  IF (COMPILER_BASENAME MATCHES "^(.+-)g?as(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
-    SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
-  ENDIF (COMPILER_BASENAME MATCHES "^(.+-)g?as(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
-ENDIF (NOT _CMAKE_TOOLCHAIN_PREFIX)
+if (NOT _CMAKE_TOOLCHAIN_PREFIX)
+  get_filename_component(COMPILER_BASENAME "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" NAME)
+  if (COMPILER_BASENAME MATCHES "^(.+-)g?as(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ()
+endif ()
 
 # Now try the C compiler regexp:
-IF (NOT _CMAKE_TOOLCHAIN_PREFIX)
-  IF (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
-    SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
-  ENDIF (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
-ENDIF (NOT _CMAKE_TOOLCHAIN_PREFIX)
+if (NOT _CMAKE_TOOLCHAIN_PREFIX)
+  if (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ()
+endif ()
 
 # Finally try the CXX compiler regexp:
-IF (NOT _CMAKE_TOOLCHAIN_PREFIX)
-  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)?$")
-ENDIF (NOT _CMAKE_TOOLCHAIN_PREFIX)
+if (NOT _CMAKE_TOOLCHAIN_PREFIX)
+  if (COMPILER_BASENAME MATCHES "^(.+-)[gc]\\+\\+(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ()
+endif ()
 
 
-INCLUDE(CMakeFindBinUtils)
+include(CMakeFindBinUtils)
 
-SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR "ASM${ASM_DIALECT}")
+set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR "ASM${ASM_DIALECT}")
 
-IF(CMAKE_ASM${ASM_DIALECT}_COMPILER)
-  MESSAGE(STATUS "Found assembler: ${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
-ELSE(CMAKE_ASM${ASM_DIALECT}_COMPILER)
-  MESSAGE(STATUS "Didn't find assembler")
-ENDIF(CMAKE_ASM${ASM_DIALECT}_COMPILER)
+if(CMAKE_ASM${ASM_DIALECT}_COMPILER)
+  message(STATUS "Found assembler: ${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
+else()
+  message(STATUS "Didn't find assembler")
+endif()
 
 
-SET(_CMAKE_ASM_COMPILER "${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
-SET(_CMAKE_ASM_COMPILER_ID "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}")
-SET(_CMAKE_ASM_COMPILER_ARG1 "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARG1}")
-SET(_CMAKE_ASM_COMPILER_ENV_VAR "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR}")
+set(_CMAKE_ASM_COMPILER "${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
+set(_CMAKE_ASM_COMPILER_ID "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}")
+set(_CMAKE_ASM_COMPILER_ARG1 "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARG1}")
+set(_CMAKE_ASM_COMPILER_ENV_VAR "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR}")
 
 # configure variables set in this file for fast reload later on
-CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeASMCompiler.cmake.in
-  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeASM${ASM_DIALECT}Compiler.cmake IMMEDIATE @ONLY)
+configure_file(${CMAKE_ROOT}/Modules/CMakeASMCompiler.cmake.in
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeASM${ASM_DIALECT}Compiler.cmake IMMEDIATE @ONLY)
 
-SET(_CMAKE_ASM_COMPILER)
-SET(_CMAKE_ASM_COMPILER_ARG1)
-SET(_CMAKE_ASM_COMPILER_ENV_VAR)
+set(_CMAKE_ASM_COMPILER)
+set(_CMAKE_ASM_COMPILER_ARG1)
+set(_CMAKE_ASM_COMPILER_ENV_VAR)
diff --git a/Modules/CMakeDetermineASM_MASMCompiler.cmake b/Modules/CMakeDetermineASM_MASMCompiler.cmake
index e23f7db4c..665a65cc5 100644
--- a/Modules/CMakeDetermineASM_MASMCompiler.cmake
+++ b/Modules/CMakeDetermineASM_MASMCompiler.cmake
@@ -14,14 +14,14 @@
 
 # Find the MS assembler (masm or masm64)
 
-SET(ASM_DIALECT "_MASM")
+set(ASM_DIALECT "_MASM")
 
 # if we are using the 64bit cl compiler, assume we also want the 64bit assembler
-IF(CMAKE_CL_64)
-   SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ml64)
-ELSE(CMAKE_CL_64)
-   SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ml)
-ENDIF(CMAKE_CL_64)
+if(CMAKE_CL_64)
+   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ml64)
+else()
+   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ml)
+endif()
 
-INCLUDE(CMakeDetermineASMCompiler)
-SET(ASM_DIALECT)
+include(CMakeDetermineASMCompiler)
+set(ASM_DIALECT)
diff --git a/Modules/CMakeDetermineASM_NASMCompiler.cmake b/Modules/CMakeDetermineASM_NASMCompiler.cmake
index d184c0a81..50f71dd8c 100644
--- a/Modules/CMakeDetermineASM_NASMCompiler.cmake
+++ b/Modules/CMakeDetermineASM_NASMCompiler.cmake
@@ -14,14 +14,14 @@
 
 # Find the nasm assembler. yasm (http://www.tortall.net/projects/yasm/) is nasm compatible
 
-SET(CMAKE_ASM_NASM_COMPILER_INIT nasm yasm)
+set(CMAKE_ASM_NASM_COMPILER_INIT nasm yasm)
 
-IF(NOT CMAKE_ASM_NASM_COMPILER)
-  FIND_PROGRAM(CMAKE_ASM_NASM_COMPILER nasm
+if(NOT CMAKE_ASM_NASM_COMPILER)
+  find_program(CMAKE_ASM_NASM_COMPILER nasm
     "$ENV{ProgramFiles}/NASM")
-ENDIF(NOT CMAKE_ASM_NASM_COMPILER)
+endif()
 
 # Load the generic DetermineASM compiler file with the DIALECT set properly:
-SET(ASM_DIALECT "_NASM")
-INCLUDE(CMakeDetermineASMCompiler)
-SET(ASM_DIALECT)
+set(ASM_DIALECT "_NASM")
+include(CMakeDetermineASMCompiler)
+set(ASM_DIALECT)
diff --git a/Modules/CMakeDetermineCCompiler.cmake b/Modules/CMakeDetermineCCompiler.cmake
index 9028e8e06..275fc4758 100644
--- a/Modules/CMakeDetermineCCompiler.cmake
+++ b/Modules/CMakeDetermineCCompiler.cmake
@@ -31,114 +31,112 @@
 # If not already set before, it also sets
 #   _CMAKE_TOOLCHAIN_PREFIX
 
-IF(NOT CMAKE_C_COMPILER)
-  SET(CMAKE_C_COMPILER_INIT NOTFOUND)
-
-  # prefer the environment variable CC
-  IF($ENV{CC} MATCHES ".+")
-    GET_FILENAME_COMPONENT(CMAKE_C_COMPILER_INIT $ENV{CC} PROGRAM PROGRAM_ARGS CMAKE_C_FLAGS_ENV_INIT)
-    IF(CMAKE_C_FLAGS_ENV_INIT)
-      SET(CMAKE_C_COMPILER_ARG1 "${CMAKE_C_FLAGS_ENV_INIT}" CACHE STRING "First argument to C compiler")
-    ENDIF(CMAKE_C_FLAGS_ENV_INIT)
-    IF(NOT EXISTS ${CMAKE_C_COMPILER_INIT})
-      MESSAGE(FATAL_ERROR "Could not find compiler set in environment variable CC:\n$ENV{CC}.")
-    ENDIF(NOT EXISTS ${CMAKE_C_COMPILER_INIT})
-  ENDIF($ENV{CC} MATCHES ".+")
-
-  # next try prefer the compiler specified by the generator
-  IF(CMAKE_GENERATOR_CC)
-    IF(NOT CMAKE_C_COMPILER_INIT)
-      SET(CMAKE_C_COMPILER_INIT ${CMAKE_GENERATOR_CC})
-    ENDIF(NOT CMAKE_C_COMPILER_INIT)
-  ENDIF(CMAKE_GENERATOR_CC)
-
-  # finally list compilers to try
-  IF(CMAKE_C_COMPILER_INIT)
-    SET(CMAKE_C_COMPILER_LIST ${CMAKE_C_COMPILER_INIT})
-  ELSE(CMAKE_C_COMPILER_INIT)
-    SET(CMAKE_C_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}gcc ${_CMAKE_TOOLCHAIN_PREFIX}cc cl bcc xlc)
-  ENDIF(CMAKE_C_COMPILER_INIT)
-
-  # Find the compiler.
-  IF (_CMAKE_USER_CXX_COMPILER_PATH)
-    FIND_PROGRAM(CMAKE_C_COMPILER NAMES ${CMAKE_C_COMPILER_LIST} PATHS ${_CMAKE_USER_CXX_COMPILER_PATH} DOC "C compiler" NO_DEFAULT_PATH)
-  ENDIF (_CMAKE_USER_CXX_COMPILER_PATH)
-  FIND_PROGRAM(CMAKE_C_COMPILER NAMES ${CMAKE_C_COMPILER_LIST} DOC "C compiler")
-
-  IF(CMAKE_C_COMPILER_INIT AND NOT CMAKE_C_COMPILER)
-    SET(CMAKE_C_COMPILER "${CMAKE_C_COMPILER_INIT}" CACHE FILEPATH "C compiler" FORCE)
-  ENDIF(CMAKE_C_COMPILER_INIT AND NOT CMAKE_C_COMPILER)
-ELSE(NOT CMAKE_C_COMPILER)
-
-  # we only get here if CMAKE_C_COMPILER was specified using -D or a pre-made CMakeCache.txt
-  # (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
-  # if CMAKE_C_COMPILER is a list of length 2, use the first item as
-  # CMAKE_C_COMPILER and the 2nd one as CMAKE_C_COMPILER_ARG1
-
-  LIST(LENGTH CMAKE_C_COMPILER _CMAKE_C_COMPILER_LIST_LENGTH)
-  IF("${_CMAKE_C_COMPILER_LIST_LENGTH}" EQUAL 2)
-    LIST(GET CMAKE_C_COMPILER 1 CMAKE_C_COMPILER_ARG1)
-    LIST(GET CMAKE_C_COMPILER 0 CMAKE_C_COMPILER)
-  ENDIF("${_CMAKE_C_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 C compiler already had a path, reuse it for searching the CXX compiler
-  GET_FILENAME_COMPONENT(_CMAKE_USER_C_COMPILER_PATH "${CMAKE_C_COMPILER}" PATH)
-  IF(NOT _CMAKE_USER_C_COMPILER_PATH)
-    FIND_PROGRAM(CMAKE_C_COMPILER_WITH_PATH NAMES ${CMAKE_C_COMPILER})
-    MARK_AS_ADVANCED(CMAKE_C_COMPILER_WITH_PATH)
-    IF(CMAKE_C_COMPILER_WITH_PATH)
-      SET(CMAKE_C_COMPILER ${CMAKE_C_COMPILER_WITH_PATH} CACHE STRING "C compiler" FORCE)
-    ENDIF(CMAKE_C_COMPILER_WITH_PATH)
-  ENDIF(NOT _CMAKE_USER_C_COMPILER_PATH)
-ENDIF(NOT CMAKE_C_COMPILER)
-MARK_AS_ADVANCED(CMAKE_C_COMPILER)
-
-IF (NOT _CMAKE_TOOLCHAIN_LOCATION)
-  GET_FILENAME_COMPONENT(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_C_COMPILER}" PATH)
-ENDIF (NOT _CMAKE_TOOLCHAIN_LOCATION)
-
-# Build a small source file to identify the compiler.
-IF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
-  SET(CMAKE_C_COMPILER_ID_RUN 1)
-  SET(CMAKE_C_PLATFORM_ID "Windows")
-  SET(CMAKE_C_COMPILER_ID "MSVC")
-ENDIF(${CMAKE_GENERATOR} MATCHES "Visual Studio")
-
-IF(NOT CMAKE_C_COMPILER_ID_RUN)
-  SET(CMAKE_C_COMPILER_ID_RUN 1)
+include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake)
+
+# Load system-specific compiler preferences for this language.
+include(Platform/${CMAKE_SYSTEM_NAME}-C OPTIONAL)
+if(NOT CMAKE_C_COMPILER_NAMES)
+  set(CMAKE_C_COMPILER_NAMES cc)
+endif()
+
+if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
+elseif("${CMAKE_GENERATOR}" MATCHES "Xcode")
+  set(CMAKE_C_COMPILER_XCODE_TYPE sourcecode.c.c)
+else()
+  if(NOT CMAKE_C_COMPILER)
+    set(CMAKE_C_COMPILER_INIT NOTFOUND)
+
+    # prefer the environment variable CC
+    if($ENV{CC} MATCHES ".+")
+      get_filename_component(CMAKE_C_COMPILER_INIT $ENV{CC} PROGRAM PROGRAM_ARGS CMAKE_C_FLAGS_ENV_INIT)
+      if(CMAKE_C_FLAGS_ENV_INIT)
+        set(CMAKE_C_COMPILER_ARG1 "${CMAKE_C_FLAGS_ENV_INIT}" CACHE STRING "First argument to C compiler")
+      endif()
+      if(NOT EXISTS ${CMAKE_C_COMPILER_INIT})
+        message(FATAL_ERROR "Could not find compiler set in environment variable CC:\n$ENV{CC}.")
+      endif()
+    endif()
+
+    # next try prefer the compiler specified by the generator
+    if(CMAKE_GENERATOR_CC)
+      if(NOT CMAKE_C_COMPILER_INIT)
+        set(CMAKE_C_COMPILER_INIT ${CMAKE_GENERATOR_CC})
+      endif()
+    endif()
+
+    # finally list compilers to try
+    if(NOT CMAKE_C_COMPILER_INIT)
+      set(CMAKE_C_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}cc ${_CMAKE_TOOLCHAIN_PREFIX}gcc cl bcc xlc clang)
+    endif()
+
+    _cmake_find_compiler(C)
+
+  else()
+
+    # we only get here if CMAKE_C_COMPILER was specified using -D or a pre-made CMakeCache.txt
+    # (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
+    # if CMAKE_C_COMPILER is a list of length 2, use the first item as
+    # CMAKE_C_COMPILER and the 2nd one as CMAKE_C_COMPILER_ARG1
+
+    list(LENGTH CMAKE_C_COMPILER _CMAKE_C_COMPILER_LIST_LENGTH)
+    if("${_CMAKE_C_COMPILER_LIST_LENGTH}" EQUAL 2)
+      list(GET CMAKE_C_COMPILER 1 CMAKE_C_COMPILER_ARG1)
+      list(GET CMAKE_C_COMPILER 0 CMAKE_C_COMPILER)
+    endif()
+
+    # 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 C compiler already had a path, reuse it for searching the CXX compiler
+    get_filename_component(_CMAKE_USER_C_COMPILER_PATH "${CMAKE_C_COMPILER}" PATH)
+    if(NOT _CMAKE_USER_C_COMPILER_PATH)
+      find_program(CMAKE_C_COMPILER_WITH_PATH NAMES ${CMAKE_C_COMPILER})
+      mark_as_advanced(CMAKE_C_COMPILER_WITH_PATH)
+      if(CMAKE_C_COMPILER_WITH_PATH)
+        set(CMAKE_C_COMPILER ${CMAKE_C_COMPILER_WITH_PATH} CACHE STRING "C compiler" FORCE)
+      endif()
+    endif()
+  endif()
+  mark_as_advanced(CMAKE_C_COMPILER)
 
   # 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_C_COMPILER_ID_TEST_FLAGS
+  set(CMAKE_C_COMPILER_ID_TEST_FLAGS
     # Try compiling to an object file only.
     "-c"
 
     # Try enabling ANSI mode on HP.
     "-Aa"
     )
+endif()
+
+# Build a small source file to identify the compiler.
+if(NOT CMAKE_C_COMPILER_ID_RUN)
+  set(CMAKE_C_COMPILER_ID_RUN 1)
 
   # Try to identify the compiler.
-  SET(CMAKE_C_COMPILER_ID)
-  FILE(READ ${CMAKE_ROOT}/Modules/CMakePlatformId.h.in
+  set(CMAKE_C_COMPILER_ID)
+  file(READ ${CMAKE_ROOT}/Modules/CMakePlatformId.h.in
     CMAKE_C_COMPILER_ID_PLATFORM_CONTENT)
-  INCLUDE(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
+  include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
   CMAKE_DETERMINE_COMPILER_ID(C CFLAGS CMakeCCompilerId.c)
 
   # Set old compiler and platform id variables.
-  IF("${CMAKE_C_COMPILER_ID}" MATCHES "GNU")
-    SET(CMAKE_COMPILER_IS_GNUCC 1)
-  ENDIF("${CMAKE_C_COMPILER_ID}" MATCHES "GNU")
-  IF("${CMAKE_C_PLATFORM_ID}" MATCHES "MinGW")
-    SET(CMAKE_COMPILER_IS_MINGW 1)
-  ELSEIF("${CMAKE_C_PLATFORM_ID}" MATCHES "Cygwin")
-    SET(CMAKE_COMPILER_IS_CYGWIN 1)
-  ENDIF("${CMAKE_C_PLATFORM_ID}" MATCHES "MinGW")
-ENDIF(NOT CMAKE_C_COMPILER_ID_RUN)
+  if("${CMAKE_C_COMPILER_ID}" MATCHES "GNU")
+    set(CMAKE_COMPILER_IS_GNUCC 1)
+  endif()
+  if("${CMAKE_C_PLATFORM_ID}" MATCHES "MinGW")
+    set(CMAKE_COMPILER_IS_MINGW 1)
+  elseif("${CMAKE_C_PLATFORM_ID}" MATCHES "Cygwin")
+    set(CMAKE_COMPILER_IS_CYGWIN 1)
+  endif()
+endif()
+
+if (NOT _CMAKE_TOOLCHAIN_LOCATION)
+  get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_C_COMPILER}" PATH)
+endif ()
 
 # If we have a gcc cross compiler, they have usually some prefix, like
 # e.g. powerpc-linux-gcc, arm-elf-gcc or i586-mingw32msvc-gcc, optionally
@@ -147,33 +145,31 @@ ENDIF(NOT CMAKE_C_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_C_COMPILER_ID}" MATCHES "GNU"
     AND NOT _CMAKE_TOOLCHAIN_PREFIX)
-  GET_FILENAME_COMPONENT(COMPILER_BASENAME "${CMAKE_C_COMPILER}" NAME)
-  IF (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
-    SET(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
-  ENDIF (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+  get_filename_component(COMPILER_BASENAME "${CMAKE_C_COMPILER}" NAME)
+  if (COMPILER_BASENAME MATCHES "^(.+-)g?cc(-[0-9]+\\.[0-9]+\\.[0-9]+)?(\\.exe)?$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ()
 
   # 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-$")
-
-ENDIF (CMAKE_CROSSCOMPILING
-    AND "${CMAKE_C_COMPILER_ID}" MATCHES "GNU"
-    AND NOT _CMAKE_TOOLCHAIN_PREFIX)
-
-INCLUDE(${CMAKE_ROOT}/Modules/CMakeClDeps.cmake)
-INCLUDE(CMakeFindBinUtils)
-IF(MSVC_C_ARCHITECTURE_ID)
-  SET(SET_MSVC_C_ARCHITECTURE_ID
-    "SET(MSVC_C_ARCHITECTURE_ID ${MSVC_C_ARCHITECTURE_ID})")
-ENDIF(MSVC_C_ARCHITECTURE_ID)
+  if ("${_CMAKE_TOOLCHAIN_PREFIX}" MATCHES "(.+-)?llvm-$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ()
+
+endif ()
+
+include(${CMAKE_ROOT}/Modules/CMakeClDeps.cmake)
+include(CMakeFindBinUtils)
+if(MSVC_C_ARCHITECTURE_ID)
+  set(SET_MSVC_C_ARCHITECTURE_ID
+    "set(MSVC_C_ARCHITECTURE_ID ${MSVC_C_ARCHITECTURE_ID})")
+endif()
 # configure variables set in this file for fast reload later on
-CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCCompiler.cmake.in
-  "${CMAKE_PLATFORM_ROOT_BIN}/CMakeCCompiler.cmake"
+configure_file(${CMAKE_ROOT}/Modules/CMakeCCompiler.cmake.in
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeCCompiler.cmake
   @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
   )
-SET(CMAKE_C_COMPILER_ENV_VAR "CC")
+set(CMAKE_C_COMPILER_ENV_VAR "CC")
diff --git a/Modules/CMakeDetermineCXXCompiler.cmake b/Modules/CMakeDetermineCXXCompiler.cmake
index 7f8f3ec8b..59da3e60d 100644
--- a/Modules/CMakeDetermineCXXCompiler.cmake
+++ b/Modules/CMakeDetermineCXXCompiler.cmake
@@ -30,123 +30,109 @@
 # If not already set before, it also sets
 #   _CMAKE_TOOLCHAIN_PREFIX
 
-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 ".+")
-
-  # 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)
-
-  # finally list compilers to try
-  IF(CMAKE_CXX_COMPILER_INIT)
-    SET(CMAKE_CXX_COMPILER_LIST ${CMAKE_CXX_COMPILER_INIT})
-  ELSE(CMAKE_CXX_COMPILER_INIT)
-    SET(CMAKE_CXX_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}c++ ${_CMAKE_TOOLCHAIN_PREFIX}g++ CC aCC cl bcc xlC)
-  ENDIF(CMAKE_CXX_COMPILER_INIT)
-
-  # Find the compiler.
-  IF (_CMAKE_USER_C_COMPILER_PATH)
-    FIND_PROGRAM(CMAKE_CXX_COMPILER NAMES ${CMAKE_CXX_COMPILER_LIST} PATHS ${_CMAKE_USER_C_COMPILER_PATH} DOC "C++ compiler" NO_DEFAULT_PATH)
-  ENDIF (_CMAKE_USER_C_COMPILER_PATH)
-  FIND_PROGRAM(CMAKE_CXX_COMPILER NAMES ${CMAKE_CXX_COMPILER_LIST} DOC "C++ compiler")
-
-  IF(CMAKE_CXX_COMPILER_INIT AND NOT CMAKE_CXX_COMPILER)
-    SET(CMAKE_CXX_COMPILER "${CMAKE_CXX_COMPILER_INIT}" CACHE FILEPATH "C++ compiler" FORCE)
-  ENDIF(CMAKE_CXX_COMPILER_INIT AND 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
-#
-# 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)
-
-# 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)
-
-# This block was used before the compiler was identified by building a
-# source file.  Unless g++ crashes when building a small C++
-# executable this should no longer be needed.
-#
-# 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)
-
-# 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)
+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()
+
+if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
+elseif("${CMAKE_GENERATOR}" MATCHES "Xcode")
+  set(CMAKE_CXX_COMPILER_XCODE_TYPE sourcecode.cpp.cpp)
+else()
+  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()
+      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()
+    endif()
+
+    # 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()
+    endif()
+
+    # 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()
+
+    _cmake_find_compiler(CXX)
+  else()
+
+    # 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
+    #
+    # 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()
+
+    # 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()
+    endif()
+  endif()
+  mark_as_advanced(CMAKE_CXX_COMPILER)
 
   # 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"
     )
+endif()
+
+# Build a small source file to identify the compiler.
+if(NOT CMAKE_CXX_COMPILER_ID_RUN)
+  set(CMAKE_CXX_COMPILER_ID_RUN 1)
 
   # 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()
+  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()
+endif()
+
+if (NOT _CMAKE_TOOLCHAIN_LOCATION)
+  get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_CXX_COMPILER}" PATH)
+endif ()
 
 # 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
@@ -155,34 +141,32 @@ 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 ()
 
   # 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-$")
-
-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)
+  if ("${_CMAKE_TOOLCHAIN_PREFIX}" MATCHES "(.+-)?llvm-$")
+    set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
+  endif ()
+
+endif ()
+
+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()
 # configure all variables set in this file
-CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
-  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCXXCompiler.cmake
+configure_file(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
+  ${CMAKE_PLATFORM_INFO_DIR}/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")
diff --git a/Modules/CMakeDetermineCompiler.cmake b/Modules/CMakeDetermineCompiler.cmake
new file mode 100644
index 000000000..2d12c0757
--- /dev/null
+++ b/Modules/CMakeDetermineCompiler.cmake
@@ -0,0 +1,72 @@
+
+#=============================================================================
+# Copyright 2004-2012 Kitware, Inc.
+#
+# Distributed under the OSI-approved