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