CMakeDetermine*Compiler: Factor out search for compiler in PATH

Factor out a _cmake_find_compiler_path helper macro to avoid duplication
of the search for a full path to the compiler.

5 files changed, 34 insertions, 92 deletions

diff --git a/Modules/CMakeDetermineASMCompiler.cmake b/Modules/CMakeDetermineASMCompiler.cmake
index ca7eb8b..1d9617f 100644
--- a/Modules/CMakeDetermineASMCompiler.cmake
+++ b/Modules/CMakeDetermineASMCompiler.cmake
@@ -48,22 +48,7 @@ if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER)
   _cmake_find_compiler(ASM${ASM_DIALECT})
 
 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
-  #
-  # 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"
-  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})
-    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()
-    unset(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH CACHE)
-  endif()
+  _cmake_find_compiler_path(ASM${ASM_DIALECT})
 endif()
 mark_as_advanced(CMAKE_ASM${ASM_DIALECT}_COMPILER)
 
diff --git a/Modules/CMakeDetermineCCompiler.cmake b/Modules/CMakeDetermineCCompiler.cmake
index c3f5a66..4f7ae24 100644
--- a/Modules/CMakeDetermineCCompiler.cmake
+++ b/Modules/CMakeDetermineCCompiler.cmake
@@ -72,31 +72,7 @@ else()
     _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})
-      if(CMAKE_C_COMPILER_WITH_PATH)
-        set(CMAKE_C_COMPILER ${CMAKE_C_COMPILER_WITH_PATH} CACHE STRING "C compiler" FORCE)
-      endif()
-      unset(CMAKE_C_COMPILER_WITH_PATH CACHE)
-    endif()
+    _cmake_find_compiler_path(C)
   endif()
   mark_as_advanced(CMAKE_C_COMPILER)
 
diff --git a/Modules/CMakeDetermineCXXCompiler.cmake b/Modules/CMakeDetermineCXXCompiler.cmake
index 21864f1..d60cff3 100644
--- a/Modules/CMakeDetermineCXXCompiler.cmake
+++ b/Modules/CMakeDetermineCXXCompiler.cmake
@@ -70,32 +70,7 @@ else()
 
     _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})
-      if(CMAKE_CXX_COMPILER_WITH_PATH)
-        set(CMAKE_CXX_COMPILER ${CMAKE_CXX_COMPILER_WITH_PATH} CACHE STRING "CXX compiler" FORCE)
-      endif()
-      unset(CMAKE_CXX_COMPILER_WITH_PATH CACHE)
-    endif()
+    _cmake_find_compiler_path(CXX)
   endif()
   mark_as_advanced(CMAKE_CXX_COMPILER)
 
diff --git a/Modules/CMakeDetermineCompiler.cmake b/Modules/CMakeDetermineCompiler.cmake
index f522c44..cd0f8b8 100644
--- a/Modules/CMakeDetermineCompiler.cmake
+++ b/Modules/CMakeDetermineCompiler.cmake
@@ -83,3 +83,33 @@ macro(_cmake_find_compiler lang)
     endforeach()
   endif()
 endmacro()
+
+macro(_cmake_find_compiler_path lang)
+  if(CMAKE_${lang}_COMPILER)
+    # we only get here if CMAKE_${lang}_COMPILER was specified using -D or a pre-made CMakeCache.txt
+    # (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
+    # if CMAKE_${lang}_COMPILER is a list of length 2, use the first item as
+    # CMAKE_${lang}_COMPILER and the 2nd one as CMAKE_${lang}_COMPILER_ARG1
+    list(LENGTH CMAKE_${lang}_COMPILER _CMAKE_${lang}_COMPILER_LIST_LENGTH)
+    if("${_CMAKE_${lang}_COMPILER_LIST_LENGTH}" EQUAL 2)
+      list(GET CMAKE_${lang}_COMPILER 1 CMAKE_${lang}_COMPILER_ARG1)
+      list(GET CMAKE_${lang}_COMPILER 0 CMAKE_${lang}_COMPILER)
+    endif()
+    unset(_CMAKE_${lang}_COMPILER_LIST_LENGTH)
+
+    # find the compiler in the PATH if necessary
+    get_filename_component(_CMAKE_USER_${lang}_COMPILER_PATH "${CMAKE_${lang}_COMPILER}" PATH)
+    if(NOT _CMAKE_USER_${lang}_COMPILER_PATH)
+      find_program(CMAKE_${lang}_COMPILER_WITH_PATH NAMES ${CMAKE_${lang}_COMPILER})
+      if(CMAKE_${lang}_COMPILER_WITH_PATH)
+        set(CMAKE_${lang}_COMPILER ${CMAKE_${lang}_COMPILER_WITH_PATH})
+        get_property(_CMAKE_${lang}_COMPILER_CACHED CACHE CMAKE_${lang}_COMPILER PROPERTY TYPE)
+        if(_CMAKE_${lang}_COMPILER_CACHED)
+          set(CMAKE_${lang}_COMPILER "${CMAKE_${lang}_COMPILER}" CACHE STRING "${lang} compiler" FORCE)
+        endif()
+        unset(_CMAKE_${lang}_COMPILER_CACHED)
+      endif()
+      unset(CMAKE_${lang}_COMPILER_WITH_PATH CACHE)
+    endif()
+  endif()
+endmacro()
diff --git a/Modules/CMakeDetermineFortranCompiler.cmake b/Modules/CMakeDetermineFortranCompiler.cmake
index 4c8a8f2..f4aaa0a 100644
--- a/Modules/CMakeDetermineFortranCompiler.cmake
+++ b/Modules/CMakeDetermineFortranCompiler.cmake
@@ -90,31 +90,7 @@ else()
     _cmake_find_compiler(Fortran)
 
   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
-    # CMAKE_Fortran_COMPILER and the 2nd one as CMAKE_Fortran_COMPILER_ARG1
-
-    list(LENGTH CMAKE_Fortran_COMPILER _CMAKE_Fortran_COMPILER_LIST_LENGTH)
-    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()
-
-    # 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_Fortran_COMPILER_PATH "${CMAKE_Fortran_COMPILER}" PATH)
-    if(NOT _CMAKE_USER_Fortran_COMPILER_PATH)
-      find_program(CMAKE_Fortran_COMPILER_WITH_PATH NAMES ${CMAKE_Fortran_COMPILER})
-      if(CMAKE_Fortran_COMPILER_WITH_PATH)
-        set(CMAKE_Fortran_COMPILER ${CMAKE_Fortran_COMPILER_WITH_PATH}
-          CACHE STRING "Fortran compiler" FORCE)
-      endif()
-      unset(CMAKE_Fortran_COMPILER_WITH_PATH CACHE)
-    endif()
+    _cmake_find_compiler_path(Fortran)
   endif()
   mark_as_advanced(CMAKE_Fortran_COMPILER)