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