229 files changed, 2811 insertions, 2811 deletions

diff --git a/Modules/AddFileDependencies.cmake b/Modules/AddFileDependencies.cmake
index af7f42f..e88025c 100644
--- a/Modules/AddFileDependencies.cmake
+++ b/Modules/AddFileDependencies.cmake
@@ -20,10 +20,10 @@ macro(ADD_FILE_DEPENDENCIES _file)
    get_source_file_property(_deps ${_file} OBJECT_DEPENDS)
    if (_deps)
       set(_deps ${_deps} ${ARGN})
-   else (_deps)
+   else ()
       set(_deps ${ARGN})
-   endif (_deps)
+   endif ()
 
    set_source_files_properties(${_file} PROPERTIES OBJECT_DEPENDS "${_deps}")
 
-endmacro(ADD_FILE_DEPENDENCIES)
+endmacro()
diff --git a/Modules/BundleUtilities.cmake b/Modules/BundleUtilities.cmake
index 0143d59..4557be6 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/CMakeASMInformation.cmake b/Modules/CMakeASMInformation.cmake
index 69554e4..dce1624 100644
--- a/Modules/CMakeASMInformation.cmake
+++ b/Modules/CMakeASMInformation.cmake
@@ -14,9 +14,9 @@
 
 if(UNIX)
   set(CMAKE_ASM${ASM_DIALECT}_OUTPUT_EXTENSION .o)
-else(UNIX)
+else()
   set(CMAKE_ASM${ASM_DIALECT}_OUTPUT_EXTENSION .obj)
-endif(UNIX)
+endif()
 
 set(CMAKE_INCLUDE_FLAG_ASM${ASM_DIALECT} "-I")       # -I
 set(CMAKE_BASE_NAME)
@@ -24,36 +24,36 @@ get_filename_component(CMAKE_BASE_NAME "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" NAM
 
 if("${CMAKE_BASE_NAME}" STREQUAL "as")
   set(CMAKE_BASE_NAME gas)
-endif("${CMAKE_BASE_NAME}" STREQUAL "as")
+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)
+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("ASM${ASM_DIALECT}" STREQUAL "ASM")
+  endif()
   include(Platform/${CMAKE_BASE_NAME} OPTIONAL)
-endif(NOT _INCLUDED_FILE)
+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(NOT _INCLUDED_FILE)
-endif(CMAKE_SYSTEM_PROCESSOR)
+  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(NOT _INCLUDED_FILE)
+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)
+endif()
 
 
 # Support for CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT and friends:
@@ -61,7 +61,7 @@ set(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT "$ENV{ASM${ASM_DIALECT}FLAGS} ${CMAKE_ASM
 # 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 " ")
+endif()
 set (CMAKE_ASM${ASM_DIALECT}_FLAGS "${CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT}" CACHE STRING
      "Flags used by the assembler during all build types.")
 
@@ -70,7 +70,7 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
   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)
+  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
@@ -79,7 +79,7 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
     "Flags used by the assembler during release builds.")
   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
                  CMAKE_ASM${ASM_DIALECT}_FLAGS_DEBUG
@@ -91,18 +91,18 @@ 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)
+endif()
 
 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
     "<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})
@@ -119,11 +119,11 @@ 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)
+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)
+endif()
 
 
 set(CMAKE_ASM${ASM_DIALECT}_INFOMATION_LOADED 1)
diff --git a/Modules/CMakeBackwardCompatibilityC.cmake b/Modules/CMakeBackwardCompatibilityC.cmake
index 90ad12e..e3b6c82 100644
--- a/Modules/CMakeBackwardCompatibilityC.cmake
+++ b/Modules/CMakeBackwardCompatibilityC.cmake
@@ -16,11 +16,11 @@
 if(CMAKE_GENERATOR MATCHES "Visual Studio 7")
   include(CMakeVS7BackwardCompatibility)
   set(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
-endif(CMAKE_GENERATOR MATCHES "Visual Studio 7")
+endif()
 if(CMAKE_GENERATOR MATCHES "Visual Studio 6")
   include(CMakeVS6BackwardCompatibility)
   set(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
-endif(CMAKE_GENERATOR MATCHES "Visual Studio 6")
+endif()
 
 if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
   # Old CMake versions did not support OS X universal binaries anyway,
@@ -57,10 +57,10 @@ if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
 
   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$")
+  else()
     set (CMAKE_X_CFLAGS "-I${X11_X11_INCLUDE_PATH}" CACHE STRING
          "X11 extra flags.")
-  endif("${X11_X11_INCLUDE_PATH}" MATCHES "^/usr/include$")
+  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.")
@@ -86,7 +86,7 @@ if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
     set(CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
     set(__ERASE_CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
   endif()
-endif(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
+endif()
 
 mark_as_advanced(
 CMAKE_HP_PTHREADS
diff --git a/Modules/CMakeBackwardCompatibilityCXX.cmake b/Modules/CMakeBackwardCompatibilityCXX.cmake
index 6888636..cfc1d91 100644
--- a/Modules/CMakeBackwardCompatibilityCXX.cmake
+++ b/Modules/CMakeBackwardCompatibilityCXX.cmake
@@ -26,10 +26,10 @@ if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
     set(CMAKE_TRY_ANSI_CXX_FLAGS "")
     if(CMAKE_SYSTEM MATCHES "IRIX.*")
       set(CMAKE_TRY_ANSI_CXX_FLAGS "-LANG:std")
-    endif(CMAKE_SYSTEM MATCHES "IRIX.*")
+    endif()
     if(CMAKE_SYSTEM MATCHES "OSF.*")
       set(CMAKE_TRY_ANSI_CXX_FLAGS "-std strict_ansi -nopure_cname")
-    endif(CMAKE_SYSTEM MATCHES "OSF.*")
+    endif()
     # if CMAKE_TRY_ANSI_CXX_FLAGS has something in it, see
     # if the compiler accepts it
     if( CMAKE_TRY_ANSI_CXX_FLAGS MATCHES ".+")
@@ -39,9 +39,9 @@ if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
       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)
+      endif()
+    endif()
+  endif()
   set(CMAKE_CXX_FLAGS_SAVE ${CMAKE_CXX_FLAGS})
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_ANSI_CXXFLAGS}")
   include(TestForANSIStreamHeaders)
@@ -50,5 +50,5 @@ if(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
   include(TestForANSIForScope)
   include(TestForSSTREAM)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_SAVE}")
-endif(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
+endif()
 
diff --git a/Modules/CMakeCCompiler.cmake.in b/Modules/CMakeCCompiler.cmake.in
index 6166ec0..b4eabe5 100644
--- a/Modules/CMakeCCompiler.cmake.in
+++ b/Modules/CMakeCCompiler.cmake.in
@@ -14,13 +14,13 @@ 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)
+endif()
 
 set(CMAKE_C_COMPILER_ENV_VAR "CC")
 
 if(CMAKE_COMPILER_IS_MINGW)
   set(MINGW 1)
-endif(CMAKE_COMPILER_IS_MINGW)
+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)
@@ -33,11 +33,11 @@ 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)
+endif()
 
 if(CMAKE_C_COMPILER_ABI)
   set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
-endif(CMAKE_C_COMPILER_ABI)
+endif()
 
 if(CMAKE_C_LIBRARY_ARCHITECTURE)
   set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_C_LIBRARY_ARCHITECTURE@")
diff --git a/Modules/CMakeCInformation.cmake b/Modules/CMakeCInformation.cmake
index f0b7fe8..ce5ce44 100644
--- a/Modules/CMakeCInformation.cmake
+++ b/Modules/CMakeCInformation.cmake
@@ -22,51 +22,51 @@
 # 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)
+else()
   set(CMAKE_C_OUTPUT_EXTENSION .obj)
-endif(UNIX)
+endif()
 
 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)
+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)
+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)
+  endif()
   if (NOT _INCLUDED_FILE)
     include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
-  endif (NOT _INCLUDED_FILE)
-endif(CMAKE_SYSTEM_PROCESSOR)
+  endif ()
+endif()
 
 
 # load the system- and compiler specific files
 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)
