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