Modules/FindPython/Support.cmake

   1 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2 # file Copyright.txt or https://cmake.org/licensing for details.
   3
   4 #
   5 # This file is a "template" file used by various FindPython modules.
   6 #
   7
   8 cmake_policy (GET CMP0094 _${_PYTHON_PREFIX}_LOOKUP_POLICY)
   9
  10 cmake_policy (VERSION 3.7)
  11
  12 if (_${_PYTHON_PREFIX}_LOOKUP_POLICY)
  13   cmake_policy (SET CMP0094 ${_${_PYTHON_PREFIX}_LOOKUP_POLICY})
  14 endif()
  15
  16 #
  17 # Initial configuration
  18 #
  19 if (NOT DEFINED _PYTHON_PREFIX)
  20   message (FATAL_ERROR "FindPython: INTERNAL ERROR")
  21 endif()
  22 if (NOT DEFINED _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR)
  23   message (FATAL_ERROR "FindPython: INTERNAL ERROR")
  24 endif()
  25 if (_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR EQUAL "3")
  26   set(_${_PYTHON_PREFIX}_VERSIONS 3.9 3.8 3.7 3.6 3.5 3.4 3.3 3.2 3.1 3.0)
  27 elseif (_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR EQUAL "2")
  28   set(_${_PYTHON_PREFIX}_VERSIONS 2.7 2.6 2.5 2.4 2.3 2.2 2.1 2.0)
  29 else()
  30   message (FATAL_ERROR "FindPython: INTERNAL ERROR")
  31 endif()
  32
  33 get_property(_${_PYTHON_PREFIX}_CMAKE_ROLE GLOBAL PROPERTY CMAKE_ROLE)
  34
  35
  36 #
  37 # helper commands
  38 #
  39 macro (_PYTHON_DISPLAY_FAILURE _PYTHON_MSG)
  40   if (${_PYTHON_PREFIX}_FIND_REQUIRED)
  41     message (FATAL_ERROR "${_PYTHON_MSG}")
  42   else()
  43     if (NOT ${_PYTHON_PREFIX}_FIND_QUIETLY)
  44       message(STATUS "${_PYTHON_MSG}")
  45     endif ()
  46   endif()
  47
  48   set (${_PYTHON_PREFIX}_FOUND FALSE)
  49   string (TOUPPER "${_PYTHON_PREFIX}" _${_PYTHON_PREFIX}_UPPER_PREFIX)
  50   set (${_PYTHON_UPPER_PREFIX}_FOUND FALSE)
  51   return()
  52 endmacro()
  53
  54
  55 function (_PYTHON_MARK_AS_INTERNAL)
  56   foreach (var IN LISTS ARGV)
  57     if (DEFINED CACHE{${var}})
  58       set_property (CACHE ${var} PROPERTY TYPE INTERNAL)
  59     endif()
  60   endforeach()
  61 endfunction()
  62
  63
  64 macro (_PYTHON_SELECT_LIBRARY_CONFIGURATIONS _PYTHON_BASENAME)
  65   if(NOT DEFINED ${_PYTHON_BASENAME}_LIBRARY_RELEASE)
  66     set(${_PYTHON_BASENAME}_LIBRARY_RELEASE "${_PYTHON_BASENAME}_LIBRARY_RELEASE-NOTFOUND")
  67   endif()
  68   if(NOT DEFINED ${_PYTHON_BASENAME}_LIBRARY_DEBUG)
  69     set(${_PYTHON_BASENAME}_LIBRARY_DEBUG "${_PYTHON_BASENAME}_LIBRARY_DEBUG-NOTFOUND")
  70   endif()
  71
  72   get_property(_PYTHON_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
  73   if (${_PYTHON_BASENAME}_LIBRARY_DEBUG AND ${_PYTHON_BASENAME}_LIBRARY_RELEASE AND
  74       NOT ${_PYTHON_BASENAME}_LIBRARY_DEBUG STREQUAL ${_PYTHON_BASENAME}_LIBRARY_RELEASE AND
  75       (_PYTHON_isMultiConfig OR CMAKE_BUILD_TYPE))
  76     # if the generator is multi-config or if CMAKE_BUILD_TYPE is set for
  77     # single-config generators, set optimized and debug libraries
  78     set (${_PYTHON_BASENAME}_LIBRARIES "")
  79     foreach (_PYTHON_libname IN LISTS ${_PYTHON_BASENAME}_LIBRARY_RELEASE)
  80       list( APPEND ${_PYTHON_BASENAME}_LIBRARIES optimized "${_PYTHON_libname}")
  81     endforeach()
  82     foreach (_PYTHON_libname IN LISTS ${_PYTHON_BASENAME}_LIBRARY_DEBUG)
  83       list( APPEND ${_PYTHON_BASENAME}_LIBRARIES debug "${_PYTHON_libname}")
  84     endforeach()
  85   elseif (${_PYTHON_BASENAME}_LIBRARY_RELEASE)
  86     set (${_PYTHON_BASENAME}_LIBRARIES "${${_PYTHON_BASENAME}_LIBRARY_RELEASE}")
  87   elseif (${_PYTHON_BASENAME}_LIBRARY_DEBUG)
  88     set (${_PYTHON_BASENAME}_LIBRARIES "${${_PYTHON_BASENAME}_LIBRARY_DEBUG}")
  89   else()
  90     set (${_PYTHON_BASENAME}_LIBRARIES "${_PYTHON_BASENAME}_LIBRARY-NOTFOUND")
  91   endif()
  92 endmacro()
  93
  94
  95 macro (_PYTHON_FIND_FRAMEWORKS)
  96   if (CMAKE_HOST_APPLE OR APPLE)
  97     file(TO_CMAKE_PATH "$ENV{CMAKE_FRAMEWORK_PATH}" _pff_CMAKE_FRAMEWORK_PATH)
  98     set (_pff_frameworks ${CMAKE_FRAMEWORK_PATH}
  99                          ${_pff_CMAKE_FRAMEWORK_PATH}
 100                          ~/Library/Frameworks
 101                          /usr/local/Frameworks
 102                          ${CMAKE_SYSTEM_FRAMEWORK_PATH})
 103     list (REMOVE_DUPLICATES _pff_frameworks)
 104     foreach (_pff_implementation IN LISTS _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS)
 105       unset (_${_PYTHON_PREFIX}_${_pff_implementation}_FRAMEWORKS)
 106       if (_pff_implementation STREQUAL "CPython")
 107         foreach (_pff_framework IN LISTS _pff_frameworks)
 108           if (EXISTS ${_pff_framework}/Python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}.framework)
 109             list (APPEND _${_PYTHON_PREFIX}_${_pff_implementation}_FRAMEWORKS ${_pff_framework}/Python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}.framework)
 110           endif()
 111           if (EXISTS ${_pff_framework}/Python.framework)
 112             list (APPEND _${_PYTHON_PREFIX}_${_pff_implementation}_FRAMEWORKS ${_pff_framework}/Python.framework)
 113           endif()
 114         endforeach()
 115       elseif (_pff_implementation STREQUAL "IronPython")
 116         foreach (_pff_framework IN LISTS _pff_frameworks)
 117           if (EXISTS ${_pff_framework}/IronPython.framework)
 118             list (APPEND _${_PYTHON_PREFIX}_${_pff_implementation}_FRAMEWORKS ${_pff_framework}/IronPython.framework)
 119           endif()
 120         endforeach()
 121       endif()
 122     endforeach()
 123     unset (_pff_implementation)
 124     unset (_pff_frameworks)
 125     unset (_pff_framework)
 126   endif()
 127 endmacro()
 128
 129 function (_PYTHON_GET_FRAMEWORKS _PYTHON_PGF_FRAMEWORK_PATHS)
 130   cmake_parse_arguments (PARSE_ARGV 1 _PGF "" "" "IMPLEMENTATIONS;VERSION")
 131
 132   if (NOT _PGF_IMPLEMENTATIONS)
 133     set (_PGF_IMPLEMENTATIONS ${_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS})
 134   endif()
 135
 136   set (framework_paths)
 137
 138   foreach (implementation IN LISTS _PGF_IMPLEMENTATIONS)
 139     if (implementation STREQUAL "CPython")
 140       foreach (version IN LISTS _PGF_VERSION)
 141         foreach (framework IN LISTS _${_PYTHON_PREFIX}_${implementation}_FRAMEWORKS)
 142           if (EXISTS "${framework}/Versions/${version}")
 143             list (APPEND framework_paths "${framework}/Versions/${version}")
 144           endif()
 145         endforeach()
 146       endforeach()
 147     elseif (implementation STREQUAL "IronPython")
 148       foreach (version IN LISTS _PGF_VERSION)
 149         foreach (framework IN LISTS _${_PYTHON_PREFIX}_${implementation}_FRAMEWORKS)
 150           # pick-up all available versions
 151           file (GLOB versions LIST_DIRECTORIES true RELATIVE "${framework}/Versions/"
 152                               "${framework}/Versions/${version}*")
 153           list (SORT versions ORDER DESCENDING)
 154           list (TRANSFORM versions PREPEND "${framework}/Versions/")
 155           list (APPEND framework_paths ${versions})
 156         endforeach()
 157       endforeach()
 158     endif()
 159   endforeach()
 160
 161   set (${_PYTHON_PGF_FRAMEWORK_PATHS} ${framework_paths} PARENT_SCOPE)
 162 endfunction()
 163
 164 function (_PYTHON_GET_REGISTRIES _PYTHON_PGR_REGISTRY_PATHS)
 165   cmake_parse_arguments (PARSE_ARGV 1 _PGR "" "" "IMPLEMENTATIONS;VERSION")
 166
 167   if (NOT _PGR_IMPLEMENTATIONS)
 168     set (_PGR_IMPLEMENTATIONS ${_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS})
 169   endif()
 170
 171   set (registries)
 172
 173   foreach (implementation IN LISTS _PGR_IMPLEMENTATIONS)
 174     if (implementation STREQUAL "CPython")
 175       foreach (version IN LISTS _PGR_VERSION)
 176         string (REPLACE "." "" version_no_dots ${version})
 177         list (APPEND registries
 178                      [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${version}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath]
 179                      [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${version}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath])
 180         if (version VERSION_GREATER_EQUAL "3.5")
 181           get_filename_component (arch "[HKEY_CURRENT_USER\\Software\\Python\\PythonCore\\${version};SysArchitecture]" NAME)
 182           if (arch MATCHES "(${_${_PYTHON_PREFIX}_ARCH}|${_${_PYTHON_PREFIX}_ARCH2})bit")
 183             list (APPEND registries
 184                          [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${version}\\InstallPath])
 185           endif()
 186         else()
 187           list (APPEND registries
 188                        [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${version}\\InstallPath])
 189         endif()
 190         list (APPEND registries
 191                      [HKEY_CURRENT_USER\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${version_no_dots}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath]
 192                      [HKEY_CURRENT_USER\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${version_no_dots}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath]
 193                      [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${version}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath]
 194                      [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${version}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath]
 195                      [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${version}\\InstallPath]
 196                      [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${version_no_dots}-${_${_PYTHON_PREFIX}_ARCH}\\InstallPath]
 197                      [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\ContinuumAnalytics\\Anaconda${version_no_dots}-${_${_PYTHON_PREFIX}_ARCH2}\\InstallPath])
 198       endforeach()
 199     elseif (implementation STREQUAL "IronPython")
 200       foreach (version  IN LISTS _PGR_VERSION)
 201         list (APPEND registries [HKEY_LOCAL_MACHINE\\SOFTWARE\\IronPython\\${version}\\InstallPath])
 202       endforeach()
 203     endif()
 204   endforeach()
 205
 206   set (${_PYTHON_PGR_REGISTRY_PATHS} "${registries}" PARENT_SCOPE)
 207 endfunction()
 208
 209
 210 function (_PYTHON_GET_ABIFLAGS _PGABIFLAGS)
 211   set (abiflags)
 212   list (GET _${_PYTHON_PREFIX}_FIND_ABI 0 pydebug)
 213   list (GET _${_PYTHON_PREFIX}_FIND_ABI 1 pymalloc)
 214   list (GET _${_PYTHON_PREFIX}_FIND_ABI 2 unicode)
 215
 216   if (pymalloc STREQUAL "ANY" AND unicode STREQUAL "ANY")
 217     set (abiflags "mu" "m" "u" "")
 218   elseif (pymalloc STREQUAL "ANY" AND unicode STREQUAL "ON")
 219     set (abiflags "mu" "u")
 220   elseif (pymalloc STREQUAL "ANY" AND unicode STREQUAL "OFF")
 221     set (abiflags "m" "")
 222   elseif (pymalloc STREQUAL "ON" AND unicode STREQUAL "ANY")
 223     set (abiflags "mu" "m")
 224   elseif (pymalloc STREQUAL "ON" AND unicode STREQUAL "ON")
 225     set (abiflags "mu")
 226   elseif (pymalloc STREQUAL "ON" AND unicode STREQUAL "OFF")
 227     set (abiflags "m")
 228   elseif (pymalloc STREQUAL "ON" AND unicode STREQUAL "ANY")
 229     set (abiflags "u" "")
 230   elseif (pymalloc STREQUAL "OFF" AND unicode STREQUAL "ON")
 231     set (abiflags "u")
 232   endif()
 233
 234   if (pydebug STREQUAL "ON")
 235     if (abiflags)
 236       list (TRANSFORM abiflags PREPEND "d")
 237     else()
 238       set (abiflags "d")
 239     endif()
 240   elseif (pydebug STREQUAL "ANY")
 241     if (abiflags)
 242       set (flags "${abiflags}")
 243       list (TRANSFORM flags PREPEND "d")
 244       list (APPEND abiflags "${flags}")
 245     else()
 246       set (abiflags "" "d")
 247     endif()
 248   endif()
 249
 250   set (${_PGABIFLAGS} "${abiflags}" PARENT_SCOPE)
 251 endfunction()
 252
 253 function (_PYTHON_GET_PATH_SUFFIXES _PYTHON_PGPS_PATH_SUFFIXES)
 254   cmake_parse_arguments (PARSE_ARGV 1 _PGPS "INTERPRETER;COMPILER;LIBRARY;INCLUDE" "" "IMPLEMENTATIONS;VERSION")
 255
 256   if (NOT _PGPS_IMPLEMENTATIONS)
 257     set (_PGPS_IMPLEMENTATIONS ${_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS})
 258   endif()
 259
 260   if (DEFINED _${_PYTHON_PREFIX}_ABIFLAGS)
 261     set (abi "${_${_PYTHON_PREFIX}_ABIFLAGS}")
 262   else()
 263     set (abi "mu" "m" "u" "")
 264   endif()
 265
 266   set (path_suffixes)
 267
 268   foreach (implementation IN LISTS _PGPS_IMPLEMENTATIONS)
 269     if (implementation STREQUAL "CPython")
 270       if (_PGPS_INTERPRETER)
 271         list (APPEND path_suffixes bin Scripts)
 272       else()
 273         foreach (version IN LISTS _PGPS_VERSION)
 274           if (_PGPS_LIBRARY)
 275             if (CMAKE_LIBRARY_ARCHITECTURE)
 276               list (APPEND path_suffixes lib/${CMAKE_LIBRARY_ARCHITECTURE})
 277             endif()
 278             list (APPEND path_suffixes lib libs)
 279
 280             if (CMAKE_LIBRARY_ARCHITECTURE)
 281               set (suffixes "${abi}")
 282               if (suffixes)
 283                 list (TRANSFORM suffixes PREPEND "lib/python${_PGPS_VERSION}/config-${_PGPS_VERSION}")
 284                 list (TRANSFORM suffixes APPEND "-${CMAKE_LIBRARY_ARCHITECTURE}")
 285               else()
 286                 set (suffixes "lib/python${_PGPS_VERSION}/config-${_PGPS_VERSION}-${CMAKE_LIBRARY_ARCHITECTURE}")
 287               endif()
 288               list (APPEND path_suffixes ${suffixes})
 289             endif()
 290             set (suffixes "${abi}")
 291             if (suffixes)
 292               list (TRANSFORM suffixes PREPEND "lib/python${_PGPS_VERSION}/config-${_PGPS_VERSION}")
 293             else()
 294               set (suffixes "lib/python${_PGPS_VERSION}/config-${_PGPS_VERSION}")
 295             endif()
 296             list (APPEND path_suffixes ${suffixes})
 297           elseif (_PGPS_INCLUDE)
 298             set (suffixes "${abi}")
 299             if (suffixes)
 300               list (TRANSFORM suffixes PREPEND "include/python${_PGPS_VERSION}")
 301             else()
 302               set (suffixes "include/python${_PGPS_VERSION}")
 303             endif()
 304             list (APPEND path_suffixes ${suffixes} include)
 305           endif()
 306         endforeach()
 307       endif()
 308     elseif (implementation STREQUAL "IronPython")
 309       if (_PGPS_INTERPRETER OR _PGPS_COMPILER)
 310         foreach (version IN LISTS _PGPS_VERSION)
 311           list (APPEND path_suffixes "share/ironpython${version}")
 312         endforeach()
 313         list (APPEND path_suffixes ${_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES})
 314       endif()
 315     elseif (implementation STREQUAL "PyPy")
 316       if (_PGPS_INTERPRETER)
 317         list (APPEND path_suffixes ${_${_PYTHON_PREFIX}_PYPY_EXECUTABLE_PATH_SUFFIXES})
 318       elseif (_PGPS_LIBRARY)
 319         list (APPEND path_suffixes ${_${_PYTHON_PREFIX}_PYPY_LIBRARY_PATH_SUFFIXES})
 320       elseif (_PGPS_INCLUDE)
 321         list (APPEND path_suffixes ${_${_PYTHON_PREFIX}_PYPY_INCLUDE_PATH_SUFFIXES})
 322       endif()
 323     endif()
 324   endforeach()
 325   list (REMOVE_DUPLICATES path_suffixes)
 326
 327   set (${_PYTHON_PGPS_PATH_SUFFIXES} ${path_suffixes} PARENT_SCOPE)
 328 endfunction()
 329
 330 function (_PYTHON_GET_NAMES _PYTHON_PGN_NAMES)
 331   cmake_parse_arguments (PARSE_ARGV 1 _PGN "POSIX;INTERPRETER;COMPILER;CONFIG;LIBRARY;WIN32;DEBUG" "" "IMPLEMENTATIONS;VERSION")
 332
 333   if (NOT _PGN_IMPLEMENTATIONS)
 334     set (_PGN_IMPLEMENTATIONS ${_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS})
 335   endif()
 336
 337   set (names)
 338
 339   foreach (implementation IN LISTS _PGN_IMPLEMENTATIONS)
 340     if (implementation STREQUAL "CPython")
 341       foreach (version IN LISTS _PGN_VERSION)
 342         if (_PGN_WIN32)
 343           string (REPLACE "." "" version_no_dots ${version})
 344
 345           set (name python${version_no_dots})
 346           if (_PGN_DEBUG)
 347             string (APPEND name "_d")
 348           endif()
 349
 350           list (APPEND names "${name}")
 351         endif()
 352
 353         if (_PGN_POSIX)
 354           if (DEFINED _${_PYTHON_PREFIX}_ABIFLAGS)
 355             set (abi "${_${_PYTHON_PREFIX}_ABIFLAGS}")
 356           else()
 357             if (_PGN_INTERPRETER OR _PGN_CONFIG)
 358               set (abi "")
 359             else()
 360               set (abi "mu" "m" "u" "")
 361             endif()
 362           endif()
 363
 364           if (abi)
 365             if (_PGN_CONFIG AND DEFINED CMAKE_LIBRARY_ARCHITECTURE)
 366               set (abinames "${abi}")
 367               list (TRANSFORM abinames PREPEND "${CMAKE_LIBRARY_ARCHITECTURE}-python${version}")
 368               list (TRANSFORM abinames APPEND "-config")
 369               list (APPEND names ${abinames})
 370             endif()
 371             set (abinames "${abi}")
 372             list (TRANSFORM abinames PREPEND "python${version}")
 373             if (_PGN_CONFIG)
 374               list (TRANSFORM abinames APPEND "-config")
 375             endif()
 376             list (APPEND names ${abinames})
 377           else()
 378             unset (abinames)
 379             if (_PGN_CONFIG AND DEFINED CMAKE_LIBRARY_ARCHITECTURE)
 380               set (abinames "${CMAKE_LIBRARY_ARCHITECTURE}-python${version}")
 381             endif()
 382             list (APPEND abinames "python${version}")
 383             if (_PGN_CONFIG)
 384               list (TRANSFORM abinames APPEND "-config")
 385             endif()
 386             list (APPEND names ${abinames})
 387           endif()
 388         endif()
 389       endforeach()
 390       if (_PGN_INTERPRETER)
 391         list (APPEND names python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR} python)
 392       endif()
 393     elseif (implementation STREQUAL "IronPython")
 394       if (_PGN_INTERPRETER)
 395         if (NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
 396           # Do not use wrapper script on Linux because it is buggy: -c interpreter option cannot be used
 397           foreach (version IN LISTS _PGN_VERSION)
 398             list (APPEND names "ipy${version}")
 399           endforeach()
 400         endif()
 401         list (APPEND names ${_${_PYTHON_PREFIX}_IRON_PYTHON_INTERPRETER_NAMES})
 402       elseif (_PGN_COMPILER)
 403         list (APPEND names ${_${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_NAMES})
 404       endif()
 405     elseif (implementation STREQUAL "PyPy")
 406       if (_PGN_INTERPRETER)
 407         list (APPEND names ${_${_PYTHON_PREFIX}_PYPY_NAMES})
 408       elseif (_PGN_LIBRARY)
 409         if (_PGN_WIN32)
 410           foreach (version IN LISTS _PGN_VERSION)
 411             string (REPLACE "." "" version_no_dots ${version})
 412
 413             set (name "python${version_no_dots}")
 414             if (_PGN_DEBUG)
 415               string (APPEND name "_d")
 416             endif()
 417             list (APPEND names "${name}")
 418           endforeach()
 419         endif()
 420         list (APPEND names ${_${_PYTHON_PREFIX}_PYPY_LIB_NAMES})
 421       endif()
 422     endif()
 423   endforeach()
 424
 425   set (${_PYTHON_PGN_NAMES} ${names} PARENT_SCOPE)
 426 endfunction()
 427
 428 function (_PYTHON_GET_CONFIG_VAR _PYTHON_PGCV_VALUE NAME)
 429   unset (${_PYTHON_PGCV_VALUE} PARENT_SCOPE)
 430
 431   if (NOT NAME MATCHES "^(PREFIX|ABIFLAGS|CONFIGDIR|INCLUDES|LIBS|SOABI)$")
 432     return()
 433   endif()
 434
 435   if (_${_PYTHON_PREFIX}_CONFIG)
 436     if (NAME STREQUAL "SOABI")
 437       set (config_flag "--extension-suffix")
 438     else()
 439       set (config_flag "--${NAME}")
 440     endif()
 441     string (TOLOWER "${config_flag}" config_flag)
 442     execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" ${config_flag}
 443                      RESULT_VARIABLE _result
 444                      OUTPUT_VARIABLE _values
 445                      ERROR_QUIET
 446                      OUTPUT_STRIP_TRAILING_WHITESPACE)
 447     if (_result)
 448       unset (_values)
 449     else()
 450       if (NAME STREQUAL "INCLUDES")
 451         # do some clean-up
 452         string (REGEX MATCHALL "(-I|-iwithsysroot)[ ]*[^ ]+" _values "${_values}")
 453         string (REGEX REPLACE "(-I|-iwithsysroot)[ ]*" "" _values "${_values}")
 454         list (REMOVE_DUPLICATES _values)
 455       elseif (NAME STREQUAL "SOABI")
 456         # clean-up: remove prefix character and suffix
 457         string (REGEX REPLACE "^[.-](.+)(${CMAKE_SHARED_LIBRARY_SUFFIX}|\\.(so|pyd))$" "\\1" _values "${_values}")
 458       endif()
 459     endif()
 460   endif()
 461
 462   if (_${_PYTHON_PREFIX}_EXECUTABLE AND NOT CMAKE_CROSSCOMPILING)
 463     if (NAME STREQUAL "PREFIX")
 464       execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c "import sys\ntry:\n   from distutils import sysconfig\n   sys.stdout.write(';'.join([sysconfig.PREFIX,sysconfig.EXEC_PREFIX,sysconfig.BASE_EXEC_PREFIX]))\nexcept Exception:\n   import sysconfig\n   sys.stdout.write(';'.join([sysconfig.get_config_var('base') or '', sysconfig.get_config_var('installed_base') or '']))"
 465                        RESULT_VARIABLE _result
 466                        OUTPUT_VARIABLE _values
 467                        ERROR_QUIET
 468                        OUTPUT_STRIP_TRAILING_WHITESPACE)
 469       if (_result)
 470         unset (_values)
 471       else()
 472         list (REMOVE_DUPLICATES _values)
 473       endif()
 474     elseif (NAME STREQUAL "INCLUDES")
 475       if (WIN32)
 476         set (_scheme "nt")
 477       else()
 478         set (_scheme "posix_prefix")
 479       endif()
 480       execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
 481                                "import sys\ntry:\n   from distutils import sysconfig\n   sys.stdout.write(';'.join([sysconfig.get_python_inc(plat_specific=True),sysconfig.get_python_inc(plat_specific=False)]))\nexcept Exception:\n   import sysconfig\n   sys.stdout.write(';'.join([sysconfig.get_path('platinclude'),sysconfig.get_path('platinclude','${_scheme}'),sysconfig.get_path('include'),sysconfig.get_path('include','${_scheme}')]))"
 482                        RESULT_VARIABLE _result
 483                        OUTPUT_VARIABLE _values
 484                        ERROR_QUIET
 485                        OUTPUT_STRIP_TRAILING_WHITESPACE)
 486       if (_result)
 487         unset (_values)
 488       else()
 489         list (REMOVE_DUPLICATES _values)
 490       endif()
 491     elseif (NAME STREQUAL "SOABI")
 492       execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
 493                                "import sys\ntry:\n   from distutils import sysconfig\n   sys.stdout.write(';'.join([sysconfig.get_config_var('SOABI') or '',sysconfig.get_config_var('EXT_SUFFIX') or '']))\nexcept Exception:\n   import sysconfig;sys.stdout.write(';'.join([sysconfig.get_config_var('SOABI') or '',sysconfig.get_config_var('EXT_SUFFIX') or '']))"
 494                        RESULT_VARIABLE _result
 495                        OUTPUT_VARIABLE _soabi
 496                        ERROR_QUIET
 497                        OUTPUT_STRIP_TRAILING_WHITESPACE)
 498       if (_result)
 499         unset (_values)
 500       else()
 501         foreach (_item IN LISTS _soabi)
 502           if (_item)
 503             set (_values "${_item}")
 504             break()
 505           endif()
 506         endforeach()
 507         if (_values)
 508           # clean-up: remove prefix character and suffix
 509           string (REGEX REPLACE "^[.-](.+)(${CMAKE_SHARED_LIBRARY_SUFFIX}|\\.(so|pyd))$" "\\1" _values "${_values}")
 510         endif()
 511       endif()
 512     else()
 513       set (config_flag "${NAME}")
 514       if (NAME STREQUAL "CONFIGDIR")
 515         set (config_flag "LIBPL")
 516       endif()
 517       execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
 518                                "import sys\ntry:\n   from distutils import sysconfig\n   sys.stdout.write(sysconfig.get_config_var('${config_flag}'))\nexcept Exception:\n   import sysconfig\n   sys.stdout.write(sysconfig.get_config_var('${config_flag}'))"
 519                        RESULT_VARIABLE _result
 520                        OUTPUT_VARIABLE _values
 521                        ERROR_QUIET
 522                        OUTPUT_STRIP_TRAILING_WHITESPACE)
 523       if (_result)
 524         unset (_values)
 525       endif()
 526     endif()
 527   endif()
 528
 529   if (config_flag STREQUAL "ABIFLAGS")
 530     set (${_PYTHON_PGCV_VALUE} "${_values}" PARENT_SCOPE)
 531     return()
 532   endif()
 533
 534   if (NOT _values OR _values STREQUAL "None")
 535     return()
 536   endif()
 537
 538   if (NAME STREQUAL "LIBS")
 539     # do some clean-up
 540     string (REGEX MATCHALL "-(l|framework)[ ]*[^ ]+" _values "${_values}")
 541     # remove elements relative to python library itself
 542     list (FILTER _values EXCLUDE REGEX "-lpython")
 543     list (REMOVE_DUPLICATES _values)
 544   endif()
 545
 546   if (WIN32 AND NAME MATCHES "^(PREFIX|CONFIGDIR|INCLUDES)$")
 547     file (TO_CMAKE_PATH "${_values}" _values)
 548   endif()
 549
 550   set (${_PYTHON_PGCV_VALUE} "${_values}" PARENT_SCOPE)
 551 endfunction()
 552
 553 function (_PYTHON_GET_VERSION)
 554   cmake_parse_arguments (PARSE_ARGV 0 _PGV "LIBRARY;INCLUDE" "PREFIX" "")
 555
 556   unset (${_PGV_PREFIX}VERSION PARENT_SCOPE)
 557   unset (${_PGV_PREFIX}VERSION_MAJOR PARENT_SCOPE)
 558   unset (${_PGV_PREFIX}VERSION_MINOR PARENT_SCOPE)
 559   unset (${_PGV_PREFIX}VERSION_PATCH PARENT_SCOPE)
 560   unset (${_PGV_PREFIX}ABI PARENT_SCOPE)
 561
 562   if (_PGV_LIBRARY)
 563     # retrieve version and abi from library name
 564     if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE)
 565       # extract version from library name
 566       if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "python([23])([0-9]+)")
 567         set (${_PGV_PREFIX}VERSION_MAJOR "${CMAKE_MATCH_1}" PARENT_SCOPE)
 568         set (${_PGV_PREFIX}VERSION_MINOR "${CMAKE_MATCH_2}" PARENT_SCOPE)
 569         set (${_PGV_PREFIX}VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}" PARENT_SCOPE)
 570         set (${_PGV_PREFIX}ABI "" PARENT_SCOPE)
 571       elseif (_${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "python([23])\\.([0-9]+)([dmu]*)")
 572         set (${_PGV_PREFIX}VERSION_MAJOR "${CMAKE_MATCH_1}" PARENT_SCOPE)
 573         set (${_PGV_PREFIX}VERSION_MINOR "${CMAKE_MATCH_2}" PARENT_SCOPE)
 574         set (${_PGV_PREFIX}VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}" PARENT_SCOPE)
 575         set (${_PGV_PREFIX}ABI "${CMAKE_MATCH_3}" PARENT_SCOPE)
 576       elseif (_${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "pypy(3)?")
 577         set (version "${CMAKE_MATCH_1}")
 578         if (version EQUAL "3")
 579           set (${_PGV_PREFIX}VERSION_MAJOR "3" PARENT_SCOPE)
 580           set (${_PGV_PREFIX}VERSION "3" PARENT_SCOPE)
 581         else()
 582           set (${_PGV_PREFIX}VERSION_MAJOR "2" PARENT_SCOPE)
 583           set (${_PGV_PREFIX}VERSION "2" PARENT_SCOPE)
 584         endif()
 585         set (${_PGV_PREFIX}ABI "" PARENT_SCOPE)
 586       endif()
 587     endif()
 588   else()
 589     if (_${_PYTHON_PREFIX}_INCLUDE_DIR)
 590       # retrieve version from header file
 591       file (STRINGS "${_${_PYTHON_PREFIX}_INCLUDE_DIR}/patchlevel.h" version
 592             REGEX "^#define[ \t]+PY_VERSION[ \t]+\"[^\"]+\"")
 593       string (REGEX REPLACE "^#define[ \t]+PY_VERSION[ \t]+\"([^\"]+)\".*" "\\1"
 594                             version "${version}")
 595       string (REGEX MATCHALL "[0-9]+" versions "${version}")
 596       list (GET versions 0 version_major)
 597       list (GET versions 1 version_minor)
 598       list (GET versions 2 version_patch)
 599
 600       set (${_PGV_PREFIX}VERSION "${version_major}.${version_minor}.${version_patch}" PARENT_SCOPE)
 601       set (${_PGV_PREFIX}VERSION_MAJOR ${version_major} PARENT_SCOPE)
 602       set (${_PGV_PREFIX}VERSION_MINOR ${version_minor} PARENT_SCOPE)
 603       set (${_PGV_PREFIX}VERSION_PATCH ${version_patch} PARENT_SCOPE)
 604
 605       # compute ABI flags
 606       if (version_major VERSION_GREATER "2")
 607         file (STRINGS "${_${_PYTHON_PREFIX}_INCLUDE_DIR}/pyconfig.h" config REGEX "(Py_DEBUG|WITH_PYMALLOC|Py_UNICODE_SIZE|MS_WIN32)")
 608         set (abi)
 609         if (config MATCHES "#[ ]*define[ ]+MS_WIN32")
 610           # ABI not used on Windows
 611           set (abi "")
 612         else()
 613           if (config MATCHES "#[ ]*define[ ]+Py_DEBUG[ ]+1")
 614             string (APPEND abi "d")
 615           endif()
 616           if (config MATCHES "#[ ]*define[ ]+WITH_PYMALLOC[ ]+1")
 617             string (APPEND abi "m")
 618           endif()
 619           if (config MATCHES "#[ ]*define[ ]+Py_UNICODE_SIZE[ ]+4")
 620             string (APPEND abi "u")
 621           endif()
 622           set (${_PGV_PREFIX}ABI "${abi}" PARENT_SCOPE)
 623         endif()
 624       else()
 625         # ABI not supported
 626         set (${_PGV_PREFIX}ABI "" PARENT_SCOPE)
 627       endif()
 628     endif()
 629   endif()
 630 endfunction()
 631
 632 function (_PYTHON_GET_LAUNCHER _PYTHON_PGL_NAME)
 633   cmake_parse_arguments (PARSE_ARGV 1 _PGL "INTERPRETER;COMPILER" "" "")
 634
 635   unset ({_PYTHON_PGL_NAME} PARENT_SCOPE)
 636
 637   if ((_PGL_INTERPRETER AND NOT _${_PYTHON_PREFIX}_EXECUTABLE)
 638       OR (_PGL_COMPILER AND NOT _${_PYTHON_PREFIX}_COMPILER))
 639     return()
 640   endif()
 641
 642   if ("IronPython" IN_LIST _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS
 643       AND NOT SYSTEM_NAME MATCHES "Windows|Linux")
 644     if (_PGL_INTERPRETER)
 645       get_filename_component (name "${_${_PYTHON_PREFIX}_EXECUTABLE}" NAME)
 646       get_filename_component (ext "${_${_PYTHON_PREFIX}_EXECUTABLE}" LAST_EXT)
 647       if (name IN_LIST _${_PYTHON_PREFIX}_IRON_PYTHON_INTERPRETER_NAMES
 648           AND ext STREQUAL ".exe")
 649         set (${_PYTHON_PGL_NAME} "${${_PYTHON_PREFIX}_DOTNET_LAUNCHER}" PARENT_SCOPE)
 650       endif()
 651     else()
 652       get_filename_component (name "${_${_PYTHON_PREFIX}_COMPILER}" NAME)
 653       get_filename_component (ext "${_${_PYTHON_PREFIX}_COMPILER}" LAST_EXT)
 654       if (name IN_LIST _${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_NAMES
 655           AND ext STREQUAL ".exe")
 656         set (${_PYTHON_PGL_NAME} "${${_PYTHON_PREFIX}_DOTNET_LAUNCHER}" PARENT_SCOPE)
 657       endif()
 658     endif()
 659   endif()
 660 endfunction()
 661
 662
 663 function (_PYTHON_VALIDATE_INTERPRETER)
 664   if (NOT _${_PYTHON_PREFIX}_EXECUTABLE)
 665     return()
 666   endif()
 667
 668   cmake_parse_arguments (PARSE_ARGV 0 _PVI "EXACT;CHECK_EXISTS" "" "")
 669   if (_PVI_UNPARSED_ARGUMENTS)
 670     set (expected_version "${_PVI_UNPARSED_ARGUMENTS}")
 671   else()
 672     unset (expected_version)
 673   endif()
 674
 675   if (_PVI_CHECK_EXISTS AND NOT EXISTS "${_${_PYTHON_PREFIX}_EXECUTABLE}")
 676     # interpreter does not exist anymore
 677     set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Cannot find the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"" PARENT_SCOPE)
 678     set_property (CACHE _${_PYTHON_PREFIX}_EXECUTABLE PROPERTY VALUE "${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND")
 679     return()
 680   endif()
 681
 682   _python_get_launcher (launcher INTERPRETER)
 683
 684   # validate ABI compatibility
 685   if (DEFINED _${_PYTHON_PREFIX}_FIND_ABI)
 686     execute_process (COMMAND ${launcher} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
 687                              "import sys; sys.stdout.write(sys.abiflags)"
 688                      RESULT_VARIABLE result
 689                      OUTPUT_VARIABLE abi
 690                      ERROR_QUIET
 691                      OUTPUT_STRIP_TRAILING_WHITESPACE)
 692     if (result)
 693       # assume ABI is not supported
 694       set (abi "")
 695     endif()
 696     if (NOT abi IN_LIST _${_PYTHON_PREFIX}_ABIFLAGS)
 697       # incompatible ABI
 698       set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Wrong ABI for the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"" PARENT_SCOPE)
 699       set_property (CACHE _${_PYTHON_PREFIX}_EXECUTABLE PROPERTY VALUE "${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND")
 700       return()
 701     endif()
 702   endif()
 703
 704   get_filename_component (python_name "${_${_PYTHON_PREFIX}_EXECUTABLE}" NAME)
 705
 706   if (expected_version)
 707     if (NOT python_name STREQUAL "python${expected_version}${abi}${CMAKE_EXECUTABLE_SUFFIX}")
 708       # compute number of components for version
 709       string (REGEX REPLACE "[^.]" "" dots "${expected_version}")
 710       # add one dot because there is one dot less than there are components
 711       string (LENGTH "${dots}." count)
 712       if (count GREATER 3)
 713         set (count 3)
 714       endif()
 715
 716       # executable found must have a specific version
 717       execute_process (COMMAND ${launcher} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
 718                                "import sys; sys.stdout.write('.'.join([str(x) for x in sys.version_info[:${count}]]))"
 719                        RESULT_VARIABLE result
 720                        OUTPUT_VARIABLE version
 721                        ERROR_QUIET
 722                        OUTPUT_STRIP_TRAILING_WHITESPACE)
 723       if (result)
 724         # interpreter is not usable
 725         set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Cannot use the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"" PARENT_SCOPE)
 726         set_property (CACHE _${_PYTHON_PREFIX}_EXECUTABLE PROPERTY VALUE "${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND")
 727       else()
 728         if (_PVI_EXACT AND NOT version VERSION_EQUAL expected_version)
 729           # interpreter has wrong version
 730           set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Wrong version for the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"" PARENT_SCOPE)
 731           set_property (CACHE _${_PYTHON_PREFIX}_EXECUTABLE PROPERTY VALUE "${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND")
 732         else()
 733           # check that version is OK
 734           string(REGEX REPLACE "^([0-9]+)\\.?.*$" "\\1" major_version "${version}")
 735           string(REGEX REPLACE "^([0-9]+)\\.?.*$" "\\1" expected_major_version "${expected_version}")
 736           if (NOT major_version VERSION_EQUAL expected_major_version
 737               OR NOT version VERSION_GREATER_EQUAL expected_version)
 738             set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Wrong version for the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"" PARENT_SCOPE)
 739             set_property (CACHE _${_PYTHON_PREFIX}_EXECUTABLE PROPERTY VALUE "${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND")
 740           endif()
 741         endif()
 742       endif()
 743       if (NOT _${_PYTHON_PREFIX}_EXECUTABLE)
 744         return()
 745       endif()
 746     endif()
 747   else()
 748     if (NOT python_name STREQUAL "python${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}${CMAKE_EXECUTABLE_SUFFIX}")
 749       # executable found do not have version in name
 750       # ensure major version is OK
 751       execute_process (COMMAND ${launcher} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
 752                                "import sys; sys.stdout.write(str(sys.version_info[0]))"
 753                        RESULT_VARIABLE result
 754                        OUTPUT_VARIABLE version
 755                        ERROR_QUIET
 756                        OUTPUT_STRIP_TRAILING_WHITESPACE)
 757       if (result OR NOT version EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR)
 758         # interpreter not usable or has wrong major version
 759         if (result)
 760           set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Cannot use the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"" PARENT_SCOPE)
 761         else()
 762           set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Wrong major version for the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"" PARENT_SCOPE)
 763         endif()
 764         set_property (CACHE _${_PYTHON_PREFIX}_EXECUTABLE PROPERTY VALUE "${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND")
 765         return()
 766       endif()
 767     endif()
 768   endif()
 769
 770   if (CMAKE_SIZEOF_VOID_P AND ("Development.Module" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS
 771         OR "Development.Embed" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
 772       AND NOT CMAKE_CROSSCOMPILING)
 773     # In this case, interpreter must have same architecture as environment
 774     execute_process (COMMAND ${launcher} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
 775                              "import sys, struct; sys.stdout.write(str(struct.calcsize(\"P\")))"
 776                      RESULT_VARIABLE result
 777                      OUTPUT_VARIABLE size
 778                      ERROR_QUIET
 779                      OUTPUT_STRIP_TRAILING_WHITESPACE)
 780     if (result OR NOT size EQUAL CMAKE_SIZEOF_VOID_P)
 781       # interpreter not usable or has wrong architecture
 782       if (result)
 783         set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Cannot use the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"" PARENT_SCOPE)
 784       else()
 785         set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Wrong architecture for the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"" PARENT_SCOPE)
 786       endif()
 787       set_property (CACHE _${_PYTHON_PREFIX}_EXECUTABLE PROPERTY VALUE "${_PYTHON_PREFIX}_EXECUTABLE-NOTFOUND")
 788       return()
 789     endif()
 790   endif()
 791 endfunction()
 792
 793
 794 function (_PYTHON_VALIDATE_COMPILER)
 795   if (NOT _${_PYTHON_PREFIX}_COMPILER)
 796     return()
 797   endif()
 798
 799   cmake_parse_arguments (PARSE_ARGV 0 _PVC "EXACT;CHECK_EXISTS" "" "")
 800   if (_PVC_UNPARSED_ARGUMENTS)
 801     set (major_version FALSE)
 802     set (expected_version "${_PVC_UNPARSED_ARGUMENTS}")
 803   else()
 804     set (major_version TRUE)
 805     set (expected_version "${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}")
 806     set (_PVC_EXACT TRUE)
 807   endif()
 808
 809   if (_PVC_CHECK_EXISTS AND NOT EXISTS "${_${_PYTHON_PREFIX}_COMPILER}")
 810     # Compiler does not exist anymore
 811     set (_${_PYTHON_PREFIX}_Compiler_REASON_FAILURE "Cannot find the compiler \"${_${_PYTHON_PREFIX}_COMPILER}\"" PARENT_SCOPE)
 812     set_property (CACHE _${_PYTHON_PREFIX}_COMPILER PROPERTY VALUE "${_PYTHON_PREFIX}_COMPILER-NOTFOUND")
 813     return()
 814   endif()
 815
 816   _python_get_launcher (launcher COMPILER)
 817
 818   # retrieve python environment version from compiler
 819   set (working_dir "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/PythonCompilerVersion.dir")
 820   if (major_version)
 821     # check only major version
 822     file (WRITE "${working_dir}/version.py" "import sys; sys.stdout.write(str(sys.version_info[0]))")
 823   else()
 824     # compute number of components for version
 825     string (REGEX REPLACE "[^.]" "" dots "${expected_version}")
 826     # add one dot because there is one dot less than there are components
 827     string (LENGTH "${dots}." count)
 828     if (count GREATER 3)
 829       set (count 3)
 830     endif()
 831     file (WRITE "${working_dir}/version.py" "import sys; sys.stdout.write('.'.join([str(x) for x in sys.version_info[:${count}]]))\n")
 832   endif()
 833   execute_process (COMMAND ${launcher} "${_${_PYTHON_PREFIX}_COMPILER}"
 834                            ${_${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_ARCH_FLAGS}
 835                            /target:exe /embed "${working_dir}/version.py"
 836                    WORKING_DIRECTORY "${working_dir}"
 837                    OUTPUT_QUIET
 838                    ERROR_QUIET
 839                    OUTPUT_STRIP_TRAILING_WHITESPACE)
 840   get_filename_component (ir_dir "${_${_PYTHON_PREFIX}_COMPILER}" DIRECTORY)
 841   execute_process (COMMAND "${CMAKE_COMMAND}" -E env "MONO_PATH=${ir_dir}"
 842                                               ${${_PYTHON_PREFIX}_DOTNET_LAUNCHER} "${working_dir}/version.exe"
 843                    WORKING_DIRECTORY "${working_dir}"
 844                    RESULT_VARIABLE result
 845                    OUTPUT_VARIABLE version
 846                    ERROR_QUIET)
 847   file (REMOVE_RECURSE "${working_dir}")
 848   if (result)
 849     # compiler is not usable
 850     set (_${_PYTHON_PREFIX}_Compiler_REASON_FAILURE "Cannot use the compiler \"${_${_PYTHON_PREFIX}_COMPILER}\"" PARENT_SCOPE)
 851     set_property (CACHE _${_PYTHON_PREFIX}_COMPILER PROPERTY VALUE "${_PYTHON_PREFIX}_COMPILER-NOTFOUND")
 852   elseif ((_PVC_EXACT AND NOT version VERSION_EQUAL expected_version)
 853           OR NOT version VERSION_GREATER_EQUAL expected_version)
 854     # Compiler has wrong version
 855     set (_${_PYTHON_PREFIX}_Compiler_REASON_FAILURE "Wrong version for the compiler \"${_${_PYTHON_PREFIX}_COMPILER}\"" PARENT_SCOPE)
 856     set_property (CACHE _${_PYTHON_PREFIX}_COMPILER PROPERTY VALUE "${_PYTHON_PREFIX}_COMPILER-NOTFOUND")
 857   endif()
 858 endfunction()
 859
 860
 861 function (_PYTHON_VALIDATE_LIBRARY)
 862   if (NOT _${_PYTHON_PREFIX}_LIBRARY_RELEASE)
 863     unset (_${_PYTHON_PREFIX}_LIBRARY_DEBUG)
 864     return()
 865   endif()
 866
 867   cmake_parse_arguments (PARSE_ARGV 0 _PVL "EXACT;CHECK_EXISTS" "" "")
 868   if (_PVL_UNPARSED_ARGUMENTS)
 869     set (expected_version ${_PVL_UNPARSED_ARGUMENTS})
 870   else()
 871     unset (expected_version)
 872   endif()
 873
 874   if (_PVL_CHECK_EXISTS AND NOT EXISTS "${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}")
 875     # library does not exist anymore
 876     set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Cannot find the library \"${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}\"" PARENT_SCOPE)
 877     set_property (CACHE _${_PYTHON_PREFIX}_LIBRARY_RELEASE PROPERTY VALUE "${_PYTHON_PREFIX}_LIBRARY_RELEASE-NOTFOUND")
 878     if (WIN32)
 879       set_property (CACHE _${_PYTHON_PREFIX}_LIBRARY_DEBUG PROPERTY VALUE "${_PYTHON_PREFIX}_LIBRARY_DEBUG-NOTFOUND")
 880     endif()
 881     set_property (CACHE _${_PYTHON_PREFIX}_INCLUDE_DIR PROPERTY VALUE "${_PYTHON_PREFIX}_INCLUDE_DIR-NOTFOUND")
 882     return()
 883   endif()
 884
 885   # retrieve version and abi from library name
 886   _python_get_version (LIBRARY PREFIX lib_)
 887
 888   if (DEFINED _${_PYTHON_PREFIX}_FIND_ABI AND NOT lib_ABI IN_LIST _${_PYTHON_PREFIX}_ABIFLAGS)
 889     # incompatible ABI
 890     set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Wrong ABI for the library \"${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}\"" PARENT_SCOPE)
 891     set_property (CACHE _${_PYTHON_PREFIX}_LIBRARY_RELEASE PROPERTY VALUE "${_PYTHON_PREFIX}_LIBRARY_RELEASE-NOTFOUND")
 892   else()
 893     if (expected_version)
 894       # library have only major.minor information
 895       string (REGEX MATCH "[0-9](\\.[0-9]+)?" version "${expected_version}")
 896       if ((_PVL_EXACT AND NOT lib_VERSION VERSION_EQUAL version) OR (lib_VERSION VERSION_LESS version))
 897         # library has wrong version
 898         set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Wrong version for the library \"${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}\"" PARENT_SCOPE)
 899         set_property (CACHE _${_PYTHON_PREFIX}_LIBRARY_RELEASE PROPERTY VALUE "${_PYTHON_PREFIX}_LIBRARY_RELEASE-NOTFOUND")
 900       endif()
 901     else()
 902       if (NOT lib_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR)
 903         # library has wrong major version
 904         set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Wrong major version for the library \"${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}\"" PARENT_SCOPE)
 905         set_property (CACHE _${_PYTHON_PREFIX}_LIBRARY_RELEASE PROPERTY VALUE "${_PYTHON_PREFIX}_LIBRARY_RELEASE-NOTFOUND")
 906       endif()
 907     endif()
 908   endif()
 909
 910   if (NOT _${_PYTHON_PREFIX}_LIBRARY_RELEASE)
 911     if (WIN32)
 912       set_property (CACHE _${_PYTHON_PREFIX}_LIBRARY_DEBUG PROPERTY VALUE "${_PYTHON_PREFIX}_LIBRARY_DEBUG-NOTFOUND")
 913     endif()
 914     unset (_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE CACHE)
 915     unset (_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG CACHE)
 916     set_property (CACHE _${_PYTHON_PREFIX}_INCLUDE_DIR PROPERTY VALUE "${_PYTHON_PREFIX}_INCLUDE_DIR-NOTFOUND")
 917   endif()
 918 endfunction()
 919
 920
 921 function (_PYTHON_VALIDATE_INCLUDE_DIR)
 922   if (NOT _${_PYTHON_PREFIX}_INCLUDE_DIR)
 923     return()
 924   endif()
 925
 926   cmake_parse_arguments (PARSE_ARGV 0 _PVID "EXACT;CHECK_EXISTS" "" "")
 927   if (_PVID_UNPARSED_ARGUMENTS)
 928     set (expected_version ${_PVID_UNPARSED_ARGUMENTS})
 929   else()
 930     unset (expected_version)
 931   endif()
 932
 933   if (_PVID_CHECK_EXISTS AND NOT EXISTS "${_${_PYTHON_PREFIX}_INCLUDE_DIR}")
 934     # include file does not exist anymore
 935     set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Cannot find the directory \"${_${_PYTHON_PREFIX}_INCLUDE_DIR}\"" PARENT_SCOPE)
 936     set_property (CACHE _${_PYTHON_PREFIX}_INCLUDE_DIR PROPERTY VALUE "${_PYTHON_PREFIX}_INCLUDE_DIR-NOTFOUND")
 937     return()
 938   endif()
 939
 940   # retrieve version from header file
 941   _python_get_version (INCLUDE PREFIX inc_)
 942
 943   if (DEFINED _${_PYTHON_PREFIX}_FIND_ABI AND NOT inc_ABI IN_LIST _${_PYTHON_PREFIX}_ABIFLAGS)
 944     # incompatible ABI
 945     set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Wrong ABI for the directory \"${_${_PYTHON_PREFIX}_INCLUDE_DIR}\"" PARENT_SCOPE)
 946     set_property (CACHE _${_PYTHON_PREFIX}_INCLUDE_DIR PROPERTY VALUE "${_PYTHON_PREFIX}_INCLUDE_DIR-NOTFOUND")
 947   else()
 948     if (expected_version)
 949       if ((_PVID_EXACT AND NOT inc_VERSION VERSION_EQUAL expected_version) OR (inc_VERSION VERSION_LESS expected_version))
 950         # include dir has wrong version
 951         set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Wrong version for the directory \"${_${_PYTHON_PREFIX}_INCLUDE_DIR}\"" PARENT_SCOPE)
 952         set_property (CACHE _${_PYTHON_PREFIX}_INCLUDE_DIR PROPERTY VALUE "${_PYTHON_PREFIX}_INCLUDE_DIR-NOTFOUND")
 953       endif()
 954     else()
 955       if (NOT inc_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR)
 956         # include dir has wrong major version
 957         set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Wrong major version for the directory \"${_${_PYTHON_PREFIX}_INCLUDE_DIR}\"" PARENT_SCOPE)
 958         set_property (CACHE _${_PYTHON_PREFIX}_INCLUDE_DIR PROPERTY VALUE "${_PYTHON_PREFIX}_INCLUDE_DIR-NOTFOUND")
 959       endif()
 960     endif()
 961   endif()
 962 endfunction()
 963
 964
 965 function (_PYTHON_FIND_RUNTIME_LIBRARY _PYTHON_LIB)
 966   string (REPLACE "_RUNTIME" "" _PYTHON_LIB "${_PYTHON_LIB}")
 967   # look at runtime part on systems supporting it
 968   if (CMAKE_SYSTEM_NAME STREQUAL "Windows" OR
 969       (CMAKE_SYSTEM_NAME MATCHES "MSYS|CYGWIN"
 970         AND ${_PYTHON_LIB} MATCHES "${CMAKE_IMPORT_LIBRARY_SUFFIX}$"))
 971     set (CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_SHARED_LIBRARY_SUFFIX})
 972     # MSYS has a special syntax for runtime libraries
 973     if (CMAKE_SYSTEM_NAME MATCHES "MSYS")
 974       list (APPEND CMAKE_FIND_LIBRARY_PREFIXES "msys-")
 975     endif()
 976     find_library (${ARGV})
 977   endif()
 978 endfunction()
 979
 980
 981 function (_PYTHON_SET_LIBRARY_DIRS _PYTHON_SLD_RESULT)
 982   unset (_PYTHON_DIRS)
 983   set (_PYTHON_LIBS ${ARGN})
 984   foreach (_PYTHON_LIB IN LISTS _PYTHON_LIBS)
 985     if (${_PYTHON_LIB})
 986       get_filename_component (_PYTHON_DIR "${${_PYTHON_LIB}}" DIRECTORY)
 987       list (APPEND _PYTHON_DIRS "${_PYTHON_DIR}")
 988     endif()
 989   endforeach()
 990   list (REMOVE_DUPLICATES _PYTHON_DIRS)
 991   set (${_PYTHON_SLD_RESULT} ${_PYTHON_DIRS} PARENT_SCOPE)
 992 endfunction()
 993
 994
 995 function (_PYTHON_SET_DEVELOPMENT_MODULE_FOUND module)
 996   if ("Development.${module}" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
 997     string(TOUPPER "${module}" id)
 998     set (module_found TRUE)
 999
1000     if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS
1001         AND NOT _${_PYTHON_PREFIX}_LIBRARY_RELEASE)
1002       set (module_found FALSE)
1003     endif()
1004     if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS
1005         AND NOT _${_PYTHON_PREFIX}_INCLUDE_DIR)
1006       set (module_found FALSE)
1007     endif()
1008
1009     set (${_PYTHON_PREFIX}_Development.${module}_FOUND ${module_found} PARENT_SCOPE)
1010   endif()
1011 endfunction()
1012
1013
1014 # If major version is specified, it must be the same as internal major version
1015 if (DEFINED ${_PYTHON_PREFIX}_FIND_VERSION_MAJOR
1016     AND NOT ${_PYTHON_PREFIX}_FIND_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR)
1017   _python_display_failure ("Could NOT find ${_PYTHON_PREFIX}: Wrong major version specified is \"${${_PYTHON_PREFIX}_FIND_VERSION_MAJOR}\", but expected major version is \"${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}\"")
1018 endif()
1019
1020
1021 # handle components
1022 if (NOT ${_PYTHON_PREFIX}_FIND_COMPONENTS)
1023   set (${_PYTHON_PREFIX}_FIND_COMPONENTS Interpreter)
1024   set (${_PYTHON_PREFIX}_FIND_REQUIRED_Interpreter TRUE)
1025 endif()
1026 if ("NumPy" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
1027   list (APPEND ${_PYTHON_PREFIX}_FIND_COMPONENTS "Interpreter" "Development.Module")
1028 endif()
1029 if ("Development" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
1030   list (APPEND ${_PYTHON_PREFIX}_FIND_COMPONENTS "Development.Module" "Development.Embed")
1031 endif()
1032 list (REMOVE_DUPLICATES ${_PYTHON_PREFIX}_FIND_COMPONENTS)
1033 foreach (_${_PYTHON_PREFIX}_COMPONENT IN ITEMS Interpreter Compiler Development Development.Module Development.Embed NumPy)
1034   set (${_PYTHON_PREFIX}_${_${_PYTHON_PREFIX}_COMPONENT}_FOUND FALSE)
1035 endforeach()
1036 if (${_PYTHON_PREFIX}_FIND_REQUIRED_Development)
1037   set (${_PYTHON_PREFIX}_FIND_REQUIRED_Development.Module TRUE)
1038   set (${_PYTHON_PREFIX}_FIND_REQUIRED_Development.Embed TRUE)
1039 endif()
1040
1041 unset (_${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS)
1042 unset (_${_PYTHON_PREFIX}_FIND_DEVELOPMENT_MODULE_ARTIFACTS)
1043 unset (_${_PYTHON_PREFIX}_FIND_DEVELOPMENT_EMBED_ARTIFACTS)
1044 if ("Development.Module" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
1045   if (CMAKE_SYSTEM_NAME MATCHES "^(Windows.*|CYGWIN|MSYS)$")
1046     list (APPEND _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_MODULE_ARTIFACTS "LIBRARY")
1047   endif()
1048   list (APPEND _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_MODULE_ARTIFACTS "INCLUDE_DIR")
1049 endif()
1050 if ("Development.Embed" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
1051   list (APPEND _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_EMBED_ARTIFACTS "LIBRARY" "INCLUDE_DIR")
1052 endif()
1053 set (_${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS ${_${_PYTHON_PREFIX}_FIND_DEVELOPMENT_MODULE_ARTIFACTS} ${_${_PYTHON_PREFIX}_FIND_DEVELOPMENT_EMBED_ARTIFACTS})
1054 list (REMOVE_DUPLICATES _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS)
1055
1056 # Set versions to search
1057 ## default: search any version
1058 set (_${_PYTHON_PREFIX}_FIND_VERSIONS ${_${_PYTHON_PREFIX}_VERSIONS})
1059 unset (_${_PYTHON_PREFIX}_FIND_VERSION_EXACT)
1060
1061 if (${_PYTHON_PREFIX}_FIND_VERSION_COUNT)
1062   if (${_PYTHON_PREFIX}_FIND_VERSION_EXACT)
1063     set (_${_PYTHON_PREFIX}_FIND_VERSION_EXACT "EXACT")
1064     set (_${_PYTHON_PREFIX}_FIND_VERSIONS ${${_PYTHON_PREFIX}_FIND_VERSION_MAJOR}.${${_PYTHON_PREFIX}_FIND_VERSION_MINOR})
1065   else()
1066     unset (_${_PYTHON_PREFIX}_FIND_VERSIONS)
1067     # add all compatible versions
1068     foreach (_${_PYTHON_PREFIX}_VERSION IN LISTS _${_PYTHON_PREFIX}_VERSIONS)
1069       if (_${_PYTHON_PREFIX}_VERSION VERSION_GREATER_EQUAL "${${_PYTHON_PREFIX}_FIND_VERSION_MAJOR}.${${_PYTHON_PREFIX}_FIND_VERSION_MINOR}")
1070         list (APPEND _${_PYTHON_PREFIX}_FIND_VERSIONS ${_${_PYTHON_PREFIX}_VERSION})
1071       endif()
1072     endforeach()
1073   endif()
1074 endif()
1075
1076 # Set ABIs to search
1077 ## default: search any ABI
1078 if (_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR VERSION_LESS "3")
1079   # ABI not supported
1080   unset (_${_PYTHON_PREFIX}_FIND_ABI)
1081   set (_${_PYTHON_PREFIX}_ABIFLAGS "")
1082 else()
1083   unset (_${_PYTHON_PREFIX}_FIND_ABI)
1084   unset (_${_PYTHON_PREFIX}_ABIFLAGS)
1085   if (DEFINED ${_PYTHON_PREFIX}_FIND_ABI)
1086     # normalization
1087     string (TOUPPER "${${_PYTHON_PREFIX}_FIND_ABI}" _${_PYTHON_PREFIX}_FIND_ABI)
1088     list (TRANSFORM _${_PYTHON_PREFIX}_FIND_ABI REPLACE "^(TRUE|Y(ES)?|1)$" "ON")
1089     list (TRANSFORM _${_PYTHON_PREFIX}_FIND_ABI REPLACE "^(FALSE|N(O)?|0)$" "OFF")
1090     if (NOT _${_PYTHON_PREFIX}_FIND_ABI MATCHES "^(ON|OFF|ANY);(ON|OFF|ANY);(ON|OFF|ANY)$")
1091       message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_ABI}: invalid value for '${_PYTHON_PREFIX}_FIND_ABI'. Ignore it")
1092       unset (_${_PYTHON_PREFIX}_FIND_ABI)
1093     endif()
1094     _python_get_abiflags (_${_PYTHON_PREFIX}_ABIFLAGS)
1095   endif()
1096 endif()
1097 unset (${_PYTHON_PREFIX}_SOABI)
1098
1099 # Define lookup strategy
1100 if (_${_PYTHON_PREFIX}_LOOKUP_POLICY STREQUAL "NEW")
1101   set (_${_PYTHON_PREFIX}_FIND_STRATEGY "LOCATION")
1102 else()
1103   set (_${_PYTHON_PREFIX}_FIND_STRATEGY "VERSION")
1104 endif()
1105 if (DEFINED ${_PYTHON_PREFIX}_FIND_STRATEGY)
1106   if (NOT ${_PYTHON_PREFIX}_FIND_STRATEGY MATCHES "^(VERSION|LOCATION)$")
1107     message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_STRATEGY}: invalid value for '${_PYTHON_PREFIX}_FIND_STRATEGY'. 'VERSION' or 'LOCATION' expected.")
1108     set (_${_PYTHON_PREFIX}_FIND_STRATEGY "VERSION")
1109   else()
1110     set (_${_PYTHON_PREFIX}_FIND_STRATEGY "${${_PYTHON_PREFIX}_FIND_STRATEGY}")
1111   endif()
1112 endif()
1113
1114 # Python and Anaconda distributions: define which architectures can be used
1115 if (CMAKE_SIZEOF_VOID_P)
1116   # In this case, search only for 64bit or 32bit
1117   math (EXPR _${_PYTHON_PREFIX}_ARCH "${CMAKE_SIZEOF_VOID_P} * 8")
1118   set (_${_PYTHON_PREFIX}_ARCH2 ${_${_PYTHON_PREFIX}_ARCH})
1119 else()
1120   # architecture unknown, search for both 64bit and 32bit
1121   set (_${_PYTHON_PREFIX}_ARCH 64)
1122   set (_${_PYTHON_PREFIX}_ARCH2 32)
1123 endif()
1124
1125 # IronPython support
1126 unset (_${_PYTHON_PREFIX}_IRON_PYTHON_INTERPRETER_NAMES)
1127 unset (_${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_NAMES)
1128 unset (_${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_ARCH_FLAGS)
1129 if (CMAKE_SIZEOF_VOID_P)
1130   if (_${_PYTHON_PREFIX}_ARCH EQUAL "32")
1131     set (_${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_ARCH_FLAGS "/platform:x86")
1132   else()
1133     set (_${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_ARCH_FLAGS "/platform:x64")
1134   endif()
1135 endif()
1136 if (NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
1137   # Do not use wrapper script on Linux because it is buggy: -c interpreter option cannot be used
1138   list (APPEND _${_PYTHON_PREFIX}_IRON_PYTHON_INTERPRETER_NAMES "ipy${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}" "ipy64" "ipy32" "ipy")
1139   list (APPEND _${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_NAMES "ipyc")
1140 endif()
1141 list (APPEND _${_PYTHON_PREFIX}_IRON_PYTHON_INTERPRETER_NAMES "ipy.exe")
1142 list (APPEND _${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_NAMES "ipyc.exe")
1143 set (_${_PYTHON_PREFIX}_IRON_PYTHON_PATH_SUFFIXES net45 net40 bin)
1144
1145 # PyPy support
1146 if (_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR EQUAL "3")
1147   set (_${_PYTHON_PREFIX}_PYPY_NAMES pypy3)
1148   set (_${_PYTHON_PREFIX}_PYPY_LIB_NAMES pypy3-c)
1149   if (WIN32)
1150     # special name for runtime part
1151     list (APPEND _${_PYTHON_PREFIX}_PYPY_LIB_NAMES libpypy3-c)
1152   endif()
1153   set (_${_PYTHON_PREFIX}_PYPY_INCLUDE_PATH_SUFFIXES lib/pypy3)
1154 else()
1155   set (_${_PYTHON_PREFIX}_PYPY_NAMES pypy)
1156   set (_${_PYTHON_PREFIX}_PYPY_LIB_NAMES pypy-c)
1157   if (WIN32)
1158     # special name for runtime part
1159     list (APPEND _${_PYTHON_PREFIX}_PYPY_LIB_NAMES libpypy-c)
1160   endif()
1161   set (_${_PYTHON_PREFIX}_PYPY_INCLUDE_PATH_SUFFIXES lib/pypy)
1162 endif()
1163 set (_${_PYTHON_PREFIX}_PYPY_EXECUTABLE_PATH_SUFFIXES bin)
1164 set (_${_PYTHON_PREFIX}_PYPY_LIBRARY_PATH_SUFFIXES lib libs bin)
1165 list (APPEND _${_PYTHON_PREFIX}_PYPY_INCLUDE_PATH_SUFFIXES include)
1166
1167 # Python Implementations handling
1168 unset (_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS)
1169 if (DEFINED ${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS)
1170   foreach (_${_PYTHON_PREFIX}_IMPLEMENTATION IN LISTS ${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS)
1171     if (NOT _${_PYTHON_PREFIX}_IMPLEMENTATION MATCHES "^(CPython|IronPython|PyPy)$")
1172       message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${_${_PYTHON_PREFIX}_IMPLEMENTATION}: invalid value for '${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS'. 'CPython', 'IronPython' or 'PyPy' expected. Value will be ignored.")
1173     else()
1174       list (APPEND _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS ${_${_PYTHON_PREFIX}_IMPLEMENTATION})
1175     endif()
1176   endforeach()
1177 else()
1178   if (WIN32)
1179     set (_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS CPython IronPython)
1180   else()
1181     set (_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS CPython)
1182   endif()
1183 endif()
1184
1185 # compute list of names for header file
1186 unset (_${_PYTHON_PREFIX}_INCLUDE_NAMES)
1187 foreach (_${_PYTHON_PREFIX}_IMPLEMENTATION IN LISTS _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS)
1188   if (_${_PYTHON_PREFIX}_IMPLEMENTATION STREQUAL "CPython")
1189     list (APPEND _${_PYTHON_PREFIX}_INCLUDE_NAMES "Python.h")
1190   elseif (_${_PYTHON_PREFIX}_IMPLEMENTATION STREQUAL "PyPy")
1191     list (APPEND _${_PYTHON_PREFIX}_INCLUDE_NAMES "PyPy.h")
1192   endif()
1193 endforeach()
1194
1195
1196 # Apple frameworks handling
1197 _python_find_frameworks ()
1198
1199 set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK "FIRST")
1200
1201 if (DEFINED ${_PYTHON_PREFIX}_FIND_FRAMEWORK)
1202   if (NOT ${_PYTHON_PREFIX}_FIND_FRAMEWORK MATCHES "^(FIRST|LAST|NEVER)$")
1203     message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_FRAMEWORK}: invalid value for '${_PYTHON_PREFIX}_FIND_FRAMEWORK'. 'FIRST', 'LAST' or 'NEVER' expected. 'FIRST' will be used instead.")
1204   else()
1205     set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK ${${_PYTHON_PREFIX}_FIND_FRAMEWORK})
1206   endif()
1207 elseif (DEFINED CMAKE_FIND_FRAMEWORK)
1208   if (CMAKE_FIND_FRAMEWORK STREQUAL "ONLY")
1209     message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: CMAKE_FIND_FRAMEWORK: 'ONLY' value is not supported. 'FIRST' will be used instead.")
1210   elseif (NOT CMAKE_FIND_FRAMEWORK MATCHES "^(FIRST|LAST|NEVER)$")
1211     message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${CMAKE_FIND_FRAMEWORK}: invalid value for 'CMAKE_FIND_FRAMEWORK'. 'FIRST', 'LAST' or 'NEVER' expected. 'FIRST' will be used instead.")
1212   else()
1213     set (_${_PYTHON_PREFIX}_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK})
1214   endif()
1215 endif()
1216
1217 # Save CMAKE_FIND_APPBUNDLE
1218 if (DEFINED CMAKE_FIND_APPBUNDLE)
1219   set (_${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE ${CMAKE_FIND_APPBUNDLE})
1220 else()
1221   unset (_${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE)
1222 endif()
1223 # To avoid app bundle lookup
1224 set (CMAKE_FIND_APPBUNDLE "NEVER")
1225
1226 # Save CMAKE_FIND_FRAMEWORK
1227 if (DEFINED CMAKE_FIND_FRAMEWORK)
1228   set (_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK})
1229 else()
1230   unset (_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK)
1231 endif()
1232 # To avoid framework lookup
1233 set (CMAKE_FIND_FRAMEWORK "NEVER")
1234
1235 # Windows Registry handling
1236 if (DEFINED ${_PYTHON_PREFIX}_FIND_REGISTRY)
1237   if (NOT ${_PYTHON_PREFIX}_FIND_REGISTRY MATCHES "^(FIRST|LAST|NEVER)$")
1238     message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_REGISTRY}: invalid value for '${_PYTHON_PREFIX}_FIND_REGISTRY'. 'FIRST', 'LAST' or 'NEVER' expected. 'FIRST' will be used instead.")
1239     set (_${_PYTHON_PREFIX}_FIND_REGISTRY "FIRST")
1240   else()
1241     set (_${_PYTHON_PREFIX}_FIND_REGISTRY ${${_PYTHON_PREFIX}_FIND_REGISTRY})
1242   endif()
1243 else()
1244   set (_${_PYTHON_PREFIX}_FIND_REGISTRY "FIRST")
1245 endif()
1246
1247 # virtual environments recognition
1248 if (DEFINED ENV{VIRTUAL_ENV} OR DEFINED ENV{CONDA_PREFIX})
1249   if (DEFINED ${_PYTHON_PREFIX}_FIND_VIRTUALENV)
1250     if (NOT ${_PYTHON_PREFIX}_FIND_VIRTUALENV MATCHES "^(FIRST|ONLY|STANDARD)$")
1251       message (AUTHOR_WARNING "Find${_PYTHON_PREFIX}: ${${_PYTHON_PREFIX}_FIND_VIRTUALENV}: invalid value for '${_PYTHON_PREFIX}_FIND_VIRTUALENV'. 'FIRST', 'ONLY' or 'STANDARD' expected. 'FIRST' will be used instead.")
1252       set (_${_PYTHON_PREFIX}_FIND_VIRTUALENV "FIRST")
1253     else()
1254       set (_${_PYTHON_PREFIX}_FIND_VIRTUALENV ${${_PYTHON_PREFIX}_FIND_VIRTUALENV})
1255     endif()
1256   else()
1257     set (_${_PYTHON_PREFIX}_FIND_VIRTUALENV FIRST)
1258   endif()
1259 else()
1260   set (_${_PYTHON_PREFIX}_FIND_VIRTUALENV STANDARD)
1261 endif()
1262
1263
1264 # Compute search signature
1265 # This signature will be used to check validity of cached variables on new search
1266 set (_${_PYTHON_PREFIX}_SIGNATURE "${${_PYTHON_PREFIX}_ROOT_DIR}:${_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS}:${_${_PYTHON_PREFIX}_FIND_STRATEGY}:${${_PYTHON_PREFIX}_FIND_VIRTUALENV}")
1267 if (NOT WIN32)
1268   string (APPEND _${_PYTHON_PREFIX}_SIGNATURE ":${${_PYTHON_PREFIX}_USE_STATIC_LIBS}:")
1269 endif()
1270 if (CMAKE_HOST_APPLE)
1271   string (APPEND _${_PYTHON_PREFIX}_SIGNATURE ":${_${_PYTHON_PREFIX}_FIND_FRAMEWORK}")
1272 endif()
1273 if (CMAKE_HOST_WIN32)
1274   string (APPEND _${_PYTHON_PREFIX}_SIGNATURE ":${_${_PYTHON_PREFIX}_FIND_REGISTRY}")
1275 endif()
1276
1277 function (_PYTHON_CHECK_DEVELOPMENT_SIGNATURE module)
1278   if ("Development.${module}" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
1279     string (TOUPPER "${module}" id)
1280     set (signature "${_${_PYTHON_PREFIX}_SIGNATURE}:")
1281     if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS)
1282       list (APPEND signature "${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}:")
1283     endif()
1284     if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS)
1285       list (APPEND signature "${_${_PYTHON_PREFIX}_INCLUDE_DIR}:")
1286     endif()
1287     string (MD5 signature "${signature}")
1288     if (signature STREQUAL _${_PYTHON_PREFIX}_DEVELOPMENT_${id}_SIGNATURE)
1289       if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS)
1290         _python_validate_library (${${_PYTHON_PREFIX}_FIND_VERSION}
1291                                   ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT}
1292                                   CHECK_EXISTS)
1293       endif()
1294       if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS)
1295         _python_validate_include_dir (${${_PYTHON_PREFIX}_FIND_VERSION}
1296                                       ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT}
1297                                       CHECK_EXISTS)
1298       endif()
1299     else()
1300       if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS)
1301         unset (_${_PYTHON_PREFIX}_LIBRARY_RELEASE CACHE)
1302         unset (_${_PYTHON_PREFIX}_LIBRARY_DEBUG CACHE)
1303       endif()
1304       if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS)
1305         unset (_${_PYTHON_PREFIX}_INCLUDE_DIR CACHE)
1306       endif()
1307     endif()
1308     if (("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS
1309           AND NOT _${_PYTHON_PREFIX}_LIBRARY_RELEASE)
1310         OR ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS
1311           AND NOT _${_PYTHON_PREFIX}_INCLUDE_DIR))
1312       unset (_${_PYTHON_PREFIX}_CONFIG CACHE)
1313       unset (_${_PYTHON_PREFIX}_DEVELOPMENT_${id}_SIGNATURE CACHE)
1314     endif()
1315   endif()
1316 endfunction()
1317
1318 function (_PYTHON_COMPUTE_DEVELOPMENT_SIGNATURE module)
1319   string (TOUPPER "${module}" id)
1320   if (${_PYTHON_PREFIX}_Development.${module}_FOUND)
1321     set (signature "${_${_PYTHON_PREFIX}_SIGNATURE}:")
1322     if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS)
1323       list (APPEND signature "${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}:")
1324     endif()
1325     if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_${id}_ARTIFACTS)
1326       list (APPEND signature "${_${_PYTHON_PREFIX}_INCLUDE_DIR}:")
1327     endif()
1328     string (MD5 signature "${signature}")
1329     set (_${_PYTHON_PREFIX}_DEVELOPMENT_${id}_SIGNATURE "${signature}" CACHE INTERNAL "")
1330   else()
1331     unset (_${_PYTHON_PREFIX}_DEVELOPMENT_${id}_SIGNATURE CACHE)
1332   endif()
1333 endfunction()
1334
1335
1336 unset (_${_PYTHON_PREFIX}_REQUIRED_VARS)
1337 unset (_${_PYTHON_PREFIX}_CACHED_VARS)
1338 unset (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE)
1339 unset (_${_PYTHON_PREFIX}_Compiler_REASON_FAILURE)
1340 unset (_${_PYTHON_PREFIX}_Development_REASON_FAILURE)
1341 unset (_${_PYTHON_PREFIX}_NumPy_REASON_FAILURE)
1342
1343
1344 # preamble
1345 ## For IronPython on platforms other than Windows, search for the .Net interpreter
1346 if ("IronPython" IN_LIST _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS
1347     AND NOT WIN32)
1348   find_program (${_PYTHON_PREFIX}_DOTNET_LAUNCHER
1349                 NAMES "mono")
1350 endif()
1351
1352
1353 # first step, search for the interpreter
1354 if ("Interpreter" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
1355   list (APPEND _${_PYTHON_PREFIX}_CACHED_VARS _${_PYTHON_PREFIX}_EXECUTABLE
1356                                               _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES)
1357   if (${_PYTHON_PREFIX}_FIND_REQUIRED_Interpreter)
1358     list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_EXECUTABLE)
1359   endif()
1360
1361   if (DEFINED ${_PYTHON_PREFIX}_EXECUTABLE
1362       AND IS_ABSOLUTE "${${_PYTHON_PREFIX}_EXECUTABLE}")
1363     if (NOT ${_PYTHON_PREFIX}_EXECUTABLE STREQUAL _${_PYTHON_PREFIX}_EXECUTABLE)
1364       # invalidate cache properties
1365       unset (_${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES CACHE)
1366     endif()
1367     set (_${_PYTHON_PREFIX}_EXECUTABLE "${${_PYTHON_PREFIX}_EXECUTABLE}" CACHE INTERNAL "")
1368   elseif (DEFINED _${_PYTHON_PREFIX}_EXECUTABLE)
1369     # compute interpreter signature and check validity of definition
1370     string (MD5 __${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE "${_${_PYTHON_PREFIX}_SIGNATURE}:${_${_PYTHON_PREFIX}_EXECUTABLE}")
1371     if (__${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE STREQUAL _${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE)
1372       # check version validity
1373       if (${_PYTHON_PREFIX}_FIND_VERSION_EXACT)
1374         _python_validate_interpreter (${${_PYTHON_PREFIX}_FIND_VERSION} EXACT CHECK_EXISTS)
1375       else()
1376         _python_validate_interpreter (${${_PYTHON_PREFIX}_FIND_VERSION} CHECK_EXISTS)
1377       endif()
1378     else()
1379       unset (_${_PYTHON_PREFIX}_EXECUTABLE CACHE)
1380     endif()
1381     if (NOT _${_PYTHON_PREFIX}_EXECUTABLE)
1382       unset (_${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE CACHE)
1383       unset (_${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES CACHE)
1384     endif()
1385   endif()
1386
1387   if (NOT _${_PYTHON_PREFIX}_EXECUTABLE)
1388     set (_${_PYTHON_PREFIX}_HINTS "${${_PYTHON_PREFIX}_ROOT_DIR}" ENV ${_PYTHON_PREFIX}_ROOT_DIR)
1389
1390     if (_${_PYTHON_PREFIX}_FIND_STRATEGY STREQUAL "LOCATION")
1391       # build all executable names
1392       _python_get_names (_${_PYTHON_PREFIX}_NAMES VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS} POSIX INTERPRETER)
1393       _python_get_path_suffixes (_${_PYTHON_PREFIX}_PATH_SUFFIXES VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS} INTERPRETER)
1394
1395       # Framework Paths
1396       _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS})
1397       # Registry Paths
1398       _python_get_registries (_${_PYTHON_PREFIX}_REGISTRY_PATHS VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS})
1399
1400       while (TRUE)
1401         # Virtual environments handling
1402         if (_${_PYTHON_PREFIX}_FIND_VIRTUALENV MATCHES "^(FIRST|ONLY)$")
1403           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1404                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1405                         NAMES_PER_DIR
1406                         HINTS ${_${_PYTHON_PREFIX}_HINTS}
1407                         PATHS ENV VIRTUAL_ENV ENV CONDA_PREFIX
1408                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1409                         NO_CMAKE_PATH
1410                         NO_CMAKE_ENVIRONMENT_PATH
1411                         NO_SYSTEM_ENVIRONMENT_PATH
1412                         NO_CMAKE_SYSTEM_PATH)
1413
1414           _python_validate_interpreter (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1415           if (_${_PYTHON_PREFIX}_EXECUTABLE)
1416             break()
1417           endif()
1418           if (_${_PYTHON_PREFIX}_FIND_VIRTUALENV STREQUAL "ONLY")
1419             break()
1420           endif()
1421         endif()
1422
1423         # Apple frameworks handling
1424         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST")
1425           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1426                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1427                         NAMES_PER_DIR
1428                         HINTS ${_${_PYTHON_PREFIX}_HINTS}
1429                         PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
1430                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1431                         NO_CMAKE_PATH
1432                         NO_CMAKE_ENVIRONMENT_PATH
1433                         NO_SYSTEM_ENVIRONMENT_PATH
1434                         NO_CMAKE_SYSTEM_PATH)
1435           _python_validate_interpreter (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1436           if (_${_PYTHON_PREFIX}_EXECUTABLE)
1437             break()
1438           endif()
1439         endif()
1440         # Windows registry
1441         if (CMAKE_HOST_WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST")
1442           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1443                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1444                         NAMES_PER_DIR
1445                         HINTS ${_${_PYTHON_PREFIX}_HINTS}
1446                         PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
1447                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1448                         NO_SYSTEM_ENVIRONMENT_PATH
1449                         NO_CMAKE_SYSTEM_PATH)
1450           _python_validate_interpreter (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1451           if (_${_PYTHON_PREFIX}_EXECUTABLE)
1452             break()
1453           endif()
1454         endif()
1455
1456         # try using HINTS
1457         find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1458                       NAMES ${_${_PYTHON_PREFIX}_NAMES}
1459                       NAMES_PER_DIR
1460                       HINTS ${_${_PYTHON_PREFIX}_HINTS}
1461                       PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1462                       NO_SYSTEM_ENVIRONMENT_PATH
1463                       NO_CMAKE_SYSTEM_PATH)
1464         _python_validate_interpreter (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1465         if (_${_PYTHON_PREFIX}_EXECUTABLE)
1466           break()
1467         endif()
1468         # try using standard paths
1469         find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1470                       NAMES ${_${_PYTHON_PREFIX}_NAMES}
1471                       NAMES_PER_DIR
1472                       PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES})
1473         _python_validate_interpreter (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1474         if (_${_PYTHON_PREFIX}_EXECUTABLE)
1475           break()
1476         endif()
1477
1478         # Apple frameworks handling
1479         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST")
1480           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1481                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1482                         NAMES_PER_DIR
1483                         PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
1484                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1485                         NO_DEFAULT_PATH)
1486           _python_validate_interpreter (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1487           if (_${_PYTHON_PREFIX}_EXECUTABLE)
1488             break()
1489           endif()
1490         endif()
1491         # Windows registry
1492         if (CMAKE_HOST_WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST")
1493           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1494                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1495                         NAMES_PER_DIR
1496                         PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
1497                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1498                         NO_DEFAULT_PATH)
1499           _python_validate_interpreter (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1500           if (_${_PYTHON_PREFIX}_EXECUTABLE)
1501             break()
1502           endif()
1503         endif()
1504
1505         break()
1506       endwhile()
1507     else()
1508       # look-up for various versions and locations
1509       foreach (_${_PYTHON_PREFIX}_VERSION IN LISTS _${_PYTHON_PREFIX}_FIND_VERSIONS)
1510         _python_get_names (_${_PYTHON_PREFIX}_NAMES VERSION ${_${_PYTHON_PREFIX}_VERSION} POSIX INTERPRETER)
1511         _python_get_path_suffixes (_${_PYTHON_PREFIX}_PATH_SUFFIXES VERSION ${_${_PYTHON_PREFIX}_VERSION} INTERPRETER)
1512
1513         _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS VERSION ${_${_PYTHON_PREFIX}_VERSION})
1514         _python_get_registries (_${_PYTHON_PREFIX}_REGISTRY_PATHS VERSION ${_${_PYTHON_PREFIX}_VERSION})
1515
1516         # Virtual environments handling
1517         if (_${_PYTHON_PREFIX}_FIND_VIRTUALENV MATCHES "^(FIRST|ONLY)$")
1518           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1519                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1520                         NAMES_PER_DIR
1521                         HINTS ${_${_PYTHON_PREFIX}_HINTS}
1522                         PATHS ENV VIRTUAL_ENV ENV CONDA_PREFIX
1523                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1524                         NO_CMAKE_PATH
1525                         NO_CMAKE_ENVIRONMENT_PATH
1526                         NO_SYSTEM_ENVIRONMENT_PATH
1527                         NO_CMAKE_SYSTEM_PATH)
1528           _python_validate_interpreter (${_${_PYTHON_PREFIX}_VERSION} EXACT)
1529           if (_${_PYTHON_PREFIX}_EXECUTABLE)
1530             break()
1531           endif()
1532           if (_${_PYTHON_PREFIX}_FIND_VIRTUALENV STREQUAL "ONLY")
1533             continue()
1534           endif()
1535         endif()
1536
1537         # Apple frameworks handling
1538         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST")
1539           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1540                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1541                         NAMES_PER_DIR
1542                         HINTS ${_${_PYTHON_PREFIX}_HINTS}
1543                         PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
1544                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1545                         NO_CMAKE_PATH
1546                         NO_CMAKE_ENVIRONMENT_PATH
1547                         NO_SYSTEM_ENVIRONMENT_PATH
1548                         NO_CMAKE_SYSTEM_PATH)
1549         endif()
1550
1551         # Windows registry
1552         if (CMAKE_HOST_WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST")
1553           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1554                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1555                         NAMES_PER_DIR
1556                         HINTS ${_${_PYTHON_PREFIX}_HINTS}
1557                         PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
1558                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1559                         NO_SYSTEM_ENVIRONMENT_PATH
1560                         NO_CMAKE_SYSTEM_PATH)
1561         endif()
1562
1563         _python_validate_interpreter (${_${_PYTHON_PREFIX}_VERSION} EXACT)
1564         if (_${_PYTHON_PREFIX}_EXECUTABLE)
1565           break()
1566         endif()
1567
1568         # try using HINTS
1569         find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1570                       NAMES ${_${_PYTHON_PREFIX}_NAMES}
1571                       NAMES_PER_DIR
1572                       HINTS ${_${_PYTHON_PREFIX}_HINTS}
1573                       PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1574                       NO_SYSTEM_ENVIRONMENT_PATH
1575                       NO_CMAKE_SYSTEM_PATH)
1576         _python_validate_interpreter (${_${_PYTHON_PREFIX}_VERSION} EXACT)
1577         if (_${_PYTHON_PREFIX}_EXECUTABLE)
1578           break()
1579         endif()
1580         # try using standard paths.
1581         # NAMES_PER_DIR is not defined on purpose to have a chance to find
1582         # expected version.
1583         # For example, typical systems have 'python' for version 2.* and 'python3'
1584         # for version 3.*. So looking for names per dir will find, potentially,
1585         # systematically 'python' (i.e. version 2) even if version 3 is searched.
1586         find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1587                       NAMES ${_${_PYTHON_PREFIX}_NAMES}
1588                       PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES})
1589         _python_validate_interpreter (${_${_PYTHON_PREFIX}_VERSION} EXACT)
1590         if (_${_PYTHON_PREFIX}_EXECUTABLE)
1591           break()
1592         endif()
1593
1594         # Apple frameworks handling
1595         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST")
1596           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1597                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1598                         NAMES_PER_DIR
1599                         PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
1600                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1601                         NO_DEFAULT_PATH)
1602         endif()
1603
1604         # Windows registry
1605         if (CMAKE_HOST_WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST")
1606           find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1607                         NAMES ${_${_PYTHON_PREFIX}_NAMES}
1608                         NAMES_PER_DIR
1609                         PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
1610                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1611                         NO_DEFAULT_PATH)
1612         endif()
1613
1614         _python_validate_interpreter (${_${_PYTHON_PREFIX}_VERSION} EXACT)
1615         if (_${_PYTHON_PREFIX}_EXECUTABLE)
1616           break()
1617         endif()
1618       endforeach()
1619
1620       if (NOT _${_PYTHON_PREFIX}_EXECUTABLE AND
1621           NOT _${_PYTHON_PREFIX}_FIND_VIRTUALENV STREQUAL "ONLY")
1622         # No specific version found. Retry with generic names and standard paths.
1623         # NAMES_PER_DIR is not defined on purpose to have a chance to find
1624         # expected version.
1625         # For example, typical systems have 'python' for version 2.* and 'python3'
1626         # for version 3.*. So looking for names per dir will find, potentially,
1627         # systematically 'python' (i.e. version 2) even if version 3 is searched.
1628         _python_get_names (_${_PYTHON_PREFIX}_NAMES POSIX INTERPRETER)
1629         find_program (_${_PYTHON_PREFIX}_EXECUTABLE
1630                       NAMES ${_${_PYTHON_PREFIX}_NAMES})
1631         _python_validate_interpreter ()
1632       endif()
1633     endif()
1634   endif()
1635
1636   set (${_PYTHON_PREFIX}_EXECUTABLE "${_${_PYTHON_PREFIX}_EXECUTABLE}")
1637   _python_get_launcher (_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER INTERPRETER)
1638
1639   # retrieve exact version of executable found
1640   if (_${_PYTHON_PREFIX}_EXECUTABLE)
1641     execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
1642                              "import sys; sys.stdout.write('.'.join([str(x) for x in sys.version_info[:3]]))"
1643                      RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
1644                      OUTPUT_VARIABLE ${_PYTHON_PREFIX}_VERSION
1645                      ERROR_QUIET
1646                      OUTPUT_STRIP_TRAILING_WHITESPACE)
1647     if (NOT _${_PYTHON_PREFIX}_RESULT)
1648       set (_${_PYTHON_PREFIX}_EXECUTABLE_USABLE TRUE)
1649     else()
1650       # Interpreter is not usable
1651       set (_${_PYTHON_PREFIX}_EXECUTABLE_USABLE FALSE)
1652       unset (${_PYTHON_PREFIX}_VERSION)
1653       set (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE "Cannot run the interpreter \"${_${_PYTHON_PREFIX}_EXECUTABLE}\"")
1654     endif()
1655   endif()
1656
1657   if (_${_PYTHON_PREFIX}_EXECUTABLE AND _${_PYTHON_PREFIX}_EXECUTABLE_USABLE)
1658     if (_${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES)
1659       set (${_PYTHON_PREFIX}_Interpreter_FOUND TRUE)
1660
1661       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 0 ${_PYTHON_PREFIX}_INTERPRETER_ID)
1662
1663       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 1 ${_PYTHON_PREFIX}_VERSION_MAJOR)
1664       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 2 ${_PYTHON_PREFIX}_VERSION_MINOR)
1665       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 3 ${_PYTHON_PREFIX}_VERSION_PATCH)
1666
1667       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 4 _${_PYTHON_PREFIX}_ARCH)
1668       set (_${_PYTHON_PREFIX}_ARCH2 ${_${_PYTHON_PREFIX}_ARCH})
1669
1670       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 5 _${_PYTHON_PREFIX}_ABIFLAGS)
1671       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 6 ${_PYTHON_PREFIX}_SOABI)
1672
1673       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 7 ${_PYTHON_PREFIX}_STDLIB)
1674       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 8 ${_PYTHON_PREFIX}_STDARCH)
1675       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 9 ${_PYTHON_PREFIX}_SITELIB)
1676       list (GET _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES 10 ${_PYTHON_PREFIX}_SITEARCH)
1677     else()
1678       string (REGEX MATCHALL "[0-9]+" _${_PYTHON_PREFIX}_VERSIONS "${${_PYTHON_PREFIX}_VERSION}")
1679       list (GET _${_PYTHON_PREFIX}_VERSIONS 0 ${_PYTHON_PREFIX}_VERSION_MAJOR)
1680       list (GET _${_PYTHON_PREFIX}_VERSIONS 1 ${_PYTHON_PREFIX}_VERSION_MINOR)
1681       list (GET _${_PYTHON_PREFIX}_VERSIONS 2 ${_PYTHON_PREFIX}_VERSION_PATCH)
1682
1683       if (${_PYTHON_PREFIX}_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR)
1684         set (${_PYTHON_PREFIX}_Interpreter_FOUND TRUE)
1685
1686         # Use interpreter version and ABI for future searches to ensure consistency
1687         set (_${_PYTHON_PREFIX}_FIND_VERSIONS ${${_PYTHON_PREFIX}_VERSION_MAJOR}.${${_PYTHON_PREFIX}_VERSION_MINOR})
1688         execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETR_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
1689                                  "import sys; sys.stdout.write(sys.abiflags)"
1690                          RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
1691                          OUTPUT_VARIABLE _${_PYTHON_PREFIX}_ABIFLAGS
1692                          ERROR_QUIET
1693                          OUTPUT_STRIP_TRAILING_WHITESPACE)
1694         if (_${_PYTHON_PREFIX}_RESULT)
1695           # assunme ABI is not supported
1696           set (_${_PYTHON_PREFIX}_ABIFLAGS "")
1697         endif()
1698       endif()
1699
1700       if (${_PYTHON_PREFIX}_Interpreter_FOUND)
1701         unset (_${_PYTHON_PREFIX}_Interpreter_REASON_FAILURE)
1702
1703         # compute and save interpreter signature
1704         string (MD5 __${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE "${_${_PYTHON_PREFIX}_SIGNATURE}:${_${_PYTHON_PREFIX}_EXECUTABLE}")
1705         set (_${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE "${__${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE}" CACHE INTERNAL "")
1706
1707         if (NOT CMAKE_SIZEOF_VOID_P)
1708           # determine interpreter architecture
1709           execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
1710                                    "import sys; sys.stdout.write(str(sys.maxsize > 2**32))"
1711                            RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
1712                            OUTPUT_VARIABLE ${_PYTHON_PREFIX}_IS64BIT
1713                            ERROR_VARIABLE ${_PYTHON_PREFIX}_IS64BIT)
1714           if (NOT _${_PYTHON_PREFIX}_RESULT)
1715             if (${_PYTHON_PREFIX}_IS64BIT)
1716               set (_${_PYTHON_PREFIX}_ARCH 64)
1717               set (_${_PYTHON_PREFIX}_ARCH2 64)
1718             else()
1719               set (_${_PYTHON_PREFIX}_ARCH 32)
1720               set (_${_PYTHON_PREFIX}_ARCH2 32)
1721             endif()
1722           endif()
1723         endif()
1724
1725         # retrieve interpreter identity
1726         execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -V
1727                          RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
1728                          OUTPUT_VARIABLE ${_PYTHON_PREFIX}_INTERPRETER_ID
1729                          ERROR_VARIABLE ${_PYTHON_PREFIX}_INTERPRETER_ID)
1730         if (NOT _${_PYTHON_PREFIX}_RESULT)
1731           if (${_PYTHON_PREFIX}_INTERPRETER_ID MATCHES "Anaconda")
1732             set (${_PYTHON_PREFIX}_INTERPRETER_ID "Anaconda")
1733           elseif (${_PYTHON_PREFIX}_INTERPRETER_ID MATCHES "Enthought")
1734             set (${_PYTHON_PREFIX}_INTERPRETER_ID "Canopy")
1735           elseif (${_PYTHON_PREFIX}_INTERPRETER_ID MATCHES "PyPy ([0-9.]+)")
1736             set (${_PYTHON_PREFIX}_INTERPRETER_ID "PyPy")
1737             set  (${_PYTHON_PREFIX}_PyPy_VERSION "${CMAKE_MATCH_1}")
1738           else()
1739             string (REGEX REPLACE "^([^ ]+).*" "\\1" ${_PYTHON_PREFIX}_INTERPRETER_ID "${${_PYTHON_PREFIX}_INTERPRETER_ID}")
1740             if (${_PYTHON_PREFIX}_INTERPRETER_ID STREQUAL "Python")
1741               # try to get a more precise ID
1742               execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
1743                                        "import sys; sys.stdout.write(sys.copyright)"
1744                                RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
1745                                OUTPUT_VARIABLE ${_PYTHON_PREFIX}_COPYRIGHT
1746                                ERROR_QUIET)
1747               if (${_PYTHON_PREFIX}_COPYRIGHT MATCHES "ActiveState")
1748                 set (${_PYTHON_PREFIX}_INTERPRETER_ID "ActivePython")
1749               endif()
1750             endif()
1751           endif()
1752         else()
1753           set (${_PYTHON_PREFIX}_INTERPRETER_ID Python)
1754         endif()
1755
1756         # retrieve various package installation directories
1757         execute_process (COMMAND ${_${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
1758                                  "import sys\ntry:\n   from distutils import sysconfig\n   sys.stdout.write(';'.join([sysconfig.get_python_lib(plat_specific=False,standard_lib=True),sysconfig.get_python_lib(plat_specific=True,standard_lib=True),sysconfig.get_python_lib(plat_specific=False,standard_lib=False),sysconfig.get_python_lib(plat_specific=True,standard_lib=False)]))\nexcept Exception:\n   import sysconfig\n   sys.stdout.write(';'.join([sysconfig.get_path('stdlib'),sysconfig.get_path('platstdlib'),sysconfig.get_path('purelib'),sysconfig.get_path('platlib')]))"
1759                          RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
1760                          OUTPUT_VARIABLE _${_PYTHON_PREFIX}_LIBPATHS
1761                          ERROR_QUIET)
1762         if (NOT _${_PYTHON_PREFIX}_RESULT)
1763           list (GET _${_PYTHON_PREFIX}_LIBPATHS 0 ${_PYTHON_PREFIX}_STDLIB)
1764           list (GET _${_PYTHON_PREFIX}_LIBPATHS 1 ${_PYTHON_PREFIX}_STDARCH)
1765           list (GET _${_PYTHON_PREFIX}_LIBPATHS 2 ${_PYTHON_PREFIX}_SITELIB)
1766           list (GET _${_PYTHON_PREFIX}_LIBPATHS 3 ${_PYTHON_PREFIX}_SITEARCH)
1767         else()
1768           unset (${_PYTHON_PREFIX}_STDLIB)
1769           unset (${_PYTHON_PREFIX}_STDARCH)
1770           unset (${_PYTHON_PREFIX}_SITELIB)
1771           unset (${_PYTHON_PREFIX}_SITEARCH)
1772         endif()
1773
1774         if (_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR VERSION_GREATER_EQUAL "3")
1775           _python_get_config_var (${_PYTHON_PREFIX}_SOABI SOABI)
1776         endif()
1777
1778         # store properties in the cache to speed-up future searches
1779         set (_${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES
1780           "${${_PYTHON_PREFIX}_INTERPRETER_ID};${${_PYTHON_PREFIX}_VERSION_MAJOR};${${_PYTHON_PREFIX}_VERSION_MINOR};${${_PYTHON_PREFIX}_VERSION_PATCH};${_${_PYTHON_PREFIX}_ARCH};${_${_PYTHON_PREFIX}_ABIFLAGS};${${_PYTHON_PREFIX}_SOABI};${${_PYTHON_PREFIX}_STDLIB};${${_PYTHON_PREFIX}_STDARCH};${${_PYTHON_PREFIX}_SITELIB};${${_PYTHON_PREFIX}_SITEARCH}" CACHE INTERNAL "${_PYTHON_PREFIX} Properties")
1781       else()
1782         unset (_${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE CACHE)
1783         unset (${_PYTHON_PREFIX}_INTERPRETER_ID)
1784       endif()
1785     endif()
1786   endif()
1787
1788   if (${_PYTHON_PREFIX}_ARTIFACTS_INTERACTIVE)
1789     set (${_PYTHON_PREFIX}_EXECUTABLE "${_${_PYTHON_PREFIX}_EXECUTABLE}" CACHE FILEPATH "${_PYTHON_PREFIX} Interpreter")
1790   endif()
1791
1792   _python_mark_as_internal (_${_PYTHON_PREFIX}_EXECUTABLE
1793                             _${_PYTHON_PREFIX}_INTERPRETER_PROPERTIES
1794                             _${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE)
1795 endif()
1796
1797
1798 # second step, search for compiler (IronPython)
1799 if ("Compiler" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
1800   list (APPEND _${_PYTHON_PREFIX}_CACHED_VARS _${_PYTHON_PREFIX}_COMPILER)
1801   if (${_PYTHON_PREFIX}_FIND_REQUIRED_Compiler)
1802     list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_COMPILER)
1803   endif()
1804
1805   if (NOT "IronPython" IN_LIST _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS)
1806     unset (_${_PYTHON_PREFIX}_COMPILER CACHE)
1807     unset (_${_PYTHON_PREFIX}_COMPILER_SIGNATURE CACHE)
1808   elseif (DEFINED ${_PYTHON_PREFIX}_COMPILER
1809       AND IS_ABSOLUTE "${${_PYTHON_PREFIX}_COMPILER}")
1810     set (_${_PYTHON_PREFIX}_COMPILER "${${_PYTHON_PREFIX}_COMPILER}" CACHE INTERNAL "")
1811   elseif (DEFINED _${_PYTHON_PREFIX}_COMPILER)
1812     # compute compiler signature and check validity of definition
1813     string (MD5 __${_PYTHON_PREFIX}_COMPILER_SIGNATURE "${_${_PYTHON_PREFIX}_SIGNATURE}:${_${_PYTHON_PREFIX}_COMPILER}")
1814     if (__${_PYTHON_PREFIX}_COMPILER_SIGNATURE STREQUAL _${_PYTHON_PREFIX}_COMPILER_SIGNATURE)
1815       # check version validity
1816       if (${_PYTHON_PREFIX}_FIND_VERSION_EXACT)
1817         _python_validate_compiler (${${_PYTHON_PREFIX}_FIND_VERSION} EXACT CHECK_EXISTS)
1818       else()
1819         _python_validate_compiler (${${_PYTHON_PREFIX}_FIND_VERSION} CHECK_EXISTS)
1820       endif()
1821     else()
1822       unset (_${_PYTHON_PREFIX}_COMPILER CACHE)
1823       unset (_${_PYTHON_PREFIX}_COMPILER_SIGNATURE CACHE)
1824     endif()
1825   endif()
1826
1827   if ("IronPython" IN_LIST _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS
1828       AND NOT _${_PYTHON_PREFIX}_COMPILER)
1829     # IronPython specific artifacts
1830     # If IronPython interpreter is found, use its path
1831     unset (_${_PYTHON_PREFIX}_IRON_ROOT)
1832     if (${_PYTHON_PREFIX}_Interpreter_FOUND AND ${_PYTHON_PREFIX}_INTERPRETER_ID STREQUAL "IronPython")
1833       get_filename_component (_${_PYTHON_PREFIX}_IRON_ROOT "${${_PYTHON_PREFIX}_EXECUTABLE}" DIRECTORY)
1834     endif()
1835
1836     if (_${_PYTHON_PREFIX}_FIND_STRATEGY STREQUAL "LOCATION")
1837       _python_get_names (_${_PYTHON_PREFIX}_COMPILER_NAMES
1838                          IMPLEMENTATIONS IronPython
1839                          VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS}
1840                          COMPILER)
1841
1842       _python_get_path_suffixes (_${_PYTHON_PREFIX}_PATH_SUFFIXES
1843                                  IMPLEMENTATIONS IronPython
1844                                  VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS}
1845                                  COMPILER)
1846
1847       _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS
1848                               IMPLEMENTATIONS IronPython
1849                               VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS})
1850       _python_get_registries (_${_PYTHON_PREFIX}_REGISTRY_PATHS
1851                               IMPLEMENTATIONS IronPython
1852                               VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS})
1853
1854       while (TRUE)
1855         # Apple frameworks handling
1856         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST")
1857           find_program (_${_PYTHON_PREFIX}_COMPILER
1858                         NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
1859                         NAMES_PER_DIR
1860                         HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS}
1861                         PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
1862                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1863                         NO_CMAKE_PATH
1864                         NO_CMAKE_ENVIRONMENT_PATH
1865                         NO_SYSTEM_ENVIRONMENT_PATH
1866                         NO_CMAKE_SYSTEM_PATH)
1867           _python_validate_compiler (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1868           if (_${_PYTHON_PREFIX}_COMPILER)
1869             break()
1870           endif()
1871         endif()
1872         # Windows registry
1873         if (CMAKE_HOST_WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST")
1874           find_program (_${_PYTHON_PREFIX}_COMPILER
1875                         NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
1876                         NAMES_PER_DIR
1877                         HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS}
1878                         PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
1879                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1880                         NO_SYSTEM_ENVIRONMENT_PATH
1881                         NO_CMAKE_SYSTEM_PATH)
1882           _python_validate_compiler (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1883           if (_${_PYTHON_PREFIX}_COMPILER)
1884             break()
1885           endif()
1886         endif()
1887
1888         # try using HINTS
1889         find_program (_${_PYTHON_PREFIX}_COMPILER
1890                       NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
1891                       NAMES_PER_DIR
1892                       HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS}
1893                       PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1894                       NO_SYSTEM_ENVIRONMENT_PATH
1895                       NO_CMAKE_SYSTEM_PATH)
1896         _python_validate_compiler (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1897         if (_${_PYTHON_PREFIX}_COMPILER)
1898           break()
1899         endif()
1900
1901         # try using standard paths
1902         find_program (_${_PYTHON_PREFIX}_COMPILER
1903                       NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
1904                       NAMES_PER_DIR
1905                       PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES})
1906         _python_validate_compiler (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1907         if (_${_PYTHON_PREFIX}_COMPILER)
1908           break()
1909         endif()
1910
1911         # Apple frameworks handling
1912         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST")
1913           find_program (_${_PYTHON_PREFIX}_COMPILER
1914                         NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
1915                         NAMES_PER_DIR
1916                         PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
1917                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1918                         NO_DEFAULT_PATH)
1919           _python_validate_compiler (${${_PYTHON_PREFIX}_FIND_VERSION} ${_${_PYTHON_PREFIX}_FIND_VERSION_EXACT})
1920           if (_${_PYTHON_PREFIX}_COMPILER)
1921             break()
1922           endif()
1923         endif()
1924         # Windows registry
1925         if (CMAKE_HOST_WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST")
1926           find_program (_${_PYTHON_PREFIX}_COMPILER
1927                         NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
1928                         NAMES_PER_DIR
1929                         PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
1930                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1931                         NO_DEFAULT_PATH)
1932           if (_${_PYTHON_PREFIX}_COMPILER)
1933             break()
1934           endif()
1935         endif()
1936
1937         break()
1938       endwhile()
1939     else()
1940       # try using root dir and registry
1941       foreach (_${_PYTHON_PREFIX}_VERSION IN LISTS _${_PYTHON_PREFIX}_FIND_VERSIONS)
1942         _python_get_names (_${_PYTHON_PREFIX}_COMPILER_NAMES
1943                            IMPLEMENTATIONS IronPython
1944                            VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS}
1945                            COMPILER)
1946
1947         _python_get_path_suffixes (_${_PYTHON_PREFIX}_PATH_SUFFIXES
1948                                    IMPLEMENTATIONS IronPython
1949                                    VERSION ${_${_PYTHON_PREFIX}_FIND_VERSION}
1950                                    COMPILER)
1951
1952         _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS
1953                                 IMPLEMENTATIONS IronPython
1954                                 VERSION ${_${_PYTHON_PREFIX}_VERSION})
1955         _python_get_registries (_${_PYTHON_PREFIX}_REGISTRY_PATHS
1956                                 IMPLEMENTATIONS IronPython
1957                                 VERSION ${_${_PYTHON_PREFIX}_VERSION})
1958
1959         # Apple frameworks handling
1960         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST")
1961           find_program (_${_PYTHON_PREFIX}_COMPILER
1962                         NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
1963                         NAMES_PER_DIR
1964                         HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS}
1965                         PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
1966                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1967                         NO_CMAKE_PATH
1968                         NO_CMAKE_ENVIRONMENT_PATH
1969                         NO_SYSTEM_ENVIRONMENT_PATH
1970                         NO_CMAKE_SYSTEM_PATH)
1971           _python_validate_compiler (${_${_PYTHON_PREFIX}_VERSION} EXACT)
1972           if (_${_PYTHON_PREFIX}_COMPILER)
1973             break()
1974           endif()
1975         endif()
1976         # Windows registry
1977         if (CMAKE_HOST_WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST")
1978           find_program (_${_PYTHON_PREFIX}_COMPILER
1979                         NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
1980                         NAMES_PER_DIR
1981                         HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS}
1982                         PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
1983                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1984                         NO_SYSTEM_ENVIRONMENT_PATH
1985                         NO_CMAKE_SYSTEM_PATH)
1986           _python_validate_compiler (${_${_PYTHON_PREFIX}_VERSION} EXACT)
1987           if (_${_PYTHON_PREFIX}_COMPILER)
1988             break()
1989           endif()
1990         endif()
1991
1992         # try using HINTS
1993         find_program (_${_PYTHON_PREFIX}_COMPILER
1994                       NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
1995                       NAMES_PER_DIR
1996                       HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS}
1997                       PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
1998                       NO_SYSTEM_ENVIRONMENT_PATH
1999                       NO_CMAKE_SYSTEM_PATH)
2000         _python_validate_compiler (${_${_PYTHON_PREFIX}_VERSION} EXACT)
2001         if (_${_PYTHON_PREFIX}_COMPILER)
2002           break()
2003         endif()
2004
2005         # Apple frameworks handling
2006         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST")
2007           find_program (_${_PYTHON_PREFIX}_COMPILER
2008                         NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
2009                         NAMES_PER_DIR
2010                         PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2011                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2012                         NO_DEFAULT_PATH)
2013           _python_validate_compiler (${_${_PYTHON_PREFIX}_VERSION} EXACT)
2014           if (_${_PYTHON_PREFIX}_COMPILER)
2015             break()
2016           endif()
2017         endif()
2018         # Windows registry
2019         if (CMAKE_HOST_WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST")
2020           find_program (_${_PYTHON_PREFIX}_COMPILER
2021                         NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
2022                         NAMES_PER_DIR
2023                         PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
2024                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2025                         NO_DEFAULT_PATH)
2026           _python_validate_compiler (${_${_PYTHON_PREFIX}_VERSION} EXACT)
2027           if (_${_PYTHON_PREFIX}_COMPILER)
2028             break()
2029           endif()
2030         endif()
2031       endforeach()
2032
2033       # no specific version found, re-try in standard paths
2034       _python_get_names (_${_PYTHON_PREFIX}_COMPILER_NAMES
2035                          IMPLEMENTATIONS IronPython
2036                          VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS}
2037                          COMPILER)
2038       _python_get_path_suffixes (_${_PYTHON_PREFIX}_PATH_SUFFIXES
2039                                  IMPLEMENTATIONS IronPython
2040                                  VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS}
2041                                  COMPILER)
2042       find_program (_${_PYTHON_PREFIX}_COMPILER
2043                     NAMES ${_${_PYTHON_PREFIX}_COMPILER_NAMES}
2044                     HINTS ${_${_PYTHON_PREFIX}_IRON_ROOT} ${_${_PYTHON_PREFIX}_HINTS}
2045                     PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES})
2046     endif()
2047   endif()
2048
2049   set (${_PYTHON_PREFIX}_COMPILER "${_${_PYTHON_PREFIX}_COMPILER}")
2050
2051   if (_${_PYTHON_PREFIX}_COMPILER)
2052     # retrieve python environment version from compiler
2053     _python_get_launcher (_${_PYTHON_PREFIX}_COMPILER_LAUNCHER COMPILER)
2054     set (_${_PYTHON_PREFIX}_VERSION_DIR "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/PythonCompilerVersion.dir")
2055     file (WRITE "${_${_PYTHON_PREFIX}_VERSION_DIR}/version.py" "import sys; sys.stdout.write('.'.join([str(x) for x in sys.version_info[:3]]))\n")
2056     execute_process (COMMAND ${_${_PYTHON_PREFIX}_COMPILER_LAUNCHER} "${_${_PYTHON_PREFIX}_COMPILER}"
2057                              ${_${_PYTHON_PREFIX}_IRON_PYTHON_COMPILER_ARCH_FLAGS}
2058                              /target:exe /embed "${_${_PYTHON_PREFIX}_VERSION_DIR}/version.py"
2059                      WORKING_DIRECTORY "${_${_PYTHON_PREFIX}_VERSION_DIR}"
2060                      OUTPUT_QUIET
2061                      ERROR_QUIET)
2062     get_filename_component (_${_PYTHON_PREFIX}_IR_DIR "${_${_PYTHON_PREFIX}_COMPILER}" DIRECTORY)
2063     execute_process (COMMAND "${CMAKE_COMMAND}" -E env "MONO_PATH=${_${_PYTHON_PREFIX}_IR_DIR}"
2064                              ${${_PYTHON_PREFIX}_DOTNET_LAUNCHER} "${_${_PYTHON_PREFIX}_VERSION_DIR}/version.exe"
2065                      WORKING_DIRECTORY "${_${_PYTHON_PREFIX}_VERSION_DIR}"
2066                      RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
2067                      OUTPUT_VARIABLE _${_PYTHON_PREFIX}_VERSION
2068                      ERROR_QUIET)
2069     if (NOT _${_PYTHON_PREFIX}_RESULT)
2070       set (_${_PYTHON_PREFIX}_COMPILER_USABLE TRUE)
2071       string (REGEX MATCHALL "[0-9]+" _${_PYTHON_PREFIX}_VERSIONS "${_${_PYTHON_PREFIX}_VERSION}")
2072       list (GET _${_PYTHON_PREFIX}_VERSIONS 0 _${_PYTHON_PREFIX}_VERSION_MAJOR)
2073       list (GET _${_PYTHON_PREFIX}_VERSIONS 1 _${_PYTHON_PREFIX}_VERSION_MINOR)
2074       list (GET _${_PYTHON_PREFIX}_VERSIONS 2 _${_PYTHON_PREFIX}_VERSION_PATCH)
2075
2076       if (NOT ${_PYTHON_PREFIX}_Interpreter_FOUND)
2077         # set public version information
2078         set (${_PYTHON_PREFIX}_VERSION ${_${_PYTHON_PREFIX}_VERSION})
2079         set (${_PYTHON_PREFIX}_VERSION_MAJOR ${_${_PYTHON_PREFIX}_VERSION_MAJOR})
2080         set (${_PYTHON_PREFIX}_VERSION_MINOR ${_${_PYTHON_PREFIX}_VERSION_MINOR})
2081         set (${_PYTHON_PREFIX}_VERSION_PATCH ${_${_PYTHON_PREFIX}_VERSION_PATCH})
2082       endif()
2083     else()
2084       # compiler not usable
2085       set (_${_PYTHON_PREFIX}_COMPILER_USABLE FALSE)
2086       set (_${_PYTHON_PREFIX}_Compiler_REASON_FAILURE "Cannot run the compiler \"${_${_PYTHON_PREFIX}_COMPILER}\"")
2087     endif()
2088     file (REMOVE_RECURSE "${_${_PYTHON_PREFIX}_VERSION_DIR}")
2089   endif()
2090
2091   if (_${_PYTHON_PREFIX}_COMPILER AND _${_PYTHON_PREFIX}_COMPILER_USABLE)
2092     if (${_PYTHON_PREFIX}_Interpreter_FOUND)
2093       # Compiler must be compatible with interpreter
2094       if ("${_${_PYTHON_PREFIX}_VERSION_MAJOR}.${_${_PYTHON_PREFIX}_VERSION_MINOR}" VERSION_EQUAL "${${_PYTHON_PREFIX}_VERSION_MAJOR}.${${_PYTHON_PREFIX}_VERSION_MINOR}")
2095         set (${_PYTHON_PREFIX}_Compiler_FOUND TRUE)
2096       endif()
2097     elseif (${_PYTHON_PREFIX}_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR)
2098       set (${_PYTHON_PREFIX}_Compiler_FOUND TRUE)
2099       # Use compiler version for future searches to ensure consistency
2100       set (_${_PYTHON_PREFIX}_FIND_VERSIONS ${${_PYTHON_PREFIX}_VERSION_MAJOR}.${${_PYTHON_PREFIX}_VERSION_MINOR})
2101     endif()
2102   endif()
2103
2104   if (${_PYTHON_PREFIX}_Compiler_FOUND)
2105     unset (_${_PYTHON_PREFIX}_Compiler_REASON_FAILURE)
2106
2107     # compute and save compiler signature
2108     string (MD5 __${_PYTHON_PREFIX}_COMPILER_SIGNATURE "${_${_PYTHON_PREFIX}_SIGNATURE}:${_${_PYTHON_PREFIX}_COMPILER}")
2109     set (_${_PYTHON_PREFIX}_COMPILER_SIGNATURE "${__${_PYTHON_PREFIX}_COMPILER_SIGNATURE}" CACHE INTERNAL "")
2110
2111     set (${_PYTHON_PREFIX}_COMPILER_ID IronPython)
2112   else()
2113     unset (_${_PYTHON_PREFIX}_COMPILER_SIGNATURE CACHE)
2114     unset (${_PYTHON_PREFIX}_COMPILER_ID)
2115   endif()
2116
2117   if (${_PYTHON_PREFIX}_ARTIFACTS_INTERACTIVE)
2118     set (${_PYTHON_PREFIX}_COMPILER "${_${_PYTHON_PREFIX}_COMPILER}" CACHE FILEPATH "${_PYTHON_PREFIX} Compiler")
2119   endif()
2120
2121   _python_mark_as_internal (_${_PYTHON_PREFIX}_COMPILER
2122                             _${_PYTHON_PREFIX}_COMPILER_SIGNATURE)
2123 endif()
2124
2125 # third step, search for the development artifacts
2126 if (${_PYTHON_PREFIX}_FIND_REQUIRED_Development.Module)
2127   if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_MODULE_ARTIFACTS)
2128     list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_LIBRARIES)
2129   endif()
2130   if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_MODULE_ARTIFACTS)
2131     list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_INCLUDE_DIRS)
2132   endif()
2133 endif()
2134 if (${_PYTHON_PREFIX}_FIND_REQUIRED_Development.Embed)
2135   if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_EMBED_ARTIFACTS)
2136     list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_LIBRARIES)
2137   endif()
2138   if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_EMBED_ARTIFACTS)
2139     list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_INCLUDE_DIRS)
2140   endif()
2141 endif()
2142 list (REMOVE_DUPLICATES _${_PYTHON_PREFIX}_REQUIRED_VARS)
2143 ## Development environment is not compatible with IronPython interpreter
2144 if (("Development.Module" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS
2145       OR "Development.Embed" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS)
2146     AND ((${_PYTHON_PREFIX}_Interpreter_FOUND
2147         AND NOT ${_PYTHON_PREFIX}_INTERPRETER_ID STREQUAL "IronPython")
2148       OR NOT ${_PYTHON_PREFIX}_Interpreter_FOUND))
2149   if (${_PYTHON_PREFIX}_Interpreter_FOUND)
2150     # reduce possible implementations to the interpreter one
2151     if (${_PYTHON_PREFIX}_INTERPRETER_ID STREQUAL "PyPy")
2152       set (_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS "PyPy")
2153     else()
2154       set (_${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS "CPython")
2155     endif()
2156   else()
2157     list (REMOVE_ITEM _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS "IronPython")
2158   endif()
2159   if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS)
2160   list (APPEND _${_PYTHON_PREFIX}_CACHED_VARS _${_PYTHON_PREFIX}_LIBRARY_RELEASE
2161                                               _${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE
2162                                               _${_PYTHON_PREFIX}_LIBRARY_DEBUG
2163                                               _${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG)
2164   endif()
2165   if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS)
2166     list (APPEND _${_PYTHON_PREFIX}_CACHED_VARS _${_PYTHON_PREFIX}_INCLUDE_DIR)
2167   endif()
2168
2169   _python_check_development_signature (Module)
2170   _python_check_development_signature (Embed)
2171
2172   if (DEFINED ${_PYTHON_PREFIX}_LIBRARY
2173       AND IS_ABSOLUTE "${${_PYTHON_PREFIX}_LIBRARY}")
2174     set (_${_PYTHON_PREFIX}_LIBRARY_RELEASE "${${_PYTHON_PREFIX}_LIBRARY}" CACHE INTERNAL "")
2175     unset (_${_PYTHON_PREFIX}_LIBRARY_DEBUG CACHE)
2176     unset (_${_PYTHON_PREFIX}_INCLUDE_DIR CACHE)
2177   endif()
2178   if (DEFINED ${_PYTHON_PREFIX}_INCLUDE_DIR
2179       AND IS_ABSOLUTE "${${_PYTHON_PREFIX}_INCLUDE_DIR}")
2180     set (_${_PYTHON_PREFIX}_INCLUDE_DIR "${${_PYTHON_PREFIX}_INCLUDE_DIR}" CACHE INTERNAL "")
2181   endif()
2182
2183   # Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES
2184   unset (_${_PYTHON_PREFIX}_CMAKE_FIND_LIBRARY_SUFFIXES)
2185   if (DEFINED ${_PYTHON_PREFIX}_USE_STATIC_LIBS AND NOT WIN32)
2186     set(_${_PYTHON_PREFIX}_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
2187     if(${_PYTHON_PREFIX}_USE_STATIC_LIBS)
2188       set (CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
2189     else()
2190       list (REMOVE_ITEM CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX})
2191     endif()
2192   endif()
2193
2194   if (NOT _${_PYTHON_PREFIX}_LIBRARY_RELEASE OR NOT _${_PYTHON_PREFIX}_INCLUDE_DIR)
2195     # if python interpreter is found, use it to look-up for artifacts
2196     # to ensure consistency between interpreter and development environments.
2197     # If not, try to locate a compatible config tool
2198     if ((NOT ${_PYTHON_PREFIX}_Interpreter_FOUND OR CMAKE_CROSSCOMPILING)
2199         AND "CPython" IN_LIST _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS)
2200       set (_${_PYTHON_PREFIX}_HINTS "${${_PYTHON_PREFIX}_ROOT_DIR}" ENV ${_PYTHON_PREFIX}_ROOT_DIR)
2201       unset (_${_PYTHON_PREFIX}_VIRTUALENV_PATHS)
2202       if (_${_PYTHON_PREFIX}_FIND_VIRTUALENV MATCHES "^(FIRST|ONLY)$")
2203         set (_${_PYTHON_PREFIX}_VIRTUALENV_PATHS ENV VIRTUAL_ENV ENV CONDA_PREFIX)
2204       endif()
2205
2206       if (_${_PYTHON_PREFIX}_FIND_STRATEGY STREQUAL "LOCATION")
2207         _python_get_names (_${_PYTHON_PREFIX}_CONFIG_NAMES VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS} POSIX CONFIG)
2208           # Framework Paths
2209         _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS})
2210
2211         # Apple frameworks handling
2212         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST")
2213           find_program (_${_PYTHON_PREFIX}_CONFIG
2214                         NAMES ${_${_PYTHON_PREFIX}_CONFIG_NAMES}
2215                         NAMES_PER_DIR
2216                         HINTS ${_${_PYTHON_PREFIX}_HINTS}
2217                         PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2218                               ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2219                         PATH_SUFFIXES bin
2220                         NO_CMAKE_PATH
2221                         NO_CMAKE_ENVIRONMENT_PATH
2222                         NO_SYSTEM_ENVIRONMENT_PATH
2223                         NO_CMAKE_SYSTEM_PATH)
2224         endif()
2225
2226         find_program (_${_PYTHON_PREFIX}_CONFIG
2227                       NAMES ${_${_PYTHON_PREFIX}_CONFIG_NAMES}
2228                       NAMES_PER_DIR
2229                       HINTS ${_${_PYTHON_PREFIX}_HINTS}
2230                       PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2231                       PATH_SUFFIXES bin)
2232
2233         # Apple frameworks handling
2234         if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST")
2235           find_program (_${_PYTHON_PREFIX}_CONFIG
2236                         NAMES ${_${_PYTHON_PREFIX}_CONFIG_NAMES}
2237                         NAMES_PER_DIR
2238                         PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2239                         PATH_SUFFIXES bin
2240                         NO_DEFAULT_PATH)
2241         endif()
2242
2243         if (_${_PYTHON_PREFIX}_CONFIG)
2244           execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --help
2245                            RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
2246                            OUTPUT_VARIABLE __${_PYTHON_PREFIX}_HELP
2247                            ERROR_QUIET
2248                            OUTPUT_STRIP_TRAILING_WHITESPACE)
2249           if (_${_PYTHON_PREFIX}_RESULT)
2250             # assume config tool is not usable
2251             unset (_${_PYTHON_PREFIX}_CONFIG CACHE)
2252           endif()
2253         endif()
2254
2255         if (_${_PYTHON_PREFIX}_CONFIG)
2256           execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --abiflags
2257                            RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
2258                            OUTPUT_VARIABLE __${_PYTHON_PREFIX}_ABIFLAGS
2259                            ERROR_QUIET
2260                            OUTPUT_STRIP_TRAILING_WHITESPACE)
2261           if (_${_PYTHON_PREFIX}_RESULT)
2262             # assume ABI is not supported
2263             set (__${_PYTHON_PREFIX}_ABIFLAGS "")
2264           endif()
2265           if (DEFINED _${_PYTHON_PREFIX}_FIND_ABI AND NOT __${_PYTHON_PREFIX}_ABIFLAGS IN_LIST _${_PYTHON_PREFIX}_ABIFLAGS)
2266             # Wrong ABI
2267             unset (_${_PYTHON_PREFIX}_CONFIG CACHE)
2268           endif()
2269         endif()
2270
2271         if (_${_PYTHON_PREFIX}_CONFIG AND DEFINED CMAKE_LIBRARY_ARCHITECTURE)
2272           # check that config tool match library architecture
2273           execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --configdir
2274                            RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
2275                            OUTPUT_VARIABLE _${_PYTHON_PREFIX}_CONFIGDIR
2276                            ERROR_QUIET
2277                            OUTPUT_STRIP_TRAILING_WHITESPACE)
2278           if (_${_PYTHON_PREFIX}_RESULT)
2279             unset (_${_PYTHON_PREFIX}_CONFIG CACHE)
2280           else()
2281             string(FIND "${_${_PYTHON_PREFIX}_CONFIGDIR}" "${CMAKE_LIBRARY_ARCHITECTURE}" _${_PYTHON_PREFIX}_RESULT)
2282             if (_${_PYTHON_PREFIX}_RESULT EQUAL -1)
2283               unset (_${_PYTHON_PREFIX}_CONFIG CACHE)
2284             endif()
2285           endif()
2286         endif()
2287       else()
2288         foreach (_${_PYTHON_PREFIX}_VERSION IN LISTS _${_PYTHON_PREFIX}_FIND_VERSIONS)
2289           # try to use pythonX.Y-config tool
2290           _python_get_names (_${_PYTHON_PREFIX}_CONFIG_NAMES VERSION ${_${_PYTHON_PREFIX}_VERSION} POSIX CONFIG)
2291
2292           # Framework Paths
2293           _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS VERSION ${_${_PYTHON_PREFIX}_VERSION})
2294
2295           # Apple frameworks handling
2296           if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST")
2297             find_program (_${_PYTHON_PREFIX}_CONFIG
2298                           NAMES ${_${_PYTHON_PREFIX}_CONFIG_NAMES}
2299                           NAMES_PER_DIR
2300                           HINTS ${_${_PYTHON_PREFIX}_HINTS}
2301                           PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2302                                 ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2303                           PATH_SUFFIXES bin
2304                           NO_CMAKE_PATH
2305                           NO_CMAKE_ENVIRONMENT_PATH
2306                           NO_SYSTEM_ENVIRONMENT_PATH
2307                           NO_CMAKE_SYSTEM_PATH)
2308           endif()
2309
2310           find_program (_${_PYTHON_PREFIX}_CONFIG
2311                         NAMES ${_${_PYTHON_PREFIX}_CONFIG_NAMES}
2312                         NAMES_PER_DIR
2313                         HINTS ${_${_PYTHON_PREFIX}_HINTS}
2314                         PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2315                         PATH_SUFFIXES bin)
2316
2317           # Apple frameworks handling
2318           if (CMAKE_HOST_APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST")
2319             find_program (_${_PYTHON_PREFIX}_CONFIG
2320                           NAMES ${_${_PYTHON_PREFIX}_CONFIG_NAMES}
2321                           NAMES_PER_DIR
2322                           PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2323                           PATH_SUFFIXES bin
2324                           NO_DEFAULT_PATH)
2325           endif()
2326
2327           unset (_${_PYTHON_PREFIX}_CONFIG_NAMES)
2328
2329           if (_${_PYTHON_PREFIX}_CONFIG)
2330             execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --help
2331                              RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
2332                              OUTPUT_VARIABLE __${_PYTHON_PREFIX}_HELP
2333                              ERROR_QUIET
2334                              OUTPUT_STRIP_TRAILING_WHITESPACE)
2335             if (_${_PYTHON_PREFIX}_RESULT)
2336               # assume config tool is not usable
2337               unset (_${_PYTHON_PREFIX}_CONFIG CACHE)
2338             endif()
2339           endif()
2340
2341           if (NOT _${_PYTHON_PREFIX}_CONFIG)
2342             continue()
2343           endif()
2344
2345           execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --abiflags
2346                            RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
2347                            OUTPUT_VARIABLE __${_PYTHON_PREFIX}_ABIFLAGS
2348                            ERROR_QUIET
2349                            OUTPUT_STRIP_TRAILING_WHITESPACE)
2350           if (_${_PYTHON_PREFIX}_RESULT)
2351             # assume ABI is not supported
2352             set (__${_PYTHON_PREFIX}_ABIFLAGS "")
2353           endif()
2354           if (DEFINED _${_PYTHON_PREFIX}_FIND_ABI AND NOT __${_PYTHON_PREFIX}_ABIFLAGS IN_LIST _${_PYTHON_PREFIX}_ABIFLAGS)
2355             # Wrong ABI
2356             unset (_${_PYTHON_PREFIX}_CONFIG CACHE)
2357             continue()
2358           endif()
2359
2360           if (_${_PYTHON_PREFIX}_CONFIG AND DEFINED CMAKE_LIBRARY_ARCHITECTURE)
2361             # check that config tool match library architecture
2362             execute_process (COMMAND "${_${_PYTHON_PREFIX}_CONFIG}" --configdir
2363                              RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
2364                              OUTPUT_VARIABLE _${_PYTHON_PREFIX}_CONFIGDIR
2365                              ERROR_QUIET
2366                              OUTPUT_STRIP_TRAILING_WHITESPACE)
2367             if (_${_PYTHON_PREFIX}_RESULT)
2368               unset (_${_PYTHON_PREFIX}_CONFIG CACHE)
2369               continue()
2370             endif()
2371             string (FIND "${_${_PYTHON_PREFIX}_CONFIGDIR}" "${CMAKE_LIBRARY_ARCHITECTURE}" _${_PYTHON_PREFIX}_RESULT)
2372             if (_${_PYTHON_PREFIX}_RESULT EQUAL -1)
2373               unset (_${_PYTHON_PREFIX}_CONFIG CACHE)
2374               continue()
2375             endif()
2376           endif()
2377
2378           if (_${_PYTHON_PREFIX}_CONFIG)
2379             break()
2380           endif()
2381         endforeach()
2382       endif()
2383     endif()
2384   endif()
2385
2386   if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS)
2387     if (NOT _${_PYTHON_PREFIX}_LIBRARY_RELEASE)
2388       if ((${_PYTHON_PREFIX}_Interpreter_FOUND AND NOT CMAKE_CROSSCOMPILING) OR _${_PYTHON_PREFIX}_CONFIG)
2389         # retrieve root install directory
2390         _python_get_config_var (_${_PYTHON_PREFIX}_PREFIX PREFIX)
2391
2392         # enforce current ABI
2393         _python_get_config_var (_${_PYTHON_PREFIX}_ABIFLAGS ABIFLAGS)
2394
2395         set (_${_PYTHON_PREFIX}_HINTS "${_${_PYTHON_PREFIX}_PREFIX}")
2396
2397         # retrieve library
2398         ## compute some paths and artifact names
2399         if (_${_PYTHON_PREFIX}_CONFIG)
2400           string (REGEX REPLACE "^.+python([0-9.]+)[a-z]*-config" "\\1" _${_PYTHON_PREFIX}_VERSION "${_${_PYTHON_PREFIX}_CONFIG}")
2401         else()
2402           set (_${_PYTHON_PREFIX}_VERSION "${${_PYTHON_PREFIX}_VERSION_MAJOR}.${${_PYTHON_PREFIX}_VERSION_MINOR}")
2403         endif()
2404         _python_get_path_suffixes (_${_PYTHON_PREFIX}_PATH_SUFFIXES VERSION ${_${_PYTHON_PREFIX}_VERSION} LIBRARY)
2405         _python_get_names (_${_PYTHON_PREFIX}_LIB_NAMES VERSION ${_${_PYTHON_PREFIX}_VERSION} WIN32 POSIX LIBRARY)
2406
2407         _python_get_config_var (_${_PYTHON_PREFIX}_CONFIGDIR CONFIGDIR)
2408         list (APPEND _${_PYTHON_PREFIX}_HINTS "${_${_PYTHON_PREFIX}_CONFIGDIR}")
2409
2410         list (APPEND _${_PYTHON_PREFIX}_HINTS "${${_PYTHON_PREFIX}_ROOT_DIR}" ENV ${_PYTHON_PREFIX}_ROOT_DIR)
2411
2412         find_library (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2413                       NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2414                       NAMES_PER_DIR
2415                       HINTS ${_${_PYTHON_PREFIX}_HINTS}
2416                       PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2417                       NO_SYSTEM_ENVIRONMENT_PATH
2418                       NO_CMAKE_SYSTEM_PATH)
2419       endif()
2420
2421       # Rely on HINTS and standard paths if interpreter or config tool failed to locate artifacts
2422       if (NOT _${_PYTHON_PREFIX}_LIBRARY_RELEASE)
2423         set (_${_PYTHON_PREFIX}_HINTS "${${_PYTHON_PREFIX}_ROOT_DIR}" ENV ${_PYTHON_PREFIX}_ROOT_DIR)
2424
2425         unset (_${_PYTHON_PREFIX}_VIRTUALENV_PATHS)
2426         if (_${_PYTHON_PREFIX}_FIND_VIRTUALENV MATCHES "^(FIRST|ONLY)$")
2427           set (_${_PYTHON_PREFIX}_VIRTUALENV_PATHS ENV VIRTUAL_ENV ENV CONDA_PREFIX)
2428         endif()
2429
2430         if (_${_PYTHON_PREFIX}_FIND_STRATEGY STREQUAL "LOCATION")
2431           # library names
2432           _python_get_names (_${_PYTHON_PREFIX}_LIB_NAMES VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS} WIN32 POSIX LIBRARY)
2433           _python_get_names (_${_PYTHON_PREFIX}_LIB_NAMES_DEBUG VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS} WIN32 DEBUG)
2434           # Paths suffixes
2435           _python_get_path_suffixes (_${_PYTHON_PREFIX}_PATH_SUFFIXES VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS} LIBRARY)
2436
2437           # Framework Paths
2438           _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS VERSION ${_${_PYTHON_PREFIX}_LIB_FIND_VERSIONS})
2439           # Registry Paths
2440           _python_get_registries (_${_PYTHON_PREFIX}_REGISTRY_PATHS VERSION ${_${_PYTHON_PREFIX}_FIND_VERSIONS} )
2441
2442           if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST")
2443             find_library (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2444                           NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2445                           NAMES_PER_DIR
2446                           HINTS ${_${_PYTHON_PREFIX}_HINTS}
2447                           PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2448                                 ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2449                           PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2450                           NO_CMAKE_PATH
2451                           NO_CMAKE_ENVIRONMENT_PATH
2452                           NO_SYSTEM_ENVIRONMENT_PATH
2453                           NO_CMAKE_SYSTEM_PATH)
2454           endif()
2455
2456           if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST")
2457             find_library (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2458                           NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2459                           NAMES_PER_DIR
2460                           HINTS ${_${_PYTHON_PREFIX}_HINTS}
2461                           PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2462                                 ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
2463                           PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2464                           NO_SYSTEM_ENVIRONMENT_PATH
2465                           NO_CMAKE_SYSTEM_PATH)
2466           endif()
2467
2468           # search in HINTS locations
2469           find_library (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2470                         NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2471                         NAMES_PER_DIR
2472                         HINTS ${_${_PYTHON_PREFIX}_HINTS}
2473                         PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2474                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2475                         NO_SYSTEM_ENVIRONMENT_PATH
2476                         NO_CMAKE_SYSTEM_PATH)
2477
2478           if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST")
2479             set (__${_PYTHON_PREFIX}_FRAMEWORK_PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS})
2480           else()
2481             unset (__${_PYTHON_PREFIX}_FRAMEWORK_PATHS)
2482           endif()
2483
2484           if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST")
2485             set (__${_PYTHON_PREFIX}_REGISTRY_PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS})
2486           else()
2487             unset (__${_PYTHON_PREFIX}_REGISTRY_PATHS)
2488           endif()
2489
2490           # search in all default paths
2491           find_library (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2492                         NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2493                         NAMES_PER_DIR
2494                         PATHS ${__${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2495                               ${__${_PYTHON_PREFIX}_REGISTRY_PATHS}
2496                         PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES})
2497         else()
2498           foreach (_${_PYTHON_PREFIX}_LIB_VERSION IN LISTS _${_PYTHON_PREFIX}_FIND_VERSIONS)
2499             _python_get_names (_${_PYTHON_PREFIX}_LIB_NAMES VERSION ${_${_PYTHON_PREFIX}_LIB_VERSION} WIN32 POSIX LIBRARY)
2500             _python_get_names (_${_PYTHON_PREFIX}_LIB_NAMES_DEBUG VERSION ${_${_PYTHON_PREFIX}_LIB_VERSION} WIN32 DEBUG)
2501
2502             _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS VERSION ${_${_PYTHON_PREFIX}_LIB_VERSION})
2503             _python_get_registries (_${_PYTHON_PREFIX}_REGISTRY_PATHS VERSION ${_${_PYTHON_PREFIX}_LIB_VERSION})
2504
2505             _python_get_path_suffixes (_${_PYTHON_PREFIX}_PATH_SUFFIXES VERSION ${_${_PYTHON_PREFIX}_LIB_VERSION} LIBRARY)
2506
2507             if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST")
2508               find_library (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2509                             NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2510                             NAMES_PER_DIR
2511                             HINTS ${_${_PYTHON_PREFIX}_HINTS}
2512                             PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2513                                   ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2514                             PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2515                             NO_CMAKE_PATH
2516                             NO_CMAKE_ENVIRONMENT_PATH
2517                             NO_SYSTEM_ENVIRONMENT_PATH
2518                             NO_CMAKE_SYSTEM_PATH)
2519             endif()
2520
2521             if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST")
2522               find_library (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2523                             NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2524                             NAMES_PER_DIR
2525                             HINTS ${_${_PYTHON_PREFIX}_HINTS}
2526                             PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2527                                   ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
2528                             PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2529                             NO_SYSTEM_ENVIRONMENT_PATH
2530                             NO_CMAKE_SYSTEM_PATH)
2531             endif()
2532
2533             # search in HINTS locations
2534             find_library (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2535                           NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2536                           NAMES_PER_DIR
2537                           HINTS ${_${_PYTHON_PREFIX}_HINTS}
2538                           PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2539                           PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2540                           NO_SYSTEM_ENVIRONMENT_PATH
2541                           NO_CMAKE_SYSTEM_PATH)
2542
2543             if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST")
2544               set (__${_PYTHON_PREFIX}_FRAMEWORK_PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS})
2545             else()
2546               unset (__${_PYTHON_PREFIX}_FRAMEWORK_PATHS)
2547             endif()
2548
2549             if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST")
2550               set (__${_PYTHON_PREFIX}_REGISTRY_PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS})
2551             else()
2552               unset (__${_PYTHON_PREFIX}_REGISTRY_PATHS)
2553             endif()
2554
2555             # search in all default paths
2556             find_library (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2557                           NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2558                           NAMES_PER_DIR
2559                           PATHS ${__${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2560                                 ${__${_PYTHON_PREFIX}_REGISTRY_PATHS}
2561                           PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES})
2562
2563             if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE)
2564               break()
2565             endif()
2566           endforeach()
2567         endif()
2568       endif()
2569     endif()
2570
2571     # finalize library version information
2572     _python_get_version (LIBRARY PREFIX _${_PYTHON_PREFIX}_)
2573     if (_${_PYTHON_PREFIX}_VERSION EQUAL "${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}")
2574       # not able to extract full version from library name
2575       if (${_PYTHON_PREFIX}_Interpreter_FOUND)
2576         # update from interpreter
2577         set (_${_PYTHON_PREFIX}_VERSION ${${_PYTHON_PREFIX}_VERSION})
2578         set (_${_PYTHON_PREFIX}_VERSION_MAJOR ${${_PYTHON_PREFIX}_VERSION_MAJOR})
2579         set (_${_PYTHON_PREFIX}_VERSION_MINOR ${${_PYTHON_PREFIX}_VERSION_MINOR})
2580         set (_${_PYTHON_PREFIX}_VERSION_PATCH ${${_PYTHON_PREFIX}_VERSION_PATCH})
2581       endif()
2582     endif()
2583
2584     set (${_PYTHON_PREFIX}_LIBRARY_RELEASE "${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}")
2585
2586     if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE AND NOT EXISTS "${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}")
2587       set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Cannot find the library \"${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}\"")
2588       set_property (CACHE _${_PYTHON_PREFIX}_LIBRARY_RELEASE PROPERTY VALUE "${_PYTHON_PREFIX}_LIBRARY_RELEASE-NOTFOUND")
2589     endif()
2590
2591     set (_${_PYTHON_PREFIX}_HINTS "${${_PYTHON_PREFIX}_ROOT_DIR}" ENV ${_PYTHON_PREFIX}_ROOT_DIR)
2592
2593     if (WIN32 AND _${_PYTHON_PREFIX}_LIBRARY_RELEASE)
2594       # search for debug library
2595       # use release library location as a hint
2596       _python_get_names (_${_PYTHON_PREFIX}_LIB_NAMES_DEBUG VERSION ${_${_PYTHON_PREFIX}_VERSION} WIN32 DEBUG)
2597       get_filename_component (_${_PYTHON_PREFIX}_PATH "${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}" DIRECTORY)
2598       find_library (_${_PYTHON_PREFIX}_LIBRARY_DEBUG
2599                     NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES_DEBUG}
2600                     NAMES_PER_DIR
2601                     HINTS "${_${_PYTHON_PREFIX}_PATH}" ${_${_PYTHON_PREFIX}_HINTS}
2602                     NO_DEFAULT_PATH)
2603       # second try including CMAKE variables to catch-up non conventional layouts
2604       find_library (_${_PYTHON_PREFIX}_LIBRARY_DEBUG
2605                     NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES_DEBUG}
2606                     NAMES_PER_DIR
2607                     NO_SYSTEM_ENVIRONMENT_PATH
2608                     NO_CMAKE_SYSTEM_PATH)
2609     endif()
2610
2611     # retrieve runtime libraries
2612     if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE)
2613       _python_get_names (_${_PYTHON_PREFIX}_LIB_NAMES VERSION ${_${_PYTHON_PREFIX}_VERSION} WIN32 POSIX LIBRARY)
2614       get_filename_component (_${_PYTHON_PREFIX}_PATH "${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}" DIRECTORY)
2615       get_filename_component (_${_PYTHON_PREFIX}_PATH2 "${_${_PYTHON_PREFIX}_PATH}" DIRECTORY)
2616       _python_find_runtime_library (_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE
2617                                     NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES}
2618                                     NAMES_PER_DIR
2619                                     HINTS "${_${_PYTHON_PREFIX}_PATH}"
2620                                           "${_${_PYTHON_PREFIX}_PATH2}" ${_${_PYTHON_PREFIX}_HINTS}
2621                                     PATH_SUFFIXES bin)
2622     endif()
2623     if (_${_PYTHON_PREFIX}_LIBRARY_DEBUG)
2624       _python_get_names (_${_PYTHON_PREFIX}_LIB_NAMES_DEBUG VERSION ${_${_PYTHON_PREFIX}_VERSION} WIN32 DEBUG)
2625       get_filename_component (_${_PYTHON_PREFIX}_PATH "${_${_PYTHON_PREFIX}_LIBRARY_DEBUG}" DIRECTORY)
2626       get_filename_component (_${_PYTHON_PREFIX}_PATH2 "${_${_PYTHON_PREFIX}_PATH}" DIRECTORY)
2627       _python_find_runtime_library (_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG
2628                                     NAMES ${_${_PYTHON_PREFIX}_LIB_NAMES_DEBUG}
2629                                     NAMES_PER_DIR
2630                                     HINTS "${_${_PYTHON_PREFIX}_PATH}"
2631                                           "${_${_PYTHON_PREFIX}_PATH2}" ${_${_PYTHON_PREFIX}_HINTS}
2632                                     PATH_SUFFIXES bin)
2633     endif()
2634   endif()
2635
2636   if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS)
2637     while (NOT _${_PYTHON_PREFIX}_INCLUDE_DIR)
2638       if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS
2639           AND NOT _${_PYTHON_PREFIX}_LIBRARY_RELEASE)
2640         # Don't search for include dir if no library was founded
2641         break()
2642       endif()
2643
2644       if ((${_PYTHON_PREFIX}_Interpreter_FOUND AND NOT CMAKE_CROSSCOMPILING) OR _${_PYTHON_PREFIX}_CONFIG)
2645         _python_get_config_var (_${_PYTHON_PREFIX}_INCLUDE_DIRS INCLUDES)
2646
2647         find_path (_${_PYTHON_PREFIX}_INCLUDE_DIR
2648                    NAMES ${_${_PYTHON_PREFIX}_INCLUDE_NAMES}
2649                    HINTS ${_${_PYTHON_PREFIX}_INCLUDE_DIRS}
2650                    NO_SYSTEM_ENVIRONMENT_PATH
2651                    NO_CMAKE_SYSTEM_PATH)
2652       endif()
2653
2654       # Rely on HINTS and standard paths if interpreter or config tool failed to locate artifacts
2655       if (NOT _${_PYTHON_PREFIX}_INCLUDE_DIR)
2656         unset (_${_PYTHON_PREFIX}_VIRTUALENV_PATHS)
2657         if (_${_PYTHON_PREFIX}_FIND_VIRTUALENV MATCHES "^(FIRST|ONLY)$")
2658           set (_${_PYTHON_PREFIX}_VIRTUALENV_PATHS ENV VIRTUAL_ENV ENV CONDA_PREFIX)
2659         endif()
2660         unset (_${_PYTHON_PREFIX}_INCLUDE_HINTS)
2661
2662         if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE)
2663           # Use the library's install prefix as a hint
2664           if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "^(.+/Frameworks/Python.framework/Versions/[0-9.]+)")
2665             list (APPEND _${_PYTHON_PREFIX}_INCLUDE_HINTS "${CMAKE_MATCH_1}")
2666           elseif (_${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "^(.+)/lib(64|32)?/python[0-9.]+/config")
2667             list (APPEND _${_PYTHON_PREFIX}_INCLUDE_HINTS "${CMAKE_MATCH_1}")
2668           elseif (DEFINED CMAKE_LIBRARY_ARCHITECTURE AND ${_${_PYTHON_PREFIX}_LIBRARY_RELEASE} MATCHES "^(.+)/lib/${CMAKE_LIBRARY_ARCHITECTURE}")
2669             list (APPEND _${_PYTHON_PREFIX}_INCLUDE_HINTS "${CMAKE_MATCH_1}")
2670           else()
2671             # assume library is in a directory under root
2672             get_filename_component (_${_PYTHON_PREFIX}_PREFIX "${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}" DIRECTORY)
2673             get_filename_component (_${_PYTHON_PREFIX}_PREFIX "${_${_PYTHON_PREFIX}_PREFIX}" DIRECTORY)
2674             list (APPEND _${_PYTHON_PREFIX}_INCLUDE_HINTS "${_${_PYTHON_PREFIX}_PREFIX}")
2675           endif()
2676         endif()
2677
2678         _python_get_frameworks (_${_PYTHON_PREFIX}_FRAMEWORK_PATHS VERSION ${_${_PYTHON_PREFIX}_VERSION})
2679         _python_get_registries (_${_PYTHON_PREFIX}_REGISTRY_PATHS VERSION ${_${_PYTHON_PREFIX}_VERSION})
2680         _python_get_path_suffixes (_${_PYTHON_PREFIX}_PATH_SUFFIXES VERSION ${_${_PYTHON_PREFIX}_VERSION} INCLUDE)
2681
2682         if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "FIRST")
2683           find_path (_${_PYTHON_PREFIX}_INCLUDE_DIR
2684                      NAMES ${_${_PYTHON_PREFIX}_INCLUDE_NAMES}
2685                      HINTS ${_${_PYTHON_PREFIX}_INCLUDE_HINTS} ${_${_PYTHON_PREFIX}_HINTS}
2686                      PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2687                            ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2688                      PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2689                      NO_CMAKE_PATH
2690                      NO_CMAKE_ENVIRONMENT_PATH
2691                      NO_SYSTEM_ENVIRONMENT_PATH
2692                      NO_CMAKE_SYSTEM_PATH)
2693         endif()
2694
2695         if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "FIRST")
2696           find_path (_${_PYTHON_PREFIX}_INCLUDE_DIR
2697                      NAMES ${_${_PYTHON_PREFIX}_INCLUDE_NAMES}
2698                      HINTS ${_${_PYTHON_PREFIX}_INCLUDE_HINTS} ${_${_PYTHON_PREFIX}_HINTS}
2699                      PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2700                            ${_${_PYTHON_PREFIX}_REGISTRY_PATHS}
2701                      PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2702                      NO_SYSTEM_ENVIRONMENT_PATH
2703                      NO_CMAKE_SYSTEM_PATH)
2704         endif()
2705
2706         if (APPLE AND _${_PYTHON_PREFIX}_FIND_FRAMEWORK STREQUAL "LAST")
2707           set (__${_PYTHON_PREFIX}_FRAMEWORK_PATHS ${_${_PYTHON_PREFIX}_FRAMEWORK_PATHS})
2708         else()
2709           unset (__${_PYTHON_PREFIX}_FRAMEWORK_PATHS)
2710         endif()
2711
2712         if (WIN32 AND _${_PYTHON_PREFIX}_FIND_REGISTRY STREQUAL "LAST")
2713           set (__${_PYTHON_PREFIX}_REGISTRY_PATHS ${_${_PYTHON_PREFIX}_REGISTRY_PATHS})
2714         else()
2715           unset (__${_PYTHON_PREFIX}_REGISTRY_PATHS)
2716         endif()
2717
2718         find_path (_${_PYTHON_PREFIX}_INCLUDE_DIR
2719                    NAMES ${_${_PYTHON_PREFIX}_INCLUDE_NAMES}
2720                    HINTS ${_${_PYTHON_PREFIX}_INCLUDE_HINTS} ${_${_PYTHON_PREFIX}_HINTS}
2721                    PATHS ${_${_PYTHON_PREFIX}_VIRTUALENV_PATHS}
2722                          ${__${_PYTHON_PREFIX}_FRAMEWORK_PATHS}
2723                          ${__${_PYTHON_PREFIX}_REGISTRY_PATHS}
2724                    PATH_SUFFIXES ${_${_PYTHON_PREFIX}_PATH_SUFFIXES}
2725                    NO_SYSTEM_ENVIRONMENT_PATH
2726                    NO_CMAKE_SYSTEM_PATH)
2727       endif()
2728
2729       # search header file in standard locations
2730       find_path (_${_PYTHON_PREFIX}_INCLUDE_DIR
2731                  NAMES ${_${_PYTHON_PREFIX}_INCLUDE_NAMES})
2732
2733       break()
2734     endwhile()
2735
2736     set (${_PYTHON_PREFIX}_INCLUDE_DIRS "${_${_PYTHON_PREFIX}_INCLUDE_DIR}")
2737
2738     if (_${_PYTHON_PREFIX}_INCLUDE_DIR AND NOT EXISTS "${_${_PYTHON_PREFIX}_INCLUDE_DIR}")
2739       set (_${_PYTHON_PREFIX}_Development_REASON_FAILURE "Cannot find the directory \"${_${_PYTHON_PREFIX}_INCLUDE_DIR}\"")
2740       set_property (CACHE _${_PYTHON_PREFIX}_INCLUDE_DIR PROPERTY VALUE "${_PYTHON_PREFIX}_INCLUDE_DIR-NOTFOUND")
2741     endif()
2742
2743     if (_${_PYTHON_PREFIX}_INCLUDE_DIR)
2744       # retrieve version from header file
2745       _python_get_version (INCLUDE PREFIX _${_PYTHON_PREFIX}_INC_)
2746
2747       if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE)
2748         if ("${_${_PYTHON_PREFIX}_INC_VERSION_MAJOR}.${_${_PYTHON_PREFIX}_INC_VERSION_MINOR}"
2749             VERSION_EQUAL _${_PYTHON_PREFIX}_VERSION)
2750           # update versioning
2751           set (_${_PYTHON_PREFIX}_VERSION ${_${_PYTHON_PREFIX}_INC_VERSION})
2752           set (_${_PYTHON_PREFIX}_VERSION_PATCH ${_${_PYTHON_PREFIX}_INC_VERSION_PATCH})
2753         endif()
2754       else()
2755         set (_${_PYTHON_PREFIX}_VERSION ${_${_PYTHON_PREFIX}_INC_VERSION})
2756         set (_${_PYTHON_PREFIX}_VERSION_MAJOR ${_${_PYTHON_PREFIX}_INC_VERSION_MAJOR})
2757         set (_${_PYTHON_PREFIX}_VERSION_MINOR ${_${_PYTHON_PREFIX}_INC_VERSION_MINOR})
2758         set (_${_PYTHON_PREFIX}_VERSION_PATCH ${_${_PYTHON_PREFIX}_INC_VERSION_PATCH})
2759       endif()
2760     endif()
2761   endif()
2762
2763   if (NOT ${_PYTHON_PREFIX}_Interpreter_FOUND AND NOT ${_PYTHON_PREFIX}_Compiler_FOUND)
2764     # set public version information
2765     set (${_PYTHON_PREFIX}_VERSION ${_${_PYTHON_PREFIX}_VERSION})
2766     set (${_PYTHON_PREFIX}_VERSION_MAJOR ${_${_PYTHON_PREFIX}_VERSION_MAJOR})
2767     set (${_PYTHON_PREFIX}_VERSION_MINOR ${_${_PYTHON_PREFIX}_VERSION_MINOR})
2768     set (${_PYTHON_PREFIX}_VERSION_PATCH ${_${_PYTHON_PREFIX}_VERSION_PATCH})
2769   endif()
2770
2771   # define public variables
2772   if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS)
2773     set (${_PYTHON_PREFIX}_LIBRARY_DEBUG "${_${_PYTHON_PREFIX}_LIBRARY_DEBUG}")
2774     _python_select_library_configurations (${_PYTHON_PREFIX})
2775
2776     set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE "${_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE}")
2777     set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG "${_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG}")
2778
2779     if (_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE)
2780       set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY "${_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE}")
2781     elseif (_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG)
2782       set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY "${_${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG}")
2783     else()
2784       set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY "${_PYTHON_PREFIX}_RUNTIME_LIBRARY-NOTFOUND")
2785     endif()
2786
2787     _python_set_library_dirs (${_PYTHON_PREFIX}_LIBRARY_DIRS
2788                               _${_PYTHON_PREFIX}_LIBRARY_RELEASE
2789                               _${_PYTHON_PREFIX}_LIBRARY_DEBUG)
2790     if (UNIX)
2791       if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "${CMAKE_SHARED_LIBRARY_SUFFIX}$")
2792         set (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DIRS ${${_PYTHON_PREFIX}_LIBRARY_DIRS})
2793       endif()
2794     else()
2795       _python_set_library_dirs (${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DIRS
2796                                 _${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE
2797                                 _${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG)
2798     endif()
2799   endif()
2800
2801   if (_${_PYTHON_PREFIX}_LIBRARY_RELEASE OR _${_PYTHON_PREFIX}_INCLUDE_DIR)
2802     if (${_PYTHON_PREFIX}_Interpreter_FOUND OR ${_PYTHON_PREFIX}_Compiler_FOUND)
2803       # development environment must be compatible with interpreter/compiler
2804       if ("${_${_PYTHON_PREFIX}_VERSION_MAJOR}.${_${_PYTHON_PREFIX}_VERSION_MINOR}" VERSION_EQUAL "${${_PYTHON_PREFIX}_VERSION_MAJOR}.${${_PYTHON_PREFIX}_VERSION_MINOR}"
2805           AND "${_${_PYTHON_PREFIX}_INC_VERSION_MAJOR}.${_${_PYTHON_PREFIX}_INC_VERSION_MINOR}" VERSION_EQUAL "${_${_PYTHON_PREFIX}_VERSION_MAJOR}.${_${_PYTHON_PREFIX}_VERSION_MINOR}")
2806         _python_set_development_module_found (Module)
2807         _python_set_development_module_found (Embed)
2808       endif()
2809     elseif (${_PYTHON_PREFIX}_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR
2810         AND "${_${_PYTHON_PREFIX}_INC_VERSION_MAJOR}.${_${_PYTHON_PREFIX}_INC_VERSION_MINOR}" VERSION_EQUAL "${_${_PYTHON_PREFIX}_VERSION_MAJOR}.${_${_PYTHON_PREFIX}_VERSION_MINOR}")
2811       _python_set_development_module_found (Module)
2812       _python_set_development_module_found (Embed)
2813     endif()
2814     if (DEFINED _${_PYTHON_PREFIX}_FIND_ABI AND
2815         (NOT _${_PYTHON_PREFIX}_ABI IN_LIST _${_PYTHON_PREFIX}_ABIFLAGS
2816           OR NOT _${_PYTHON_PREFIX}_INC_ABI IN_LIST _${_PYTHON_PREFIX}_ABIFLAGS))
2817       set (${_PYTHON_PREFIX}_Development.Module_FOUND FALSE)
2818       set (${_PYTHON_PREFIX}_Development.Embed_FOUND FALSE)
2819     endif()
2820   endif()
2821
2822   if (( ${_PYTHON_PREFIX}_Development.Module_FOUND
2823         AND ${_PYTHON_PREFIX}_Development.Embed_FOUND)
2824       OR (NOT "Development.Module" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS
2825         AND ${_PYTHON_PREFIX}_Development.Embed_FOUND)
2826       OR (NOT "Development.Embed" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS
2827         AND ${_PYTHON_PREFIX}_Development.Module_FOUND))
2828     unset (_${_PYTHON_PREFIX}_Development_REASON_FAILURE)
2829   endif()
2830
2831   if ("Development" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS
2832       AND ${_PYTHON_PREFIX}_Development.Module_FOUND
2833       AND ${_PYTHON_PREFIX}_Development.Embed_FOUND)
2834     set (${_PYTHON_PREFIX}_Development_FOUND TRUE)
2835   endif()
2836
2837   if ((${_PYTHON_PREFIX}_Development.Module_FOUND
2838       OR ${_PYTHON_PREFIX}_Development.Embed_FOUND)
2839     AND EXISTS "${_${_PYTHON_PREFIX}_INCLUDE_DIR}/PyPy.h")
2840   # retrieve PyPy version
2841   file (STRINGS "${_${_PYTHON_PREFIX}_INCLUDE_DIR}/patchlevel.h" ${_PYTHON_PREFIX}_PyPy_VERSION
2842                 REGEX "^#define[ \t]+PYPY_VERSION[ \t]+\"[^\"]+\"")
2843   string (REGEX REPLACE "^#define[ \t]+PYPY_VERSION[ \t]+\"([^\"]+)\".*" "\\1"
2844                 ${_PYTHON_PREFIX}_PyPy_VERSION "${${_PYTHON_PREFIX}_PyPy_VERSION}")
2845   endif()
2846
2847   if (_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR VERSION_GREATER_EQUAL "3"
2848       AND NOT DEFINED ${_PYTHON_PREFIX}_SOABI)
2849     _python_get_config_var (${_PYTHON_PREFIX}_SOABI SOABI)
2850   endif()
2851
2852   _python_compute_development_signature (Module)
2853   _python_compute_development_signature (Embed)
2854
2855   # Restore the original find library ordering
2856   if (DEFINED _${_PYTHON_PREFIX}_CMAKE_FIND_LIBRARY_SUFFIXES)
2857     set (CMAKE_FIND_LIBRARY_SUFFIXES ${_${_PYTHON_PREFIX}_CMAKE_FIND_LIBRARY_SUFFIXES})
2858   endif()
2859
2860   if (${_PYTHON_PREFIX}_ARTIFACTS_INTERACTIVE)
2861     if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS)
2862       set (${_PYTHON_PREFIX}_LIBRARY "${_${_PYTHON_PREFIX}_LIBRARY_RELEASE}" CACHE FILEPATH "${_PYTHON_PREFIX} Library")
2863     endif()
2864     if ("INCLUDE_DIR" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_ARTIFACTS)
2865       set (${_PYTHON_PREFIX}_INCLUDE_DIR "${_${_PYTHON_PREFIX}_INCLUDE_DIR}" CACHE FILEPATH "${_PYTHON_PREFIX} Include Directory")
2866     endif()
2867   endif()
2868
2869   _python_mark_as_internal (_${_PYTHON_PREFIX}_LIBRARY_RELEASE
2870                             _${_PYTHON_PREFIX}_LIBRARY_DEBUG
2871                             _${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE
2872                             _${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG
2873                             _${_PYTHON_PREFIX}_INCLUDE_DIR
2874                             _${_PYTHON_PREFIX}_CONFIG
2875                             _${_PYTHON_PREFIX}_DEVELOPMENT_MODULE_SIGNATURE
2876                             _${_PYTHON_PREFIX}_DEVELOPMENT_EMBED_SIGNATURE)
2877 endif()
2878
2879 if (${_PYTHON_PREFIX}_FIND_REQUIRED_NumPy)
2880   list (APPEND _${_PYTHON_PREFIX}_REQUIRED_VARS ${_PYTHON_PREFIX}_NumPy_INCLUDE_DIRS)
2881 endif()
2882 if ("NumPy" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS AND ${_PYTHON_PREFIX}_Interpreter_FOUND)
2883   list (APPEND _${_PYTHON_PREFIX}_CACHED_VARS _${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR)
2884
2885   if (DEFINED ${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR
2886       AND IS_ABSOLUTE "${${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}")
2887     set (_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR "${${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}" CACHE INTERNAL "")
2888   elseif (DEFINED _${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR)
2889     # compute numpy signature. Depends on interpreter and development signatures
2890     string (MD5 __${_PYTHON_PREFIX}_NUMPY_SIGNATURE "${_${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE}:${_${_PYTHON_PREFIX}_DEVELOPMENT_MODULE_SIGNATURE}:${_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}")
2891     if (NOT __${_PYTHON_PREFIX}_NUMPY_SIGNATURE STREQUAL _${_PYTHON_PREFIX}_NUMPY_SIGNATURE
2892         OR NOT EXISTS "${_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}")
2893       unset (_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR CACHE)
2894       unset (_${_PYTHON_PREFIX}_NUMPY_SIGNATURE CACHE)
2895     endif()
2896   endif()
2897
2898   if (NOT _${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR)
2899     execute_process(COMMAND ${${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
2900                             "import sys\ntry: import numpy; sys.stdout.write(numpy.get_include())\nexcept:pass\n"
2901                     RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
2902                     OUTPUT_VARIABLE _${_PYTHON_PREFIX}_NumPy_PATH
2903                     ERROR_QUIET
2904                     OUTPUT_STRIP_TRAILING_WHITESPACE)
2905
2906     if (NOT _${_PYTHON_PREFIX}_RESULT)
2907       find_path (_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR
2908                  NAMES "numpy/arrayobject.h" "numpy/numpyconfig.h"
2909                  HINTS "${_${_PYTHON_PREFIX}_NumPy_PATH}"
2910                  NO_DEFAULT_PATH)
2911     endif()
2912   endif()
2913
2914   set (${_PYTHON_PREFIX}_NumPy_INCLUDE_DIRS "${_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}")
2915
2916   if(_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR AND NOT EXISTS "${_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}")
2917     set (_${_PYTHON_PREFIX}_NumPy_REASON_FAILURE "Cannot find the directory \"${_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}\"")
2918     set_property (CACHE _${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR PROPERTY VALUE "${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR-NOTFOUND")
2919   endif()
2920
2921   if (_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR)
2922     execute_process (COMMAND ${${_PYTHON_PREFIX}_INTERPRETER_LAUNCHER} "${_${_PYTHON_PREFIX}_EXECUTABLE}" -c
2923                              "import sys\ntry: import numpy; sys.stdout.write(numpy.__version__)\nexcept:pass\n"
2924                      RESULT_VARIABLE _${_PYTHON_PREFIX}_RESULT
2925                      OUTPUT_VARIABLE _${_PYTHON_PREFIX}_NumPy_VERSION)
2926     if (NOT _${_PYTHON_PREFIX}_RESULT)
2927       set (${_PYTHON_PREFIX}_NumPy_VERSION "${_${_PYTHON_PREFIX}_NumPy_VERSION}")
2928     else()
2929       unset (${_PYTHON_PREFIX}_NumPy_VERSION)
2930     endif()
2931
2932     # final step: set NumPy founded only if Development.Module component is founded as well
2933     set(${_PYTHON_PREFIX}_NumPy_FOUND ${${_PYTHON_PREFIX}_Development.Module_FOUND})
2934   else()
2935     set (${_PYTHON_PREFIX}_NumPy_FOUND FALSE)
2936   endif()
2937
2938   if (${_PYTHON_PREFIX}_NumPy_FOUND)
2939     unset (_${_PYTHON_PREFIX}_NumPy_REASON_FAILURE)
2940
2941     # compute and save numpy signature
2942     string (MD5 __${_PYTHON_PREFIX}_NUMPY_SIGNATURE "${_${_PYTHON_PREFIX}_INTERPRETER_SIGNATURE}:${_${_PYTHON_PREFIX}_DEVELOPMENT_MODULE_SIGNATURE}:${${_PYTHON_PREFIX}_NumPyINCLUDE_DIR}")
2943     set (_${_PYTHON_PREFIX}_NUMPY_SIGNATURE "${__${_PYTHON_PREFIX}_NUMPY_SIGNATURE}" CACHE INTERNAL "")
2944   else()
2945     unset (_${_PYTHON_PREFIX}_NUMPY_SIGNATURE CACHE)
2946   endif()
2947
2948   if (${_PYTHON_PREFIX}_ARTIFACTS_INTERACTIVE)
2949     set (${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR "${_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR}" CACHE FILEPATH "${_PYTHON_PREFIX} NumPy Include Directory")
2950   endif()
2951
2952   _python_mark_as_internal (_${_PYTHON_PREFIX}_NumPy_INCLUDE_DIR
2953                             _${_PYTHON_PREFIX}_NUMPY_SIGNATURE)
2954 endif()
2955
2956 # final validation
2957 if (${_PYTHON_PREFIX}_VERSION_MAJOR AND
2958     NOT ${_PYTHON_PREFIX}_VERSION_MAJOR VERSION_EQUAL _${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR)
2959   _python_display_failure ("Could NOT find ${_PYTHON_PREFIX}: Found unsuitable major version \"${${_PYTHON_PREFIX}_VERSION_MAJOR}\", but required major version is exact version \"${_${_PYTHON_PREFIX}_REQUIRED_VERSION_MAJOR}\"")
2960 endif()
2961
2962 unset (_${_PYTHON_PREFIX}_REASON_FAILURE)
2963 foreach (_${_PYTHON_PREFIX}_COMPONENT IN ITEMS Interpreter Compiler Development NumPy)
2964   if (_${_PYTHON_PREFIX}_${_${_PYTHON_PREFIX}_COMPONENT}_REASON_FAILURE)
2965     string (APPEND _${_PYTHON_PREFIX}_REASON_FAILURE "\n        ${_${_PYTHON_PREFIX}_COMPONENT}: ${_${_PYTHON_PREFIX}_${_${_PYTHON_PREFIX}_COMPONENT}_REASON_FAILURE}")
2966     unset (_${_PYTHON_PREFIX}_${_${_PYTHON_PREFIX}_COMPONENT}_REASON_FAILURE)
2967   endif()
2968 endforeach()
2969
2970 include (${CMAKE_CURRENT_LIST_DIR}/../FindPackageHandleStandardArgs.cmake)
2971 find_package_handle_standard_args (${_PYTHON_PREFIX}
2972                                    REQUIRED_VARS ${_${_PYTHON_PREFIX}_REQUIRED_VARS}
2973                                    VERSION_VAR ${_PYTHON_PREFIX}_VERSION
2974                                    HANDLE_COMPONENTS
2975                                    REASON_FAILURE_MESSAGE "${_${_PYTHON_PREFIX}_REASON_FAILURE}")
2976
2977 # Create imported targets and helper functions
2978 if(_${_PYTHON_PREFIX}_CMAKE_ROLE STREQUAL "PROJECT")
2979   if ("Interpreter" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS
2980       AND ${_PYTHON_PREFIX}_Interpreter_FOUND
2981       AND NOT TARGET ${_PYTHON_PREFIX}::Interpreter)
2982     add_executable (${_PYTHON_PREFIX}::Interpreter IMPORTED)
2983     set_property (TARGET ${_PYTHON_PREFIX}::Interpreter
2984                   PROPERTY IMPORTED_LOCATION "${${_PYTHON_PREFIX}_EXECUTABLE}")
2985   endif()
2986
2987   if ("Compiler" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS
2988       AND ${_PYTHON_PREFIX}_Compiler_FOUND
2989       AND NOT TARGET ${_PYTHON_PREFIX}::Compiler)
2990     add_executable (${_PYTHON_PREFIX}::Compiler IMPORTED)
2991     set_property (TARGET ${_PYTHON_PREFIX}::Compiler
2992                   PROPERTY IMPORTED_LOCATION "${${_PYTHON_PREFIX}_COMPILER}")
2993   endif()
2994
2995   if (("Development.Module" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS
2996         AND ${_PYTHON_PREFIX}_Development.Module_FOUND)
2997       OR ("Development.Embed" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS
2998         AND ${_PYTHON_PREFIX}_Development.Embed_FOUND))
2999
3000     macro (__PYTHON_IMPORT_LIBRARY __name)
3001       if (${_PYTHON_PREFIX}_LIBRARY_RELEASE MATCHES "${CMAKE_SHARED_LIBRARY_SUFFIX}$"
3002           OR ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE)
3003         set (_${_PYTHON_PREFIX}_LIBRARY_TYPE SHARED)
3004       else()
3005         set (_${_PYTHON_PREFIX}_LIBRARY_TYPE STATIC)
3006       endif()
3007
3008       if (NOT TARGET ${__name})
3009         add_library (${__name} ${_${_PYTHON_PREFIX}_LIBRARY_TYPE} IMPORTED)
3010       endif()
3011
3012       set_property (TARGET ${__name}
3013                     PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${${_PYTHON_PREFIX}_INCLUDE_DIRS}")
3014
3015       if (${_PYTHON_PREFIX}_LIBRARY_RELEASE AND ${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE)
3016         # System manage shared libraries in two parts: import and runtime
3017         if (${_PYTHON_PREFIX}_LIBRARY_RELEASE AND ${_PYTHON_PREFIX}_LIBRARY_DEBUG)
3018           set_property (TARGET ${__name} PROPERTY IMPORTED_CONFIGURATIONS RELEASE DEBUG)
3019           set_target_properties (${__name}
3020                                  PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C"
3021                                             IMPORTED_IMPLIB_RELEASE "${${_PYTHON_PREFIX}_LIBRARY_RELEASE}"
3022                                             IMPORTED_LOCATION_RELEASE "${${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE}")
3023           set_target_properties (${__name}
3024                                  PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C"
3025                                             IMPORTED_IMPLIB_DEBUG "${${_PYTHON_PREFIX}_LIBRARY_DEBUG}"
3026                                             IMPORTED_LOCATION_DEBUG "${${_PYTHON_PREFIX}_RUNTIME_LIBRARY_DEBUG}")
3027         else()
3028           set_target_properties (${__name}
3029                                  PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C"
3030                                             IMPORTED_IMPLIB "${${_PYTHON_PREFIX}_LIBRARIES}"
3031                                             IMPORTED_LOCATION "${${_PYTHON_PREFIX}_RUNTIME_LIBRARY_RELEASE}")
3032         endif()
3033       else()
3034         if (${_PYTHON_PREFIX}_LIBRARY_RELEASE AND ${_PYTHON_PREFIX}_LIBRARY_DEBUG)
3035           set_property (TARGET ${__name} PROPERTY IMPORTED_CONFIGURATIONS RELEASE DEBUG)
3036           set_target_properties (${__name}
3037                                  PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C"
3038                                             IMPORTED_LOCATION_RELEASE "${${_PYTHON_PREFIX}_LIBRARY_RELEASE}")
3039           set_target_properties (${__name}
3040                                  PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C"
3041                                             IMPORTED_LOCATION_DEBUG "${${_PYTHON_PREFIX}_LIBRARY_DEBUG}")
3042         else()
3043           set_target_properties (${__name}
3044                                  PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C"
3045                                             IMPORTED_LOCATION "${${_PYTHON_PREFIX}_LIBRARY_RELEASE}")
3046         endif()
3047       endif()
3048
3049       if (_${_PYTHON_PREFIX}_LIBRARY_TYPE STREQUAL "STATIC")
3050         # extend link information with dependent libraries
3051         _python_get_config_var (_${_PYTHON_PREFIX}_LINK_LIBRARIES LIBS)
3052         if (_${_PYTHON_PREFIX}_LINK_LIBRARIES)
3053           set_property (TARGET ${__name}
3054                         PROPERTY INTERFACE_LINK_LIBRARIES ${_${_PYTHON_PREFIX}_LINK_LIBRARIES})
3055         endif()
3056       endif()
3057     endmacro()
3058
3059     if (${_PYTHON_PREFIX}_Development.Embed_FOUND)
3060       __python_import_library (${_PYTHON_PREFIX}::Python)
3061     endif()
3062
3063     if (${_PYTHON_PREFIX}_Development.Module_FOUND)
3064       if ("LIBRARY" IN_LIST _${_PYTHON_PREFIX}_FIND_DEVELOPMENT_MODULE_ARTIFACTS)
3065         # On Windows/CYGWIN/MSYS, Python::Module is the same as Python::Python
3066         # but ALIAS cannot be used because the imported library is not GLOBAL.
3067         __python_import_library (${_PYTHON_PREFIX}::Module)
3068       else()
3069         if (NOT TARGET ${_PYTHON_PREFIX}::Module)
3070           add_library (${_PYTHON_PREFIX}::Module INTERFACE IMPORTED)
3071         endif()
3072         set_property (TARGET ${_PYTHON_PREFIX}::Module
3073                       PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${${_PYTHON_PREFIX}_INCLUDE_DIRS}")
3074
3075         # When available, enforce shared library generation with undefined symbols
3076         if (APPLE)
3077           set_property (TARGET ${_PYTHON_PREFIX}::Module
3078                         PROPERTY INTERFACE_LINK_OPTIONS "LINKER:-undefined,dynamic_lookup")
3079         endif()
3080         if (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
3081           set_property (TARGET ${_PYTHON_PREFIX}::Module
3082                         PROPERTY INTERFACE_LINK_OPTIONS "LINKER:-z,nodefs")
3083         endif()
3084         if (CMAKE_SYSTEM_NAME STREQUAL "AIX")
3085           set_property (TARGET ${_PYTHON_PREFIX}::Module
3086                         PROPERTY INTERFACE_LINK_OPTIONS "LINKER:-b,erok")
3087         endif()
3088       endif()
3089     endif()
3090
3091     #
3092     # PYTHON_ADD_LIBRARY (<name> [STATIC|SHARED|MODULE] src1 src2 ... srcN)
3093     # It is used to build modules for python.
3094     #
3095     function (__${_PYTHON_PREFIX}_ADD_LIBRARY prefix name)
3096       cmake_parse_arguments (PARSE_ARGV 2 PYTHON_ADD_LIBRARY "STATIC;SHARED;MODULE;WITH_SOABI" "" "")
3097
3098       if (prefix STREQUAL "Python2" AND PYTHON_ADD_LIBRARY_WITH_SOABI)
3099         message (AUTHOR_WARNING "FindPython2: Option `WITH_SOABI` is not supported for Python2 and will be ignored.")
3100         unset (PYTHON_ADD_LIBRARY_WITH_SOABI)
3101       endif()
3102
3103       if (PYTHON_ADD_LIBRARY_STATIC)
3104         set (type STATIC)
3105       elseif (PYTHON_ADD_LIBRARY_SHARED)
3106         set (type SHARED)
3107       else()
3108         set (type MODULE)
3109       endif()
3110
3111       if (type STREQUAL "MODULE" AND NOT TARGET ${prefix}::Module)
3112         message (SEND_ERROR "${prefix}_ADD_LIBRARY: dependent target '${prefix}::Module' is not defined.\n   Did you miss to request COMPONENT 'Development.Module'?")
3113         return()
3114       endif()
3115       if (NOT type STREQUAL "MODULE" AND NOT TARGET ${prefix}::Python)
3116         message (SEND_ERROR "${prefix}_ADD_LIBRARY: dependent target '${prefix}::Python' is not defined.\n   Did you miss to request COMPONENT 'Development.Embed'?")
3117         return()
3118       endif()
3119
3120       add_library (${name} ${type} ${PYTHON_ADD_LIBRARY_UNPARSED_ARGUMENTS})
3121
3122       get_property (type TARGET ${name} PROPERTY TYPE)
3123
3124       if (type STREQUAL "MODULE_LIBRARY")
3125         target_link_libraries (${name} PRIVATE ${prefix}::Module)
3126         # customize library name to follow module name rules
3127         set_property (TARGET ${name} PROPERTY PREFIX "")
3128         if(CMAKE_SYSTEM_NAME STREQUAL "Windows")
3129           set_property (TARGET ${name} PROPERTY SUFFIX ".pyd")
3130         endif()
3131
3132         if (PYTHON_ADD_LIBRARY_WITH_SOABI AND ${prefix}_SOABI)
3133           get_property (suffix TARGET ${name} PROPERTY SUFFIX)
3134           if (NOT suffix)
3135             set (suffix "${CMAKE_SHARED_MODULE_SUFFIX}")
3136           endif()
3137           set_property (TARGET ${name} PROPERTY SUFFIX ".${${prefix}_SOABI}${suffix}")
3138         endif()
3139       else()
3140         if (PYTHON_ADD_LIBRARY_WITH_SOABI)
3141           message (AUTHOR_WARNING "Find${prefix}: Option `WITH_SOABI` is only supported for `MODULE` library type.")
3142         endif()
3143         target_link_libraries (${name} PRIVATE ${prefix}::Python)
3144       endif()
3145     endfunction()
3146   endif()
3147
3148   if ("NumPy" IN_LIST ${_PYTHON_PREFIX}_FIND_COMPONENTS AND ${_PYTHON_PREFIX}_NumPy_FOUND
3149       AND NOT TARGET ${_PYTHON_PREFIX}::NumPy AND TARGET ${_PYTHON_PREFIX}::Module)
3150     add_library (${_PYTHON_PREFIX}::NumPy INTERFACE IMPORTED)
3151     set_property (TARGET ${_PYTHON_PREFIX}::NumPy
3152                   PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${${_PYTHON_PREFIX}_NumPy_INCLUDE_DIRS}")
3153     target_link_libraries (${_PYTHON_PREFIX}::NumPy INTERFACE ${_PYTHON_PREFIX}::Module)
3154   endif()
3155 endif()
3156
3157 # final clean-up
3158
3159 # Restore CMAKE_FIND_APPBUNDLE
3160 if (DEFINED _${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE)
3161   set (CMAKE_FIND_APPBUNDLE ${_${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE})
3162   unset (_${_PYTHON_PREFIX}_CMAKE_FIND_APPBUNDLE)
3163 else()
3164   unset (CMAKE_FIND_APPBUNDLE)
3165 endif()
3166 # Restore CMAKE_FIND_FRAMEWORK
3167 if (DEFINED _${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK)
3168   set (CMAKE_FIND_FRAMEWORK ${_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK})
3169   unset (_${_PYTHON_PREFIX}_CMAKE_FIND_FRAMEWORK)
3170 else()
3171   unset (CMAKE_FIND_FRAMEWORK)
3172 endif()