+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)
+endif ()
 
 if(CMAKE_C_SIZEOF_DATA_PTR)
   foreach(f ${CMAKE_C_ABI_FILES})
@@ -100,13 +100,13 @@ endif()
 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)
+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(CMAKE_C_FLAGS_INIT STREQUAL " ")
+endif()
 set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS_INIT}" CACHE STRING
      "Flags used by the compiler during all build types.")
 
@@ -115,7 +115,7 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
   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)
+  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
@@ -124,13 +124,13 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
     "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
     "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}"
     CACHE STRING "Libraries linked by defalut with all C applications.")
   mark_as_advanced(CMAKE_C_STANDARD_LIBRARIES)
-endif(CMAKE_C_STANDARD_LIBRARIES_INIT)
+endif()
 
 include(CMakeCommonLanguageInclude)
 
@@ -165,12 +165,12 @@ include(CMakeCommonLanguageInclude)
 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)
+endif()
 
 # Create a static archive incrementally for large object file counts.
 # If CMAKE_C_CREATE_STATIC_LIBRARY is set it will override these.
@@ -188,24 +188,24 @@ endif()
 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
     "<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)
+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)
+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)
+endif()
 
 mark_as_advanced(
 CMAKE_C_FLAGS
diff --git a/Modules/CMakeCXXCompiler.cmake.in b/Modules/CMakeCXXCompiler.cmake.in
index 3cef7f8..b6477df 100644
--- a/Modules/CMakeCXXCompiler.cmake.in
+++ b/Modules/CMakeCXXCompiler.cmake.in
@@ -14,13 +14,13 @@ 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)
+endif()
 
 set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
 
 if(CMAKE_COMPILER_IS_MINGW)
   set(MINGW 1)
-endif(CMAKE_COMPILER_IS_MINGW)
+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)
@@ -34,11 +34,11 @@ 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)
+endif()
 
 if(CMAKE_CXX_COMPILER_ABI)
   set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
-endif(CMAKE_CXX_COMPILER_ABI)
+endif()
 
 if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
   set(CMAKE_LIBRARY_ARCHITECTURE "@CMAKE_CXX_LIBRARY_ARCHITECTURE@")
diff --git a/Modules/CMakeCXXInformation.cmake b/Modules/CMakeCXXInformation.cmake
index 961d9cd..933c15a 100644
--- a/Modules/CMakeCXXInformation.cmake
+++ b/Modules/CMakeCXXInformation.cmake
@@ -22,50 +22,50 @@
 # 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)
+else()
   set(CMAKE_CXX_OUTPUT_EXTENSION .obj)
-endif(UNIX)
+endif()
 
 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)
+endif()
 
 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)
+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)
+  endif()
   if (NOT _INCLUDED_FILE)
     include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
-  endif (NOT _INCLUDED_FILE)
-endif(CMAKE_SYSTEM_PROCESSOR)
+  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)
+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)
+endif ()
 
 if(CMAKE_CXX_SIZEOF_DATA_PTR)
   foreach(f ${CMAKE_CXX_ABI_FILES})
@@ -98,39 +98,39 @@ endif()
 # 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)
+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)
+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)
+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)
+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)
+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)
+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)
+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)
+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)
+endif()
 
 if(NOT DEFINED CMAKE_EXE_EXPORTS_CXX_FLAG)
   set(CMAKE_EXE_EXPORTS_CXX_FLAG ${CMAKE_EXE_EXPORTS_C_FLAG})
@@ -142,27 +142,27 @@ 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)
+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)
+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)
+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)
+endif()
 
 if(NOT CMAKE_INCLUDE_FLAG_CXX)
   set(CMAKE_INCLUDE_FLAG_CXX ${CMAKE_INCLUDE_FLAG_C})
-endif(NOT CMAKE_INCLUDE_FLAG_CXX)
+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)
+endif()
 
 # for most systems a module is the same as a shared library
 # so unless the variable CMAKE_MODULE_EXISTS is set just
@@ -170,28 +170,28 @@ endif(NOT CMAKE_INCLUDE_FLAG_SEP_CXX)
 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)
+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)
+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)
+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
       ${CMAKE_${type}_LINK_STATIC_C_FLAGS})
-  endif(NOT CMAKE_${type}_LINK_STATIC_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
@@ -201,7 +201,7 @@ 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 " ")
+endif()
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_INIT}" CACHE STRING
      "Flags used by the compiler during all build types.")
 
@@ -215,13 +215,13 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
   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}"
     CACHE STRING "Libraries linked by defalut with all C++ applications.")
   mark_as_advanced(CMAKE_CXX_STANDARD_LIBRARIES)
-endif(CMAKE_CXX_STANDARD_LIBRARIES_INIT)
+endif()
 
 include(CMakeCommonLanguageInclude)
 
@@ -255,12 +255,12 @@ include(CMakeCommonLanguageInclude)
 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)
+endif()
 
 
 # Create a static archive incrementally for large object file counts.
@@ -279,12 +279,12 @@ endif()
 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
     "<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(
 CMAKE_BUILD_TOOL
diff --git a/Modules/CMakeCommonLanguageInclude.cmake b/Modules/CMakeCommonLanguageInclude.cmake
index 99b5f11..bf94f9f 100644
--- a/Modules/CMakeCommonLanguageInclude.cmake
+++ b/Modules/CMakeCommonLanguageInclude.cmake
@@ -25,7 +25,7 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
   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)
+  endif()
 
   set (CMAKE_EXE_LINKER_FLAGS_DEBUG ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
      "Flags used by the linker during debug builds.")
@@ -68,7 +68,7 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
      ${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}"
      CACHE STRING "Flags used by the linker during the creation of dll's.")
diff --git a/Modules/CMakeDependentOption.cmake b/Modules/CMakeDependentOption.cmake
index 98cae45..990728f 100644
--- a/Modules/CMakeDependentOption.cmake
+++ b/Modules/CMakeDependentOption.cmake
@@ -31,21 +31,21 @@ macro(CMAKE_DEPENDENT_OPTION option doc default depends force)
     foreach(d ${depends})
       string(REGEX REPLACE " +" ";" CMAKE_DEPENDENT_OPTION_DEP "${d}")
       if(${CMAKE_DEPENDENT_OPTION_DEP})
-      else(${CMAKE_DEPENDENT_OPTION_DEP})
+      else()
         set(${option}_AVAILABLE 0)
-      endif(${CMAKE_DEPENDENT_OPTION_DEP})
-    endforeach(d)
+      endif()
+    endforeach()
     if(${option}_AVAILABLE)
       option(${option} "${doc}" "${default}")
       set(${option} "${${option}}" CACHE BOOL "${doc}" FORCE)
-    else(${option}_AVAILABLE)
+    else()
       if(${option} MATCHES "^${option}$")
-      else(${option} MATCHES "^${option}$")
+      else()
         set(${option} "${${option}}" CACHE INTERNAL "${doc}")
-      endif(${option} MATCHES "^${option}$")
+      endif()
       set(${option} ${force})
-    endif(${option}_AVAILABLE)
-  else(${option}_ISSET MATCHES "^${option}_ISSET$")
+    endif()
+  else()
     set(${option} "${${option}_ISSET}")
-  endif(${option}_ISSET MATCHES "^${option}_ISSET$")
-endmacro(CMAKE_DEPENDENT_OPTION)
+  endif()
+endmacro()
diff --git a/Modules/CMakeDetermineASMCompiler.cmake b/Modules/CMakeDetermineASMCompiler.cmake
index ad6616c..4cf29dd 100644
--- a/Modules/CMakeDetermineASMCompiler.cmake
+++ b/Modules/CMakeDetermineASMCompiler.cmake
@@ -20,7 +20,7 @@ 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 ".+")
+  endif()
 
   # finally list compilers to try
   if("ASM${ASM_DIALECT}" STREQUAL "ASM") # the generic assembler support
@@ -47,7 +47,7 @@ if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
   # Find the compiler.
   _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
@@ -62,14 +62,14 @@ else(NOT 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)
+    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)
+endif ()
 
 
 if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
@@ -110,9 +110,9 @@ 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)
+else()
   message(STATUS "The ASM${ASM_DIALECT} compiler identification is unknown")
