mirror of
https://github.com/gnss-sdr/gnss-sdr
synced 2026-05-23 05:42:12 +00:00
Carles Fernandez
e82624d981
Refactor Python detection Improve imported target handling Improve version detection Improve naming consistency
378 lines
11 KiB
CMake
378 lines
11 KiB
CMake
# GNSS-SDR is a Global Navigation Satellite System software-defined receiver.
|
|
# This file is part of GNSS-SDR.
|
|
#
|
|
# SPDX-FileCopyrightText: 2011-2026 C. Fernandez-Prades cfernandez(at)cttc.es
|
|
# SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
|
|
########################################################################
|
|
# Internal helper:
|
|
# Run a Python snippet with the selected interpreter.
|
|
#
|
|
# Usage:
|
|
# gnsssdr_python_run("<python code>" result_var)
|
|
#
|
|
# The Python code must exit with code 0 on success and non-zero on failure.
|
|
########################################################################
|
|
macro(GNSSSDR_PYTHON_RUN code result_var)
|
|
execute_process(
|
|
COMMAND ${PYTHON_EXECUTABLE} -c "${code}"
|
|
OUTPUT_QUIET
|
|
ERROR_QUIET
|
|
RESULT_VARIABLE _gnsssdr_python_run_result
|
|
)
|
|
set(${result_var} ${_gnsssdr_python_run_result})
|
|
endmacro()
|
|
|
|
|
|
########################################################################
|
|
# Internal helper:
|
|
# Read Python version information from the selected interpreter.
|
|
#
|
|
# Sets:
|
|
# PYTHON_VERSION_STRING
|
|
# PYTHON_VERSION_MAJOR
|
|
########################################################################
|
|
macro(GNSSSDR_PYTHON_GET_VERSION)
|
|
unset(PYTHON_VERSION_STRING)
|
|
unset(PYTHON_VERSION_MAJOR)
|
|
execute_process(
|
|
COMMAND ${PYTHON_EXECUTABLE} -c
|
|
"import sys; sys.stdout.write(sys.version.split()[0])"
|
|
OUTPUT_VARIABLE PYTHON_VERSION_STRING
|
|
ERROR_QUIET
|
|
OUTPUT_STRIP_TRAILING_WHITESPACE
|
|
)
|
|
if(NOT "${PYTHON_VERSION_STRING}" STREQUAL "")
|
|
string(SUBSTRING "${PYTHON_VERSION_STRING}" 0 1 PYTHON_VERSION_MAJOR)
|
|
endif()
|
|
endmacro()
|
|
|
|
|
|
########################################################################
|
|
# Check that Python satisfies a minimum version.
|
|
#
|
|
# Arguments:
|
|
# minver Minimum version string, e.g. 2.7 or 3.6
|
|
# have Output variable set to TRUE/FALSE
|
|
########################################################################
|
|
macro(GNSSSDR_PYTHON_CHECK_MIN_VERSION minver have)
|
|
message(STATUS "Python checking for python >= ${minver}")
|
|
gnsssdr_python_run(
|
|
"import sys
|
|
|
|
def norm(v):
|
|
out = []
|
|
for p in str(v).split('.'):
|
|
n = ''.join([c for c in p if '0' <= c <= '9'])
|
|
out.append(int(n or '0'))
|
|
while len(out) < 3:
|
|
out.append(0)
|
|
return tuple(out)
|
|
|
|
sys.exit(0 if norm(sys.version.split()[0]) >= norm('${minver}') else 1)"
|
|
_gnsssdr_python_minver_result
|
|
)
|
|
if(_gnsssdr_python_minver_result EQUAL 0)
|
|
message(STATUS "Python checking for python >= ${minver} - found")
|
|
set(${have} TRUE)
|
|
else()
|
|
message(STATUS "Python checking for python >= ${minver} - not found")
|
|
set(${have} FALSE)
|
|
endif()
|
|
endmacro()
|
|
|
|
|
|
########################################################################
|
|
# Check for a Python module, optionally with a minimum version.
|
|
#
|
|
# Arguments:
|
|
# desc Human-readable description
|
|
# mod Module name to import
|
|
# minver Minimum module version, or empty string to skip version check
|
|
# have Output variable set to TRUE/FALSE
|
|
#
|
|
########################################################################
|
|
macro(GNSSSDR_PYTHON_CHECK_MODULE desc mod minver have)
|
|
message(STATUS "Python checking for ${desc}")
|
|
if("${minver}" STREQUAL "")
|
|
gnsssdr_python_run(
|
|
"import sys
|
|
try:
|
|
import ${mod}
|
|
except Exception:
|
|
sys.exit(1)
|
|
sys.exit(0)"
|
|
_gnsssdr_python_module_result
|
|
)
|
|
else()
|
|
gnsssdr_python_run(
|
|
"import sys
|
|
try:
|
|
import ${mod}
|
|
except Exception:
|
|
sys.exit(1)
|
|
|
|
def norm(v):
|
|
out = []
|
|
for p in str(v).split('.'):
|
|
n = ''.join([c for c in p if '0' <= c <= '9'])
|
|
out.append(int(n or '0'))
|
|
while len(out) < 3:
|
|
out.append(0)
|
|
return tuple(out)
|
|
|
|
try:
|
|
modver = ${mod}.__version__
|
|
except Exception:
|
|
sys.exit(1)
|
|
|
|
sys.exit(0 if norm(modver) >= norm('${minver}') else 1)"
|
|
_gnsssdr_python_module_result
|
|
)
|
|
endif()
|
|
if(_gnsssdr_python_module_result EQUAL 0)
|
|
message(STATUS "Python checking for ${desc} - found")
|
|
set(${have} TRUE)
|
|
else()
|
|
message(STATUS "Python checking for ${desc} - not found")
|
|
set(${have} FALSE)
|
|
endif()
|
|
endmacro()
|
|
|
|
|
|
########################################################################
|
|
# Internal helper:
|
|
# Test whether a given interpreter is suitable.
|
|
#
|
|
# Conditions:
|
|
# - Python version >= GNSSSDR_PYTHON_MIN_VERSION
|
|
# - mako >= GNSSSDR_MAKO_MIN_VERSION
|
|
# - six present if Python 2
|
|
#
|
|
# Arguments:
|
|
# candidate Full path to Python interpreter
|
|
# have Output variable set to TRUE/FALSE
|
|
########################################################################
|
|
function(GNSSSDR_PYTHON_EVALUATE_CANDIDATE candidate have)
|
|
set(${have} FALSE PARENT_SCOPE)
|
|
|
|
if("${candidate}" STREQUAL "")
|
|
return()
|
|
endif()
|
|
|
|
if(NOT EXISTS "${candidate}")
|
|
return()
|
|
endif()
|
|
|
|
set(PYTHON_EXECUTABLE "${candidate}")
|
|
gnsssdr_python_get_version()
|
|
|
|
if("${PYTHON_VERSION_STRING}" STREQUAL "")
|
|
return()
|
|
endif()
|
|
|
|
gnsssdr_python_check_min_version(
|
|
${GNSSSDR_PYTHON_MIN_VERSION}
|
|
_GNSSSDR_PYTHON_MIN_VER_FOUND
|
|
)
|
|
if(NOT _GNSSSDR_PYTHON_MIN_VER_FOUND)
|
|
return()
|
|
endif()
|
|
|
|
gnsssdr_python_check_module(
|
|
"mako >= ${GNSSSDR_MAKO_MIN_VERSION}"
|
|
mako
|
|
${GNSSSDR_MAKO_MIN_VERSION}
|
|
_GNSSSDR_MAKO_FOUND
|
|
)
|
|
if(NOT _GNSSSDR_MAKO_FOUND)
|
|
return()
|
|
endif()
|
|
|
|
if(PYTHON_VERSION_STRING VERSION_LESS "3.0")
|
|
gnsssdr_python_check_module(
|
|
"six - python 2 and 3 compatibility library"
|
|
six
|
|
""
|
|
_GNSSSDR_SIX_FOUND
|
|
)
|
|
if(NOT _GNSSSDR_SIX_FOUND)
|
|
return()
|
|
endif()
|
|
else()
|
|
set(_GNSSSDR_SIX_FOUND TRUE)
|
|
endif()
|
|
|
|
set(_GNSSSDR_CANDIDATE_VERSION_STRING "${PYTHON_VERSION_STRING}"
|
|
PARENT_SCOPE)
|
|
set(_GNSSSDR_CANDIDATE_VERSION_MAJOR "${PYTHON_VERSION_MAJOR}"
|
|
PARENT_SCOPE)
|
|
set(_GNSSSDR_CANDIDATE_PYTHON_MIN_VER_FOUND
|
|
"${_GNSSSDR_PYTHON_MIN_VER_FOUND}" PARENT_SCOPE)
|
|
set(_GNSSSDR_CANDIDATE_MAKO_FOUND "${_GNSSSDR_MAKO_FOUND}"
|
|
PARENT_SCOPE)
|
|
set(_GNSSSDR_CANDIDATE_SIX_FOUND "${_GNSSSDR_SIX_FOUND}"
|
|
PARENT_SCOPE)
|
|
set(${have} TRUE PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
########################################################################
|
|
# Select the Python interpreter
|
|
#
|
|
# Strategy:
|
|
# 1) Respect user-provided PYTHON_EXECUTABLE
|
|
# 2) On modern CMake, try Python3 then Python2
|
|
# 3) On old CMake, collect candidates from PythonInterp and explicit names
|
|
# 4) Last resort: find_program()
|
|
#
|
|
# The selected interpreter must satisfy all required module checks.
|
|
########################################################################
|
|
set(_GNSSSDR_PYTHON_CANDIDATES "")
|
|
set(_GNSSSDR_SELECTED_PYTHON "")
|
|
set(_GNSSSDR_USER_PYTHON_EXECUTABLE "")
|
|
|
|
if(DEFINED PYTHON_EXECUTABLE AND NOT "${PYTHON_EXECUTABLE}" STREQUAL "")
|
|
set(_GNSSSDR_USER_PYTHON_EXECUTABLE "${PYTHON_EXECUTABLE}")
|
|
endif()
|
|
|
|
set(PYTHONINTERP_FOUND FALSE)
|
|
set(PYTHON_MIN_VER_FOUND FALSE)
|
|
set(MAKO_FOUND FALSE)
|
|
set(SIX_FOUND FALSE)
|
|
unset(PYTHON_VERSION_MAJOR)
|
|
unset(PYTHON_VERSION_STRING)
|
|
unset(PYTHON3)
|
|
|
|
|
|
########################################################################
|
|
# Build candidate list
|
|
########################################################################
|
|
|
|
# 1) Respect user-provided interpreter first
|
|
if(NOT "${_GNSSSDR_USER_PYTHON_EXECUTABLE}" STREQUAL "")
|
|
message(STATUS
|
|
"User set python executable ${_GNSSSDR_USER_PYTHON_EXECUTABLE}"
|
|
)
|
|
list(APPEND _GNSSSDR_PYTHON_CANDIDATES
|
|
"${_GNSSSDR_USER_PYTHON_EXECUTABLE}"
|
|
)
|
|
endif()
|
|
|
|
# 2) Modern CMake (>= 3.12): prefer Python3, then Python2
|
|
if(NOT CMAKE_VERSION VERSION_LESS "3.12" AND NOT CMAKE_CROSSCOMPILING)
|
|
if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
|
|
set(_GNSSSDR_PREVIOUS_CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK})
|
|
set(CMAKE_FIND_FRAMEWORK LAST)
|
|
endif()
|
|
|
|
unset(Python3_EXECUTABLE)
|
|
unset(Python2_EXECUTABLE)
|
|
unset(Python3_FOUND)
|
|
unset(Python2_FOUND)
|
|
|
|
find_package(Python3 COMPONENTS Interpreter)
|
|
if(Python3_FOUND)
|
|
list(APPEND _GNSSSDR_PYTHON_CANDIDATES "${Python3_EXECUTABLE}")
|
|
else()
|
|
find_package(Python2 COMPONENTS Interpreter)
|
|
if(Python2_FOUND)
|
|
list(APPEND _GNSSSDR_PYTHON_CANDIDATES "${Python2_EXECUTABLE}")
|
|
endif()
|
|
endif()
|
|
|
|
if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
|
|
set(CMAKE_FIND_FRAMEWORK ${_GNSSSDR_PREVIOUS_CMAKE_FIND_FRAMEWORK})
|
|
endif()
|
|
|
|
# 3) Old CMake: use PythonInterp as a candidate source,
|
|
# but still validate the interpreter before accepting it
|
|
else()
|
|
set(Python_ADDITIONAL_VERSIONS
|
|
3.11 3.10 3.9 3.8 3.7 3.6 3.5 3.4 2.7
|
|
)
|
|
if(CMAKE_VERSION VERSION_LESS "2.8.12")
|
|
find_package(PythonInterp)
|
|
else()
|
|
find_package(PythonInterp ${GNSSSDR_PYTHON_MIN_VERSION})
|
|
endif()
|
|
if(PYTHONINTERP_FOUND AND NOT "${PYTHON_EXECUTABLE}" STREQUAL "")
|
|
list(APPEND _GNSSSDR_PYTHON_CANDIDATES "${PYTHON_EXECUTABLE}")
|
|
endif()
|
|
endif()
|
|
|
|
# 4) Last-resort program-name fallbacks, in preferred order
|
|
find_program(_GNSSSDR_PYTHON3 NAMES python3)
|
|
find_program(_GNSSSDR_PYTHON2 NAMES python2.7 python2)
|
|
find_program(_GNSSSDR_PYTHON NAMES python)
|
|
|
|
foreach(_gnsssdr_python_prog
|
|
${_GNSSSDR_PYTHON3}
|
|
${_GNSSSDR_PYTHON2}
|
|
${_GNSSSDR_PYTHON}
|
|
)
|
|
if(NOT "${_gnsssdr_python_prog}" STREQUAL "")
|
|
list(APPEND _GNSSSDR_PYTHON_CANDIDATES "${_gnsssdr_python_prog}")
|
|
endif()
|
|
endforeach()
|
|
|
|
list(REMOVE_DUPLICATES _GNSSSDR_PYTHON_CANDIDATES)
|
|
|
|
|
|
########################################################################
|
|
# Evaluate candidates and accept the first fully suitable interpreter
|
|
########################################################################
|
|
foreach(_GNSSSDR_PYTHON_CANDIDATE IN LISTS _GNSSSDR_PYTHON_CANDIDATES)
|
|
message(STATUS
|
|
"Trying Python candidate: ${_GNSSSDR_PYTHON_CANDIDATE}")
|
|
gnsssdr_python_evaluate_candidate(
|
|
"${_GNSSSDR_PYTHON_CANDIDATE}"
|
|
_GNSSSDR_PYTHON_CANDIDATE_OK
|
|
)
|
|
if(_GNSSSDR_PYTHON_CANDIDATE_OK)
|
|
set(_GNSSSDR_SELECTED_PYTHON "${_GNSSSDR_PYTHON_CANDIDATE}")
|
|
break()
|
|
endif()
|
|
endforeach()
|
|
|
|
if(NOT "${_GNSSSDR_SELECTED_PYTHON}" STREQUAL "")
|
|
set(PYTHON_EXECUTABLE "${_GNSSSDR_SELECTED_PYTHON}")
|
|
set(PYTHONINTERP_FOUND TRUE)
|
|
set(PYTHON_VERSION_STRING "${_GNSSSDR_CANDIDATE_VERSION_STRING}")
|
|
set(PYTHON_VERSION_MAJOR "${_GNSSSDR_CANDIDATE_VERSION_MAJOR}")
|
|
set(PYTHON_MIN_VER_FOUND "${_GNSSSDR_CANDIDATE_PYTHON_MIN_VER_FOUND}")
|
|
set(MAKO_FOUND "${_GNSSSDR_CANDIDATE_MAKO_FOUND}")
|
|
set(SIX_FOUND "${_GNSSSDR_CANDIDATE_SIX_FOUND}")
|
|
else()
|
|
set(PYTHONINTERP_FOUND FALSE)
|
|
unset(PYTHON_EXECUTABLE)
|
|
unset(PYTHON_VERSION_MAJOR)
|
|
unset(PYTHON_VERSION_STRING)
|
|
set(PYTHON_MIN_VER_FOUND FALSE)
|
|
set(MAKO_FOUND FALSE)
|
|
set(SIX_FOUND FALSE)
|
|
endif()
|
|
|
|
|
|
########################################################################
|
|
# Set convenience variables
|
|
########################################################################
|
|
if(DEFINED PYTHON_VERSION_MAJOR AND "${PYTHON_VERSION_MAJOR}" STREQUAL "3")
|
|
set(PYTHON3 TRUE)
|
|
endif()
|
|
|
|
if(CMAKE_CROSSCOMPILING)
|
|
set(QA_PYTHON_EXECUTABLE "/usr/bin/python")
|
|
else()
|
|
set(QA_PYTHON_EXECUTABLE "${PYTHON_EXECUTABLE}")
|
|
endif()
|
|
|
|
# Make the path to the executable appear in the CMake GUI
|
|
set(PYTHON_EXECUTABLE "${PYTHON_EXECUTABLE}" CACHE FILEPATH
|
|
"python interpreter"
|
|
)
|
|
set(QA_PYTHON_EXECUTABLE "${QA_PYTHON_EXECUTABLE}" CACHE FILEPATH
|
|
"python interpreter for QA tests"
|
|
)
|