Modules/FindPython/Support.cmake

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