-endif(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
+endif()
 
 
 
@@ -127,22 +127,22 @@ 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)
+  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)
+  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)
+  endif ()
+endif ()
 
 
 include(CMakeFindBinUtils)
@@ -151,9 +151,9 @@ 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)
+else()
   message(STATUS "Didn't find assembler")
-endif(CMAKE_ASM${ASM_DIALECT}_COMPILER)
+endif()
 
 
 set(_CMAKE_ASM_COMPILER "${CMAKE_ASM${ASM_DIALECT}_COMPILER}")
diff --git a/Modules/CMakeDetermineASM_MASMCompiler.cmake b/Modules/CMakeDetermineASM_MASMCompiler.cmake
index 3649537..665a65c 100644
--- a/Modules/CMakeDetermineASM_MASMCompiler.cmake
+++ b/Modules/CMakeDetermineASM_MASMCompiler.cmake
@@ -19,9 +19,9 @@ 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)
+else()
    set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ml)
-endif(CMAKE_CL_64)
+endif()
 
 include(CMakeDetermineASMCompiler)
 set(ASM_DIALECT)
diff --git a/Modules/CMakeDetermineASM_NASMCompiler.cmake b/Modules/CMakeDetermineASM_NASMCompiler.cmake
index a9a9e05..50f71dd 100644
--- a/Modules/CMakeDetermineASM_NASMCompiler.cmake
+++ b/Modules/CMakeDetermineASM_NASMCompiler.cmake
@@ -19,7 +19,7 @@ set(CMAKE_ASM_NASM_COMPILER_INIT nasm yasm)
 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")
diff --git a/Modules/CMakeDetermineCCompiler.cmake b/Modules/CMakeDetermineCCompiler.cmake
index 6bed021..171eadd 100644
--- a/Modules/CMakeDetermineCCompiler.cmake
+++ b/Modules/CMakeDetermineCCompiler.cmake
@@ -47,18 +47,18 @@ if(NOT CMAKE_C_COMPILER)
     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)
+    endif()
     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 ".+")
+    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(NOT CMAKE_C_COMPILER_INIT)
-  endif(CMAKE_GENERATOR_CC)
+    endif()
+  endif()
 
   # finally list compilers to try
   if(NOT CMAKE_C_COMPILER_INIT)
@@ -67,7 +67,7 @@ if(NOT CMAKE_C_COMPILER)
 
   _cmake_find_compiler(C)
 
-else(NOT CMAKE_C_COMPILER)
+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
@@ -78,7 +78,7 @@ else(NOT CMAKE_C_COMPILER)
   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)
+  endif()
 
   # if a compiler was specified by the user but without path,
   # now try to find it with the full path
@@ -91,21 +91,21 @@ else(NOT 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)
+    endif()
+  endif()
+endif()
 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)
+endif ()
 
 # 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")
+endif()
 
 if(NOT CMAKE_C_COMPILER_ID_RUN)
   set(CMAKE_C_COMPILER_ID_RUN 1)
@@ -131,13 +131,13 @@ if(NOT CMAKE_C_COMPILER_ID_RUN)
   # 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")
+  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("${CMAKE_C_PLATFORM_ID}" MATCHES "MinGW")
-endif(NOT CMAKE_C_COMPILER_ID_RUN)
+  endif()
+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
@@ -152,13 +152,13 @@ if (CMAKE_CROSSCOMPILING
   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)?$")
+  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 ()
 
 endif (CMAKE_CROSSCOMPILING
     AND "${CMAKE_C_COMPILER_ID}" MATCHES "GNU"
@@ -169,7 +169,7 @@ 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)
+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"
diff --git a/Modules/CMakeDetermineCXXCompiler.cmake b/Modules/CMakeDetermineCXXCompiler.cmake
index aaabb20..898947a 100644
--- a/Modules/CMakeDetermineCXXCompiler.cmake
+++ b/Modules/CMakeDetermineCXXCompiler.cmake
@@ -46,18 +46,18 @@ if(NOT CMAKE_CXX_COMPILER)
     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)
+    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(NOT EXISTS ${CMAKE_CXX_COMPILER_INIT})
-  endif($ENV{CXX} MATCHES ".+")
+    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(NOT CMAKE_CXX_COMPILER_INIT)
-  endif(CMAKE_GENERATOR_CXX)
+    endif()
+  endif()
 
   # finally list compilers to try
   if(NOT CMAKE_CXX_COMPILER_INIT)
@@ -65,7 +65,7 @@ if(NOT CMAKE_CXX_COMPILER)
   endif()
 
   _cmake_find_compiler(CXX)
-else(NOT CMAKE_CXX_COMPILER)
+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
@@ -77,7 +77,7 @@ else(NOT CMAKE_CXX_COMPILER)
   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)
+  endif()
 
 # if a compiler was specified by the user but without path,
 # now try to find it with the full path
@@ -90,14 +90,14 @@ else(NOT 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)
+    endif()
+  endif()
+endif()
 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)
+endif ()
 
 # This block was used before the compiler was identified by building a
 # source file.  Unless g++ crashes when building a small C++
@@ -109,14 +109,14 @@ endif (NOT _CMAKE_TOOLCHAIN_LOCATION)
 # if(BEOS)
 #   set(CMAKE_COMPILER_IS_GNUCXX 1)
 #   set(CMAKE_COMPILER_IS_GNUCXX_RUN 1)
-# endif(BEOS)
+# endif()
 
 # 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")
+endif()
 if(NOT CMAKE_CXX_COMPILER_ID_RUN)
   set(CMAKE_CXX_COMPILER_ID_RUN 1)
 
@@ -138,13 +138,13 @@ if(NOT CMAKE_CXX_COMPILER_ID_RUN)
   # 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")
+  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("${CMAKE_CXX_PLATFORM_ID}" MATCHES "MinGW")
-endif(NOT CMAKE_CXX_COMPILER_ID_RUN)
+  endif()
+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
@@ -159,13 +159,13 @@ if (CMAKE_CROSSCOMPILING
   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)?$")
+  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 ()
 
 endif (CMAKE_CROSSCOMPILING
     AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU"
@@ -176,7 +176,7 @@ 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)
+endif()
 # configure all variables set in this file
 configure_file(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
   ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCXXCompiler.cmake
diff --git a/Modules/CMakeDetermineCompilerABI.cmake b/Modules/CMakeDetermineCompilerABI.cmake
index b79afdf..ae2eb9b 100644
--- a/Modules/CMakeDetermineCompilerABI.cmake
+++ b/Modules/CMakeDetermineCompilerABI.cmake
@@ -49,21 +49,21 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
       foreach(info ${ABI_STRINGS})
         if("${info}" MATCHES ".*INFO:sizeof_dptr\\[0*([^]]*)\\].*")
           string(REGEX REPLACE ".*INFO:sizeof_dptr\\[0*([^]]*)\\].*" "\\1" ABI_SIZEOF_DPTR "${info}")
-        endif("${info}" MATCHES ".*INFO:sizeof_dptr\\[0*([^]]*)\\].*")
+        endif()
         if("${info}" MATCHES ".*INFO:abi\\[([^]]*)\\].*")
           string(REGEX REPLACE ".*INFO:abi\\[([^]]*)\\].*" "\\1" ABI_NAME "${info}")
-        endif("${info}" MATCHES ".*INFO:abi\\[([^]]*)\\].*")
-      endforeach(info)
+        endif()
+      endforeach()
 
       if(ABI_SIZEOF_DPTR)
         set(CMAKE_${lang}_SIZEOF_DATA_PTR "${ABI_SIZEOF_DPTR}" PARENT_SCOPE)
       elseif(CMAKE_${lang}_SIZEOF_DATA_PTR_DEFAULT)
         set(CMAKE_${lang}_SIZEOF_DATA_PTR "${CMAKE_${lang}_SIZEOF_DATA_PTR_DEFAULT}" PARENT_SCOPE)
-      endif(ABI_SIZEOF_DPTR)
+      endif()
 
       if(ABI_NAME)
         set(CMAKE_${lang}_COMPILER_ABI "${ABI_NAME}" PARENT_SCOPE)
-      endif(ABI_NAME)
+      endif()
 
       # Parse implicit linker information for this language, if available.
       set(implicit_dirs "")
@@ -122,10 +122,10 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
         endforeach()
       endif()
 
-    else(CMAKE_DETERMINE_${lang}_ABI_COMPILED)
+    else()
       message(STATUS "Detecting ${lang} compiler ABI info - failed")
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
         "Detecting ${lang} compiler ABI info failed to compile with the following output:\n${OUTPUT}\n\n")
-    endif(CMAKE_DETERMINE_${lang}_ABI_COMPILED)
-  endif(NOT DEFINED CMAKE_DETERMINE_${lang}_ABI_COMPILED)
-endfunction(CMAKE_DETERMINE_COMPILER_ABI)
+    endif()
+  endif()
+endfunction()
diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake
index 6fd0add..f574978 100644
--- a/Modules/CMakeDetermineCompilerId.cmake
+++ b/Modules/CMakeDetermineCompilerId.cmake
@@ -24,9 +24,9 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
   # Make sure user-specified compiler flags are used.
   if(CMAKE_${lang}_FLAGS)
     set(CMAKE_${lang}_COMPILER_ID_FLAGS ${CMAKE_${lang}_FLAGS})
-  else(CMAKE_${lang}_FLAGS)
+  else()
     set(CMAKE_${lang}_COMPILER_ID_FLAGS $ENV{${flagvar}})
-  endif(CMAKE_${lang}_FLAGS)
+  endif()
   string(REGEX REPLACE " " ";" CMAKE_${lang}_COMPILER_ID_FLAGS_LIST "${CMAKE_${lang}_COMPILER_ID_FLAGS}")
 
   # Compute the directory in which to run the test.
@@ -39,9 +39,9 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
       CMAKE_DETERMINE_COMPILER_ID_BUILD("${lang}" "${flags}" "${src}")
       foreach(file ${COMPILER_${lang}_PRODUCED_FILES})
         CMAKE_DETERMINE_COMPILER_ID_CHECK("${lang}" "${CMAKE_${lang}_COMPILER_ID_DIR}/${file}" "${src}")
-      endforeach(file)
-    endif(NOT CMAKE_${lang}_COMPILER_ID)
-  endforeach(flags)
+      endforeach()
+    endif()
+  endforeach()
 
   # If the compiler is still unknown, try to query its vendor.
   if(NOT CMAKE_${lang}_COMPILER_ID)
@@ -51,7 +51,7 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
   # if the format is unknown after all files have been checked, put "Unknown" in the cache
   if(NOT CMAKE_EXECUTABLE_FORMAT)
     set(CMAKE_EXECUTABLE_FORMAT "Unknown" CACHE INTERNAL "Executable file format")
-  endif(NOT CMAKE_EXECUTABLE_FORMAT)
+  endif()
 
   # Display the final identification result.
   if(CMAKE_${lang}_COMPILER_ID)
@@ -62,16 +62,16 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
     endif()
     message(STATUS "The ${lang} compiler identification is "
       "${CMAKE_${lang}_COMPILER_ID}${_version}")
-  else(CMAKE_${lang}_COMPILER_ID)
+  else()
     message(STATUS "The ${lang} compiler identification is unknown")
-  endif(CMAKE_${lang}_COMPILER_ID)
+  endif()
 
   set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)
   set(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE)
   set(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}"
     PARENT_SCOPE)
   set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_${lang}_COMPILER_VERSION}" PARENT_SCOPE)
-endfunction(CMAKE_DETERMINE_COMPILER_ID)
+endfunction()
 
 #-----------------------------------------------------------------------------
 # Function to write the compiler id source file.
@@ -79,7 +79,7 @@ function(CMAKE_DETERMINE_COMPILER_ID_WRITE lang src)
   file(READ ${CMAKE_ROOT}/Modules/${src}.in ID_CONTENT_IN)
   string(CONFIGURE "${ID_CONTENT_IN}" ID_CONTENT_OUT @ONLY)
   file(WRITE ${CMAKE_${lang}_COMPILER_ID_DIR}/${src} "${ID_CONTENT_OUT}")
-endfunction(CMAKE_DETERMINE_COMPILER_ID_WRITE)
+endfunction()
 
 #-----------------------------------------------------------------------------
 # Function to build the compiler id source file and look for output
@@ -110,7 +110,7 @@ Id flags: ${testflags}
       ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
       RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT
       )
-  else(COMMAND EXECUTE_PROCESS)
+  else()
     exec_program(
       ${CMAKE_${lang}_COMPILER} ${CMAKE_${lang}_COMPILER_ID_DIR}
       ARGS ${CMAKE_${lang}_COMPILER_ID_ARG1}
@@ -120,7 +120,7 @@ Id flags: ${testflags}
       OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT
       RETURN_VALUE CMAKE_${lang}_COMPILER_ID_RESULT
       )
-  endif(COMMAND EXECUTE_PROCESS)
+  endif()
 
   # Check the result of compilation.
   if(CMAKE_${lang}_COMPILER_ID_RESULT)
@@ -136,11 +136,11 @@ ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "${MSG}")
     #if(NOT CMAKE_${lang}_COMPILER_ID_ALLOW_FAIL)
     #  message(FATAL_ERROR "${MSG}")
-    #endif(NOT CMAKE_${lang}_COMPILER_ID_ALLOW_FAIL)
+    #endif()
 
     # No output files should be inspected.
     set(COMPILER_${lang}_PRODUCED_FILES)
-  else(CMAKE_${lang}_COMPILER_ID_RESULT)
+  else()
     # Compilation succeeded.
     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
       "Compiling the ${lang} compiler identification source file \"${src}\" succeeded.
@@ -161,7 +161,7 @@ ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
         "Compilation of the ${lang} compiler identification source \""
         "${src}\" produced \"${file}\"\n\n")
-    endforeach(file)
+    endforeach()
 
     if(NOT COMPILER_${lang}_PRODUCED_FILES)
       # No executable was found.
@@ -169,12 +169,12 @@ ${CMAKE_${lang}_COMPILER_ID_OUTPUT}
         "Compilation of the ${lang} compiler identification source \""
         "${src}\" did not produce an executable in \""
         "${CMAKE_${lang}_COMPILER_ID_DIR}\".\n\n")
-    endif(NOT COMPILER_${lang}_PRODUCED_FILES)
-  endif(CMAKE_${lang}_COMPILER_ID_RESULT)
+    endif()
+  endif()
 
   # Return the files produced by the compilation.
   set(COMPILER_${lang}_PRODUCED_FILES "${COMPILER_${lang}_PRODUCED_FILES}" PARENT_SCOPE)
-endfunction(CMAKE_DETERMINE_COMPILER_ID_BUILD lang testflags src)
+endfunction()
 
 #-----------------------------------------------------------------------------
 # Function to extract the compiler id from an executable.
@@ -192,24 +192,24 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
       if("${info}" MATCHES ".*INFO:compiler\\[([^]\"]*)\\].*")
         if(COMPILER_ID)
           set(COMPILER_ID_TWICE 1)
-        endif(COMPILER_ID)
+        endif()
         string(REGEX REPLACE ".*INFO:compiler\\[([^]]*)\\].*" "\\1"
           COMPILER_ID "${info}")
-      endif("${info}" MATCHES ".*INFO:compiler\\[([^]\"]*)\\].*")
+      endif()
       if("${info}" MATCHES ".*INFO:platform\\[([^]\"]*)\\].*")
         string(REGEX REPLACE ".*INFO:platform\\[([^]]*)\\].*" "\\1"
           PLATFORM_ID "${info}")
-      endif("${info}" MATCHES ".*INFO:platform\\[([^]\"]*)\\].*")
+      endif()
       if("${info}" MATCHES ".*INFO:arch\\[([^]\"]*)\\].*")
         string(REGEX REPLACE ".*INFO:arch\\[([^]]*)\\].*" "\\1"
           ARCHITECTURE_ID "${info}")
-      endif("${info}" MATCHES ".*INFO:arch\\[([^]\"]*)\\].*")
+      endif()
       if("${info}" MATCHES ".*INFO:compiler_version\\[([^]\"]*)\\].*")
         string(REGEX REPLACE ".*INFO:compiler_version\\[([^]]*)\\].*" "\\1" COMPILER_VERSION "${info}")
         string(REGEX REPLACE "^0+([0-9])" "\\1" COMPILER_VERSION "${COMPILER_VERSION}")
         string(REGEX REPLACE "\\.0+([0-9])" ".\\1" COMPILER_VERSION "${COMPILER_VERSION}")
-      endif("${info}" MATCHES ".*INFO:compiler_version\\[([^]\"]*)\\].*")
-    endforeach(info)
+      endif()
+    endforeach()
 
     # Check if a valid compiler and platform were found.
     if(COMPILER_ID AND NOT COMPILER_ID_TWICE)
@@ -217,7 +217,7 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
       set(CMAKE_${lang}_PLATFORM_ID "${PLATFORM_ID}")
       set(MSVC_${lang}_ARCHITECTURE_ID "${ARCHITECTURE_ID}")
       set(CMAKE_${lang}_COMPILER_VERSION "${COMPILER_VERSION}")
-    endif(COMPILER_ID AND NOT COMPILER_ID_TWICE)
+    endif()
 
     # Check the compiler identification string.
     if(CMAKE_${lang}_COMPILER_ID)
@@ -225,13 +225,13 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
         "The ${lang} compiler identification is ${CMAKE_${lang}_COMPILER_ID}, found in \""
         "${file}\"\n\n")
-    else(CMAKE_${lang}_COMPILER_ID)
+    else()
       # The compiler identification could not be found.
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
         "The ${lang} compiler identification could not be found in \""
         "${file}\"\n\n")
-    endif(CMAKE_${lang}_COMPILER_ID)
-  endif(NOT CMAKE_${lang}_COMPILER_ID)
+    endif()
+  endif()
 
   # try to figure out the executable format: ELF, COFF, Mach-O
   if(NOT CMAKE_EXECUTABLE_FORMAT)
@@ -240,22 +240,22 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
     # ELF files start with 0x7f"ELF"
     if("${CMAKE_EXECUTABLE_MAGIC}" STREQUAL "7f454c46")
       set(CMAKE_EXECUTABLE_FORMAT "ELF" CACHE INTERNAL "Executable file format")
-    endif("${CMAKE_EXECUTABLE_MAGIC}" STREQUAL "7f454c46")
+    endif()
 
 #    # COFF (.exe) files start with "MZ"
 #    if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "4d5a....")
 #      set(CMAKE_EXECUTABLE_FORMAT "COFF" CACHE STRING "Executable file format")
-#    endif("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "4d5a....")
+#    endif()
 #
 #    # Mach-O files start with CAFEBABE or FEEDFACE, according to http://radio.weblogs.com/0100490/2003/01/28.html
 #    if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "cafebabe")
 #      set(CMAKE_EXECUTABLE_FORMAT "MACHO" CACHE STRING "Executable file format")
-#    endif("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "cafebabe")
+#    endif()
 #    if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "feedface")
 #      set(CMAKE_EXECUTABLE_FORMAT "MACHO" CACHE STRING "Executable file format")
-#    endif("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "feedface")
+#    endif()
 
-  endif(NOT CMAKE_EXECUTABLE_FORMAT)
+  endif()
   if(NOT DEFINED CMAKE_EXECUTABLE_FORMAT)
     set(CMAKE_EXECUTABLE_FORMAT)
   endif()
@@ -266,7 +266,7 @@ function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file)
     PARENT_SCOPE)
   set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_${lang}_COMPILER_VERSION}" PARENT_SCOPE)
   set(CMAKE_EXECUTABLE_FORMAT "${CMAKE_EXECUTABLE_FORMAT}" PARENT_SCOPE)
-endfunction(CMAKE_DETERMINE_COMPILER_ID_CHECK lang)
+endfunction()
 
 #-----------------------------------------------------------------------------
 # Function to query the compiler vendor.
@@ -285,7 +285,7 @@ function(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang)
     set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CompilerId${lang})
     file(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR})
     file(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR})
-  endif(NOT CMAKE_${lang}_COMPILER_ID_DIR)
+  endif()
 
 
   foreach(vendor ${CMAKE_${lang}_COMPILER_ID_VENDORS})
@@ -320,4 +320,4 @@ function(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang)
        endif()
     endif()
   endforeach()
-endfunction(CMAKE_DETERMINE_COMPILER_ID_VENDOR)
+endfunction()
diff --git a/Modules/CMakeDetermineFortranCompiler.cmake b/Modules/CMakeDetermineFortranCompiler.cmake
index c8e5612..da77e21 100644
--- a/Modules/CMakeDetermineFortranCompiler.cmake
+++ b/Modules/CMakeDetermineFortranCompiler.cmake
@@ -31,19 +31,19 @@ if(NOT CMAKE_Fortran_COMPILER)
     get_filename_component(CMAKE_Fortran_COMPILER_INIT $ENV{FC} PROGRAM PROGRAM_ARGS CMAKE_Fortran_FLAGS_ENV_INIT)
     if(CMAKE_Fortran_FLAGS_ENV_INIT)
       set(CMAKE_Fortran_COMPILER_ARG1 "${CMAKE_Fortran_FLAGS_ENV_INIT}" CACHE STRING "First argument to Fortran compiler")
-    endif(CMAKE_Fortran_FLAGS_ENV_INIT)
+    endif()
     if(EXISTS ${CMAKE_Fortran_COMPILER_INIT})
-    else(EXISTS ${CMAKE_Fortran_COMPILER_INIT})
+    else()
       message(FATAL_ERROR "Could not find compiler set in environment variable FC:\n$ENV{FC}.")
-    endif(EXISTS ${CMAKE_Fortran_COMPILER_INIT})
-  endif($ENV{FC} MATCHES ".+")
+    endif()
+  endif()
 
   # next try prefer the compiler specified by the generator
   if(CMAKE_GENERATOR_FC)
     if(NOT CMAKE_Fortran_COMPILER_INIT)
       set(CMAKE_Fortran_COMPILER_INIT ${CMAKE_GENERATOR_FC})
-    endif(NOT CMAKE_Fortran_COMPILER_INIT)
-  endif(CMAKE_GENERATOR_FC)
+    endif()
+  endif()
 
   # finally list compilers to try
   if(NOT CMAKE_Fortran_COMPILER_INIT)
@@ -85,7 +85,7 @@ if(NOT CMAKE_Fortran_COMPILER)
 
   _cmake_find_compiler(Fortran)
 
-else(NOT CMAKE_Fortran_COMPILER)
+else()
    # we only get here if CMAKE_Fortran_COMPILER was specified using -D or a pre-made CMakeCache.txt
   # (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
   # if CMAKE_Fortran_COMPILER is a list of length 2, use the first item as
@@ -95,7 +95,7 @@ else(NOT CMAKE_Fortran_COMPILER)
   if("${_CMAKE_Fortran_COMPILER_LIST_LENGTH}" EQUAL 2)
     list(GET CMAKE_Fortran_COMPILER 1 CMAKE_Fortran_COMPILER_ARG1)
     list(GET CMAKE_Fortran_COMPILER 0 CMAKE_Fortran_COMPILER)
-  endif("${_CMAKE_Fortran_COMPILER_LIST_LENGTH}" EQUAL 2)
+  endif()
 
   # if a compiler was specified by the user but without path,
   # now try to find it with the full path
@@ -109,9 +109,9 @@ else(NOT CMAKE_Fortran_COMPILER)
     if(CMAKE_Fortran_COMPILER_WITH_PATH)
       set(CMAKE_Fortran_COMPILER ${CMAKE_Fortran_COMPILER_WITH_PATH}
         CACHE STRING "Fortran compiler" FORCE)
-    endif(CMAKE_Fortran_COMPILER_WITH_PATH)
-  endif(NOT _CMAKE_USER_Fortran_COMPILER_PATH)
-endif(NOT CMAKE_Fortran_COMPILER)
+    endif()
+  endif()
+endif()
 
 mark_as_advanced(CMAKE_Fortran_COMPILER)
 
@@ -120,7 +120,7 @@ if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
   set(CMAKE_Fortran_COMPILER_ID_RUN 1)
   set(CMAKE_Fortran_PLATFORM_ID "Windows")
   set(CMAKE_Fortran_COMPILER_ID "Intel")
-endif(${CMAKE_GENERATOR} MATCHES "Visual Studio")
+endif()
 
 if(NOT CMAKE_Fortran_COMPILER_ID_RUN)
   set(CMAKE_Fortran_COMPILER_ID_RUN 1)
@@ -160,32 +160,32 @@ if(NOT CMAKE_Fortran_COMPILER_ID_RUN)
         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
           "Determining if the Fortran compiler is GNU succeeded with "
           "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
-      else("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
+      else()
         file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
           "Determining if the Fortran compiler is GNU failed with "
           "the following output:\n${CMAKE_COMPILER_OUTPUT}\n\n")
-      endif("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
+      endif()
       if(NOT CMAKE_Fortran_PLATFORM_ID)
         if("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_MINGW.*" )
           set(CMAKE_Fortran_PLATFORM_ID "MinGW")
-        endif("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_MINGW.*" )
+        endif()
         if("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_CYGWIN.*" )
           set(CMAKE_Fortran_PLATFORM_ID "Cygwin")
-        endif("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_CYGWIN.*" )
-      endif(NOT CMAKE_Fortran_PLATFORM_ID)
-    endif(NOT CMAKE_COMPILER_RETURN)
-  endif(NOT CMAKE_Fortran_COMPILER_ID)
+        endif()
+      endif()
+    endif()
+  endif()
 
   # Set old compiler and platform id variables.
   if("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU")
     set(CMAKE_COMPILER_IS_GNUG77 1)
-  endif("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU")
+  endif()
   if("${CMAKE_Fortran_PLATFORM_ID}" MATCHES "MinGW")
     set(CMAKE_COMPILER_IS_MINGW 1)
   elseif("${CMAKE_Fortran_PLATFORM_ID}" MATCHES "Cygwin")
     set(CMAKE_COMPILER_IS_CYGWIN 1)
-  endif("${CMAKE_Fortran_PLATFORM_ID}" MATCHES "MinGW")
-endif(NOT CMAKE_Fortran_COMPILER_ID_RUN)
+  endif()
+endif()
 
 include(CMakeFindBinUtils)
 
diff --git a/Modules/CMakeDetermineJavaCompiler.cmake b/Modules/CMakeDetermineJavaCompiler.cmake
index f35b9ff..3f430b4 100644
--- a/Modules/CMakeDetermineJavaCompiler.cmake
+++ b/Modules/CMakeDetermineJavaCompiler.cmake
@@ -22,25 +22,25 @@ if(NOT CMAKE_Java_COMPILER)
     get_filename_component(CMAKE_Java_COMPILER_INIT $ENV{JAVA_COMPILER} PROGRAM PROGRAM_ARGS CMAKE_Java_FLAGS_ENV_INIT)
     if(CMAKE_Java_FLAGS_ENV_INIT)
       set(CMAKE_Java_COMPILER_ARG1 "${CMAKE_Java_FLAGS_ENV_INIT}" CACHE STRING "First argument to Java compiler")
-    endif(CMAKE_Java_FLAGS_ENV_INIT)
+    endif()
     if(NOT EXISTS ${CMAKE_Java_COMPILER_INIT})
       message(SEND_ERROR "Could not find compiler set in environment variable JAVA_COMPILER:\n$ENV{JAVA_COMPILER}.")
-    endif(NOT EXISTS ${CMAKE_Java_COMPILER_INIT})
-  endif($ENV{JAVA_COMPILER} MATCHES ".+")
+    endif()
+  endif()
 
   if($ENV{JAVA_RUNTIME} MATCHES ".+")
     get_filename_component(CMAKE_Java_RUNTIME_INIT $ENV{JAVA_RUNTIME} PROGRAM PROGRAM_ARGS CMAKE_Java_FLAGS_ENV_INIT)
     if(NOT EXISTS ${CMAKE_Java_RUNTIME_INIT})
       message(SEND_ERROR "Could not find compiler set in environment variable JAVA_RUNTIME:\n$ENV{JAVA_RUNTIME}.")
-    endif(NOT EXISTS ${CMAKE_Java_RUNTIME_INIT})
-  endif($ENV{JAVA_RUNTIME} MATCHES ".+")
+    endif()
+  endif()
 
   if($ENV{JAVA_ARCHIVE} MATCHES ".+")
     get_filename_component(CMAKE_Java_ARCHIVE_INIT $ENV{JAVA_ARCHIVE} PROGRAM PROGRAM_ARGS CMAKE_Java_FLAGS_ENV_INIT)
     if(NOT EXISTS ${CMAKE_Java_ARCHIVE_INIT})
       message(SEND_ERROR "Could not find compiler set in environment variable JAVA_ARCHIVE:\n$ENV{JAVA_ARCHIVE}.")
-    endif(NOT EXISTS ${CMAKE_Java_ARCHIVE_INIT})
-  endif($ENV{JAVA_ARCHIVE} MATCHES ".+")
+    endif()
+  endif()
 
   set(Java_BIN_PATH
     "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\2.0;JavaHome]/bin"
@@ -67,33 +67,33 @@ if(NOT CMAKE_Java_COMPILER)
   # if no compiler has been specified yet, then look for one
   if(CMAKE_Java_COMPILER_INIT)
     set(CMAKE_Java_COMPILER ${CMAKE_Java_COMPILER_INIT} CACHE PATH "Java Compiler")
-  else(CMAKE_Java_COMPILER_INIT)
+  else()
     find_program(CMAKE_Java_COMPILER
       NAMES javac
       PATHS ${Java_BIN_PATH}
     )
-  endif(CMAKE_Java_COMPILER_INIT)
+  endif()
 
   # if no runtime has been specified yet, then look for one
   if(CMAKE_Java_RUNTIME_INIT)
     set(CMAKE_Java_RUNTIME ${CMAKE_Java_RUNTIME_INIT} CACHE PATH "Java Compiler")
-  else(CMAKE_Java_RUNTIME_INIT)
+  else()
     find_program(CMAKE_Java_RUNTIME
       NAMES java
       PATHS ${Java_BIN_PATH}
     )
-  endif(CMAKE_Java_RUNTIME_INIT)
+  endif()
 
   # if no archive has been specified yet, then look for one
   if(CMAKE_Java_ARCHIVE_INIT)
     set(CMAKE_Java_ARCHIVE ${CMAKE_Java_ARCHIVE_INIT} CACHE PATH "Java Compiler")
-  else(CMAKE_Java_ARCHIVE_INIT)
+  else()
     find_program(CMAKE_Java_ARCHIVE
       NAMES jar
       PATHS ${Java_BIN_PATH}
     )
-  endif(CMAKE_Java_ARCHIVE_INIT)
-endif(NOT CMAKE_Java_COMPILER)
+  endif()
+endif()
 mark_as_advanced(CMAKE_Java_COMPILER)
 
 # configure variables set in this file for fast reload later on
diff --git a/Modules/CMakeDetermineRCCompiler.cmake b/Modules/CMakeDetermineRCCompiler.cmake
index 41a7af5..669dd16 100644
--- a/Modules/CMakeDetermineRCCompiler.cmake
+++ b/Modules/CMakeDetermineRCCompiler.cmake
@@ -24,33 +24,33 @@ if(NOT CMAKE_RC_COMPILER)
     get_filename_component(CMAKE_RC_COMPILER_INIT $ENV{RC} PROGRAM PROGRAM_ARGS CMAKE_RC_FLAGS_ENV_INIT)
     if(CMAKE_RC_FLAGS_ENV_INIT)
       set(CMAKE_RC_COMPILER_ARG1 "${CMAKE_RC_FLAGS_ENV_INIT}" CACHE STRING "First argument to RC compiler")
-    endif(CMAKE_RC_FLAGS_ENV_INIT)
+    endif()
     if(EXISTS ${CMAKE_RC_COMPILER_INIT})
-    else(EXISTS ${CMAKE_RC_COMPILER_INIT})
+    else()
       message(FATAL_ERROR "Could not find compiler set in environment variable RC:\n$ENV{RC}.")
-    endif(EXISTS ${CMAKE_RC_COMPILER_INIT})
-  endif($ENV{RC} MATCHES ".+")
+    endif()
+  endif()
 
   # next try prefer the compiler specified by the generator
   if(CMAKE_GENERATOR_RC)
     if(NOT CMAKE_RC_COMPILER_INIT)
       set(CMAKE_RC_COMPILER_INIT ${CMAKE_GENERATOR_RC})
-    endif(NOT CMAKE_RC_COMPILER_INIT)
-  endif(CMAKE_GENERATOR_RC)
+    endif()
+  endif()
 
   # finally list compilers to try
   if(CMAKE_RC_COMPILER_INIT)
     set(CMAKE_RC_COMPILER_LIST ${CMAKE_RC_COMPILER_INIT})
-  else(CMAKE_RC_COMPILER_INIT)
+  else()
     set(CMAKE_RC_COMPILER_LIST rc)
-  endif(CMAKE_RC_COMPILER_INIT)
+  endif()
 
   # Find the compiler.
   find_program(CMAKE_RC_COMPILER NAMES ${CMAKE_RC_COMPILER_LIST} DOC "RC compiler")
   if(CMAKE_RC_COMPILER_INIT AND NOT CMAKE_RC_COMPILER)
     set(CMAKE_RC_COMPILER "${CMAKE_RC_COMPILER_INIT}" CACHE FILEPATH "RC compiler" FORCE)
-  endif(CMAKE_RC_COMPILER_INIT AND NOT CMAKE_RC_COMPILER)
-endif(NOT CMAKE_RC_COMPILER)
+  endif()
+endif()
 
 mark_as_advanced(CMAKE_RC_COMPILER)
 
diff --git a/Modules/CMakeDetermineSystem.cmake b/Modules/CMakeDetermineSystem.cmake
index a72bd5f..22c5016 100644
--- a/Modules/CMakeDetermineSystem.cmake
+++ b/Modules/CMakeDetermineSystem.cmake
@@ -59,23 +59,23 @@ if(CMAKE_HOST_UNIX)
       if("${val}" GREATER 0)
         exec_program(uname ARGS -m OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR
           RETURN_VALUE val)
-      endif("${val}" GREATER 0)
+      endif()
     endif()
     # check the return of the last uname -m or -p
     if("${val}" GREATER 0)
         set(CMAKE_HOST_SYSTEM_PROCESSOR "unknown")
-    endif("${val}" GREATER 0)
+    endif()
     set(CMAKE_UNAME ${CMAKE_UNAME} CACHE INTERNAL "uname command")
     # processor may have double quote in the name, and that needs to be removed
     string(REGEX REPLACE "\"" "" CMAKE_HOST_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
     string(REGEX REPLACE "/" "_" CMAKE_HOST_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
-  endif(CMAKE_UNAME)
-else(CMAKE_HOST_UNIX)
+  endif()
+else()
   if(CMAKE_HOST_WIN32)
     set (CMAKE_HOST_SYSTEM_NAME "Windows")
     set (CMAKE_HOST_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITECTURE}")
-  endif(CMAKE_HOST_WIN32)
-endif(CMAKE_HOST_UNIX)
+  endif()
+endif()
 
 # if a toolchain file is used, the user wants to cross compile.
 # in this case read the toolchain file and keep the CMAKE_HOST_SYSTEM_*
@@ -87,15 +87,15 @@ if(CMAKE_TOOLCHAIN_FILE)
   if(NOT _INCLUDED_TOOLCHAIN_FILE)
      # if the file isn't found there, check the default locations
      include("${CMAKE_TOOLCHAIN_FILE}" OPTIONAL RESULT_VARIABLE _INCLUDED_TOOLCHAIN_FILE)
-  endif(NOT _INCLUDED_TOOLCHAIN_FILE)
+  endif()
 
   if(_INCLUDED_TOOLCHAIN_FILE)
     set(CMAKE_TOOLCHAIN_FILE "${_INCLUDED_TOOLCHAIN_FILE}" CACHE FILEPATH "The CMake toolchain file" FORCE)
-  else(_INCLUDED_TOOLCHAIN_FILE)
+  else()
     message(FATAL_ERROR "Could not find toolchain file: ${CMAKE_TOOLCHAIN_FILE}")
     set(CMAKE_TOOLCHAIN_FILE "NOTFOUND" CACHE FILEPATH "The CMake toolchain file" FORCE)
-  endif(_INCLUDED_TOOLCHAIN_FILE)
-endif(CMAKE_TOOLCHAIN_FILE)
+  endif()
+endif()
 
 
 # if CMAKE_SYSTEM_NAME is here already set, either it comes from a toolchain file
@@ -104,45 +104,45 @@ endif(CMAKE_TOOLCHAIN_FILE)
 if(CMAKE_SYSTEM_NAME)
   if(NOT DEFINED CMAKE_CROSSCOMPILING)
     set(CMAKE_CROSSCOMPILING TRUE)
-  endif(NOT DEFINED CMAKE_CROSSCOMPILING)
+  endif()
   set(PRESET_CMAKE_SYSTEM_NAME TRUE)
-else(CMAKE_SYSTEM_NAME)
+else()
   set(CMAKE_SYSTEM_NAME      "${CMAKE_HOST_SYSTEM_NAME}")
   set(CMAKE_SYSTEM_VERSION   "${CMAKE_HOST_SYSTEM_VERSION}")
   set(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}")
   set(CMAKE_CROSSCOMPILING FALSE)
   set(PRESET_CMAKE_SYSTEM_NAME FALSE)
-endif(CMAKE_SYSTEM_NAME)
+endif()
 
 
 macro(ADJUST_CMAKE_SYSTEM_VARIABLES _PREFIX)
   if(NOT ${_PREFIX}_NAME)
     set(${_PREFIX}_NAME "UnknownOS")
-  endif(NOT ${_PREFIX}_NAME)
+  endif()
 
   # fix for BSD/OS , remove the /
   if(${_PREFIX}_NAME MATCHES BSD.OS)
     set(${_PREFIX}_NAME BSDOS)
-  endif(${_PREFIX}_NAME MATCHES BSD.OS)
+  endif()
 
   # fix for GNU/kFreeBSD, remove the GNU/
   if(${_PREFIX}_NAME MATCHES kFreeBSD)
     set(${_PREFIX}_NAME kFreeBSD)
-  endif(${_PREFIX}_NAME MATCHES kFreeBSD)
+  endif()
 
   # fix for CYGWIN which has windows version in it
   if(${_PREFIX}_NAME MATCHES CYGWIN)
     set(${_PREFIX}_NAME CYGWIN)
-  endif(${_PREFIX}_NAME MATCHES CYGWIN)
+  endif()
 
   # set CMAKE_SYSTEM to the CMAKE_SYSTEM_NAME
   set(${_PREFIX}  ${${_PREFIX}_NAME})
   # if there is a CMAKE_SYSTEM_VERSION then add a -${CMAKE_SYSTEM_VERSION}
   if(${_PREFIX}_VERSION)
     set(${_PREFIX} ${${_PREFIX}}-${${_PREFIX}_VERSION})
-  endif(${_PREFIX}_VERSION)
+  endif()
 
-endmacro(ADJUST_CMAKE_SYSTEM_VARIABLES _PREFIX)
+endmacro()
 
 ADJUST_CMAKE_SYSTEM_VARIABLES(CMAKE_SYSTEM)
 ADJUST_CMAKE_SYSTEM_VARIABLES(CMAKE_HOST_SYSTEM)
@@ -156,21 +156,21 @@ if(CMAKE_BINARY_DIR)
                 "The target system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n")
     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
                 "The host system is: ${CMAKE_HOST_SYSTEM_NAME} - ${CMAKE_HOST_SYSTEM_VERSION} - ${CMAKE_HOST_SYSTEM_PROCESSOR}\n")
-  else(PRESET_CMAKE_SYSTEM_NAME)
+  else()
     file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
                 "The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n")
-  endif(PRESET_CMAKE_SYSTEM_NAME)
+  endif()
 
   # if a toolchain file is used, it needs to be included in the configured file,
   # so settings done there are also available if they don't go in the cache and in try_compile()
   set(INCLUDE_CMAKE_TOOLCHAIN_FILE_IF_REQUIRED)
   if(DEFINED CMAKE_TOOLCHAIN_FILE)
     set(INCLUDE_CMAKE_TOOLCHAIN_FILE_IF_REQUIRED "include(\"${CMAKE_TOOLCHAIN_FILE}\")")
-  endif(DEFINED CMAKE_TOOLCHAIN_FILE)
+  endif()
 
   # configure variables set in this file for fast reload, the template file is defined at the top of this file
   configure_file(${CMAKE_ROOT}/Modules/CMakeSystem.cmake.in
                 ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake
                 IMMEDIATE @ONLY)
 
-endif(CMAKE_BINARY_DIR)
+endif()
diff --git a/Modules/CMakeExpandImportedTargets.cmake b/Modules/CMakeExpandImportedTargets.cmake
index d698ad8..14551d1 100644
--- a/Modules/CMakeExpandImportedTargets.cmake
+++ b/Modules/CMakeExpandImportedTargets.cmake
@@ -76,16 +76,16 @@ function(CMAKE_EXPAND_IMPORTED_TARGETS _RESULT )
             # guard against infinite loop: abort after 100 iterations ( 100 is arbitrary chosen)
             if ("${_CCSR_LOOP_COUNTER}" LESS 100)
                set(_CHECK_FOR_IMPORTED_TARGETS TRUE)
-#                else ("${_CCSR_LOOP_COUNTER}" LESS 1)
+#                else ()
 #                   message(STATUS "********* aborting loop, counter : ${_CCSR_LOOP_COUNTER}")
-            endif ("${_CCSR_LOOP_COUNTER}" LESS 100)
+            endif ()
 
             # if one of the imported configurations equals ${CMAKE_TRY_COMPILE_CONFIGURATION},
             # use it, otherwise simply use the first one:
             list(FIND _importedConfigs "${CEIT_CONFIGURATION}" _configIndexToUse)
             if("${_configIndexToUse}" EQUAL -1)
               set(_configIndexToUse 0)
-            endif("${_configIndexToUse}" EQUAL -1)
+            endif()
             list(GET _importedConfigs ${_configIndexToUse} _importedConfigToUse)
 
             get_target_property(_importedLocation "${_CURRENT_LIB}" IMPORTED_LOCATION_${_importedConfigToUse})
@@ -98,18 +98,18 @@ function(CMAKE_EXPAND_IMPORTED_TARGETS _RESULT )
 #                  message(STATUS "Appending link interface lib ${_currentLinkInterfaceLib}")
                   if(_currentLinkInterfaceLib)
                      list(APPEND _CCSR_NEW_REQ_LIBS "${_currentLinkInterfaceLib}" )
-                  endif(_currentLinkInterfaceLib)
-               endforeach(_currentLinkInterfaceLib "${_linkInterfaceLibs}")
-            endif(_linkInterfaceLibs)
-         else(_importedConfigs)
+                  endif()
+               endforeach()
+            endif()
+         else()
             # "Normal" libraries are just used as they are.
             list(APPEND _CCSR_NEW_REQ_LIBS "${_CURRENT_LIB}" )
 #            message(STATUS "Appending lib directly: ${_CURRENT_LIB}")
-         endif(_importedConfigs)
-      endforeach(_CURRENT_LIB ${_CCSR_REQ_LIBS})
+         endif()
+      endforeach()
 
       set(_CCSR_REQ_LIBS ${_CCSR_NEW_REQ_LIBS} )
-   endwhile(_CHECK_FOR_IMPORTED_TARGETS)
+   endwhile()
 
    # Finally we iterate once more over all libraries. This loop only removes
    # all remaining imported target names (there shouldn't be any left anyway).
@@ -119,10 +119,10 @@ function(CMAKE_EXPAND_IMPORTED_TARGETS _RESULT )
       if (NOT _importedConfigs)
          list(APPEND _CCSR_NEW_REQ_LIBS "${_CURRENT_LIB}" )
 #         message(STATUS "final: appending ${_CURRENT_LIB}")
-      else (NOT _importedConfigs)
+      else ()
 #             message(STATUS "final: skipping ${_CURRENT_LIB}")
-      endif (NOT _importedConfigs)
-   endforeach(_CURRENT_LIB ${_CCSR_REQ_LIBS})
+      endif ()
+   endforeach()
 #   message(STATUS "setting -${_RESULT}- to -${_CCSR_NEW_REQ_LIBS}-")
    set(${_RESULT} "${_CCSR_NEW_REQ_LIBS}" PARENT_SCOPE)
 
diff --git a/Modules/CMakeExportBuildSettings.cmake b/Modules/CMakeExportBuildSettings.cmake
index 7392e6b..a18f950 100644
--- a/Modules/CMakeExportBuildSettings.cmake
+++ b/Modules/CMakeExportBuildSettings.cmake
@@ -30,7 +30,7 @@ macro(CMAKE_EXPORT_BUILD_SETTINGS SETTINGS_FILE)
   if(${SETTINGS_FILE} MATCHES ".+")
     configure_file(${CMAKE_ROOT}/Modules/CMakeBuildSettings.cmake.in
                    ${SETTINGS_FILE} @ONLY IMMEDIATE)
-  else(${SETTINGS_FILE} MATCHES ".+")
+  else()
     message(SEND_ERROR "CMAKE_EXPORT_BUILD_SETTINGS called with no argument.")
-  endif(${SETTINGS_FILE} MATCHES ".+")
-endmacro(CMAKE_EXPORT_BUILD_SETTINGS)
+  endif()
+endmacro()
diff --git a/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake b/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake
index 0fe2abb..54a6418 100644
--- a/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake
+++ b/Modules/CMakeExtraGeneratorDetermineCompilerMacrosAndIncludeDirs.cmake
@@ -44,7 +44,7 @@ macro(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang _resultIncludeDirs _resultDefines
     foreach(nextLine ${_includeLines})
       string(STRIP "${nextLine}" _includePath)
       list(APPEND ${_resultIncludeDirs} "${_includePath}")
-    endforeach(nextLine)
+    endforeach()
 
   endif()
 
@@ -71,9 +71,9 @@ macro(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang _resultIncludeDirs _resultDefines
     else()
       list(APPEND ${_resultDefines} " ")
     endif()
-  endforeach(nextLine)
+  endforeach()
 
-endmacro(_DETERMINE_GCC_SYSTEM_INCLUDE_DIRS _lang)
+endmacro()
 
 # Save the current LC_ALL, LC_MESSAGES, and LANG environment variables and set them
 # to "C" that way GCC's "search starts here" text is in English and we can grok it.
diff --git a/Modules/CMakeFindBinUtils.cmake b/Modules/CMakeFindBinUtils.cmake
index 71537ff..362052f 100644
--- a/Modules/CMakeFindBinUtils.cmake
+++ b/Modules/CMakeFindBinUtils.cmake
@@ -48,7 +48,7 @@ else("${CMAKE_CXX_COMPILER_ID}" MATCHES "MSVC"
   find_program(CMAKE_RANLIB NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ranlib HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
   if(NOT CMAKE_RANLIB)
     set(CMAKE_RANLIB : CACHE INTERNAL "noop for ranlib")
-  endif(NOT CMAKE_RANLIB)
+  endif()
 
   find_program(CMAKE_STRIP NAMES ${_CMAKE_TOOLCHAIN_PREFIX}strip HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
   find_program(CMAKE_LINKER NAMES ${_CMAKE_TOOLCHAIN_PREFIX}ld HINTS ${_CMAKE_TOOLCHAIN_LOCATION})
@@ -69,7 +69,7 @@ if(APPLE)
 
   if(NOT CMAKE_INSTALL_NAME_TOOL)
     message(FATAL_ERROR "Could not find install_name_tool, please check your installation.")
-  endif(NOT CMAKE_INSTALL_NAME_TOOL)
+  endif()
 
   mark_as_advanced(CMAKE_INSTALL_NAME_TOOL)
-endif(APPLE)
+endif()
diff --git a/Modules/CMakeFindCodeBlocks.cmake b/Modules/CMakeFindCodeBlocks.cmake