diff --git a/debian/NEWS b/debian/NEWS new file mode 100644 index 000000000..b063e8057 --- /dev/null +++ b/debian/NEWS @@ -0,0 +1,9 @@ +cmake (2.8.7-4) unstable; urgency=low + + From now on, pass either -DPythonInterp_FIND_VERSION= or + -DPythonLibs_FIND_VERSION= respectively in order to tell cmake to + look for the specific Python version. However, if an explicit Python version + is requested via find_package(), it will override the one specified on the + command line. + + -- Modestas Vainius Fri, 16 Mar 2012 22:15:23 +0200 diff --git a/debian/changelog b/debian/changelog index aa484dd41..cf5ae8a25 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,5 +1,9 @@ cmake (2.8.7-4) UNRELEASED; urgency=low + * Backport a bunch of FindPython* related commits from cmake master. It + is now possible to force a specific python version via command line again. + The interface has changed though, see NEWS entry. (Closes: #663188) + Patch: backport_findpython_fixes.diff -- Modestas Vainius Fri, 16 Mar 2012 22:10:41 +0200 diff --git a/debian/patches/backport_findpython_fixes.diff b/debian/patches/backport_findpython_fixes.diff new file mode 100644 index 000000000..dd7ff4b7a --- /dev/null +++ b/debian/patches/backport_findpython_fixes.diff @@ -0,0 +1,282 @@ +From: Rolf Eike Beer +Subject: Various FindPython* fixes +Bug-Debian: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=663188 +Applied-Upstream: 2.8.8 +Origin: backport, commit:a04ced3 FindPythonLibs: Search for single-user installs on Windows + commit:0fe4d69 FindPythonInterp: make version selectable + commit:aa11536 FindPythonInterp: fix version parsing + commit:bde7b5a FindPythonInterp: try harder to get a version number + commit:bbddaee FindPython{Interp,Libs}: document Python_ADDITIONAL_VERSIONS as input + commit:f772378 FindPythonLibs: make the version selection work as for PythonInterp + commit:c9c1a17 FindPythonLibs: get the exact version of the found library (#3080) + commit:91d5a2a FindPythonLibs: put debug libraries into PYTHON_LIBRARIES + commit:7d6db93 FindPythonInterp: rework the version detection + commit:53d02ea FindPythonLibs: stop scanning when libraries are found + commit:fc495b7 Merge topic 'findpythoninterp-version-detection' +Last-Update: 2012-03-16 + +The main feature is support for: + + -DPythonLibs_FIND_VERSION= and + -DPythonInterp_FIND_VERSION= + +--- a/Modules/FindPythonLibs.cmake ++++ b/Modules/FindPythonLibs.cmake +@@ -7,8 +7,12 @@ + # PYTHON_LIBRARIES - path to the python library + # PYTHON_INCLUDE_PATH - path to where Python.h is found (deprecated) + # PYTHON_INCLUDE_DIRS - path to where Python.h is found +-# PYTHON_DEBUG_LIBRARIES - path to the debug library +-# Python_ADDITIONAL_VERSIONS - list of additional Python versions to search for ++# PYTHON_DEBUG_LIBRARIES - path to the debug library (deprecated) ++# PYTHONLIBS_VERSION_STRING - version of the Python libs found (since CMake 2.8.8) ++# ++# The Python_ADDITIONAL_VERSIONS variable can be used to specify a list of ++# version numbers that should be taken into account when searching for Python. ++# You need to set this variable before calling find_package(PythonLibs). + + #============================================================================= + # Copyright 2001-2009 Kitware, Inc. +@@ -27,11 +31,42 @@ INCLUDE(CMakeFindFrameworks) + # Search for the python framework on Apple. + CMAKE_FIND_FRAMEWORKS(Python) + ++SET(_PYTHON1_VERSIONS 1.6 1.5) ++SET(_PYTHON2_VERSIONS 2.7 2.6 2.5 2.4 2.3 2.2 2.1 2.0) ++SET(_PYTHON3_VERSIONS 3.3 3.2 3.1 3.0) ++ ++IF(PythonLibs_FIND_VERSION) ++ IF(PythonLibs_FIND_VERSION MATCHES "^[0-9]+\\.[0-9]+(\\.[0-9]+.*)?$") ++ STRING(REGEX REPLACE "^([0-9]+\\.[0-9]+).*" "\\1" _PYTHON_FIND_MAJ_MIN "${PythonLibs_FIND_VERSION}") ++ STRING(REGEX REPLACE "^([0-9]+).*" "\\1" _PYTHON_FIND_MAJ "${_PYTHON_FIND_MAJ_MIN}") ++ UNSET(_PYTHON_FIND_OTHER_VERSIONS) ++ IF(NOT PythonLibs_FIND_VERSION_EXACT) ++ FOREACH(_PYTHON_V ${_PYTHON${_PYTHON_FIND_MAJ}_VERSIONS}) ++ IF(NOT _PYTHON_V VERSION_LESS _PYTHON_FIND_MAJ_MIN) ++ LIST(APPEND _PYTHON_FIND_OTHER_VERSIONS ${_PYTHON_V}) ++ ENDIF() ++ ENDFOREACH() ++ ENDIF(NOT PythonLibs_FIND_VERSION_EXACT) ++ UNSET(_PYTHON_FIND_MAJ_MIN) ++ UNSET(_PYTHON_FIND_MAJ) ++ ELSE(PythonLibs_FIND_VERSION MATCHES "^[0-9]+\\.[0-9]+(\\.[0-9]+.*)?$") ++ SET(_PYTHON_FIND_OTHER_VERSIONS ${_PYTHON${PythonLibs_FIND_VERSION}_VERSIONS}) ++ ENDIF(PythonLibs_FIND_VERSION MATCHES "^[0-9]+\\.[0-9]+(\\.[0-9]+.*)?$") ++ELSE(PythonLibs_FIND_VERSION) ++ SET(_PYTHON_FIND_OTHER_VERSIONS ${_PYTHON3_VERSIONS} ${_PYTHON2_VERSIONS} ${_PYTHON1_VERSIONS}) ++ENDIF(PythonLibs_FIND_VERSION) ++ + # Set up the versions we know about, in the order we will search. Always add + # the user supplied additional versions to the front. +-set(_Python_VERSIONS ++SET(_Python_VERSIONS + ${Python_ADDITIONAL_VERSIONS} +- 2.7 2.6 2.5 2.4 2.3 2.2 2.1 2.0 1.6 1.5) ++ ${_PYTHON_FIND_OTHER_VERSIONS} ++ ) ++ ++UNSET(_PYTHON_FIND_OTHER_VERSIONS) ++UNSET(_PYTHON1_VERSIONS) ++UNSET(_PYTHON2_VERSIONS) ++UNSET(_PYTHON3_VERSIONS) + + FOREACH(_CURRENT_VERSION ${_Python_VERSIONS}) + STRING(REPLACE "." "" _CURRENT_VERSION_NO_DOTS ${_CURRENT_VERSION}) +@@ -40,13 +75,17 @@ FOREACH(_CURRENT_VERSION ${_Python_VERSI + NAMES python${_CURRENT_VERSION_NO_DOTS}_d python + PATHS + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs/Debug +- [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs ) ++ [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs/Debug ++ [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs ++ [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs ++ ) + ENDIF(WIN32) + + FIND_LIBRARY(PYTHON_LIBRARY + NAMES python${_CURRENT_VERSION_NO_DOTS} python${_CURRENT_VERSION} + PATHS + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs ++ [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/libs + # Avoid finding the .dll in the PATH. We want the .lib. + NO_SYSTEM_ENVIRONMENT_PATH + ) +@@ -79,6 +118,7 @@ FOREACH(_CURRENT_VERSION ${_Python_VERSI + PATHS + ${PYTHON_FRAMEWORK_INCLUDES} + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/include ++ [HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_CURRENT_VERSION}\\InstallPath]/include + PATH_SUFFIXES + python${_CURRENT_VERSION} + ) +@@ -87,6 +127,17 @@ FOREACH(_CURRENT_VERSION ${_Python_VERSI + SET(PYTHON_INCLUDE_PATH "${PYTHON_INCLUDE_DIR}" CACHE INTERNAL + "Path to where Python.h is found (deprecated)") + ++ IF(PYTHON_INCLUDE_DIR AND EXISTS "${PYTHON_INCLUDE_DIR}/patchlevel.h") ++ FILE(STRINGS "${PYTHON_INCLUDE_DIR}/patchlevel.h" python_version_str ++ REGEX "^#define[ \t]+PY_VERSION[ \t]+\"[^\"]+\"") ++ STRING(REGEX REPLACE "^#define[ \t]+PY_VERSION[ \t]+\"([^\"]+)\".*" "\\1" ++ PYTHONLIBS_VERSION_STRING "${python_version_str}") ++ UNSET(python_version_str) ++ ENDIF(PYTHON_INCLUDE_DIR AND EXISTS "${PYTHON_INCLUDE_DIR}/patchlevel.h") ++ ++ IF(PYTHON_LIBRARY AND PYTHON_INCLUDE_DIR) ++ BREAK() ++ ENDIF(PYTHON_LIBRARY AND PYTHON_INCLUDE_DIR) + ENDFOREACH(_CURRENT_VERSION) + + MARK_AS_ADVANCED( +@@ -100,13 +151,23 @@ MARK_AS_ADVANCED( + # library. We now set the variables listed by the documentation for this + # module. + SET(PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIR}") +-SET(PYTHON_LIBRARIES "${PYTHON_LIBRARY}") + SET(PYTHON_DEBUG_LIBRARIES "${PYTHON_DEBUG_LIBRARY}") + ++# These variables have been historically named in this module different from ++# what SELECT_LIBRARY_CONFIGURATIONS() expects. ++SET(PYTHON_LIBRARY_DEBUG "${PYTHON_DEBUG_LIBRARY}") ++SET(PYTHON_LIBRARY_RELEASE "${PYTHON_LIBRARY}") ++INCLUDE(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake) ++SELECT_LIBRARY_CONFIGURATIONS(PYTHON) ++# SELECT_LIBRARY_CONFIGURATIONS() sets ${PREFIX}_FOUND if it has a library. ++# Unset this, this prefix doesn't match the module prefix, they are different ++# for historical reasons. ++UNSET(PYTHON_FOUND) + + INCLUDE(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) +-FIND_PACKAGE_HANDLE_STANDARD_ARGS(PythonLibs DEFAULT_MSG PYTHON_LIBRARIES PYTHON_INCLUDE_DIRS) +- ++FIND_PACKAGE_HANDLE_STANDARD_ARGS(PythonLibs ++ REQUIRED_VARS PYTHON_LIBRARIES PYTHON_INCLUDE_DIRS ++ VERSION_VAR PYTHONLIBS_VERSION_STRING) + + # PYTHON_ADD_MODULE( src1 src2 ... srcN) is used to build modules for python. + # PYTHON_WRITE_MODULES_HEADER() writes a header file you can include +--- a/Modules/FindPythonInterp.cmake ++++ b/Modules/FindPythonInterp.cmake +@@ -10,11 +10,14 @@ + # PYTHON_VERSION_MINOR - Python minor version found e.g. 5 + # PYTHON_VERSION_PATCH - Python patch version found e.g. 2 + # +-# Python_ADDITIONAL_VERSIONS - list of additional Python versions to search for ++# The Python_ADDITIONAL_VERSIONS variable can be used to specify a list of ++# version numbers that should be taken into account when searching for Python. ++# You need to set this variable before calling find_package(PythonInterp). + + #============================================================================= + # Copyright 2005-2010 Kitware, Inc. + # Copyright 2011 Bjoern Ricks ++# Copyright 2012 Rolf Eike Beer + # + # Distributed under the OSI-approved BSD License (the "License"); + # see accompanying file Copyright.txt for details. +@@ -26,14 +29,51 @@ + # (To distribute this file outside of CMake, substitute the full + # License text for the above reference.) + ++unset(_Python_NAMES) ++ ++set(_PYTHON1_VERSIONS 1.6 1.5) ++set(_PYTHON2_VERSIONS 2.7 2.6 2.5 2.4 2.3 2.2 2.1 2.0) ++set(_PYTHON3_VERSIONS 3.3 3.2 3.1 3.0) ++ ++if(PythonInterp_FIND_VERSION) ++ if(PythonInterp_FIND_VERSION MATCHES "^[0-9]+\\.[0-9]+(\\.[0-9]+.*)?$") ++ string(REGEX REPLACE "^([0-9]+\\.[0-9]+).*" "\\1" _PYTHON_FIND_MAJ_MIN "${PythonInterp_FIND_VERSION}") ++ string(REGEX REPLACE "^([0-9]+).*" "\\1" _PYTHON_FIND_MAJ "${_PYTHON_FIND_MAJ_MIN}") ++ list(APPEND _Python_NAMES python${_PYTHON_FIND_MAJ_MIN} python${_PYTHON_FIND_MAJ}) ++ unset(_PYTHON_FIND_OTHER_VERSIONS) ++ if(NOT PythonInterp_FIND_VERSION_EXACT) ++ foreach(_PYTHON_V ${_PYTHON${_PYTHON_FIND_MAJ}_VERSIONS}) ++ if(NOT _PYTHON_V VERSION_LESS _PYTHON_FIND_MAJ_MIN) ++ list(APPEND _PYTHON_FIND_OTHER_VERSIONS ${_PYTHON_V}) ++ endif() ++ endforeach() ++ endif(NOT PythonInterp_FIND_VERSION_EXACT) ++ unset(_PYTHON_FIND_MAJ_MIN) ++ unset(_PYTHON_FIND_MAJ) ++ else(PythonInterp_FIND_VERSION MATCHES "^[0-9]+\\.[0-9]+(\\.[0-9]+.*)?$") ++ list(APPEND _Python_NAMES python${PythonInterp_FIND_VERSION}) ++ set(_PYTHON_FIND_OTHER_VERSIONS ${_PYTHON${PythonInterp_FIND_VERSION}_VERSIONS}) ++ endif(PythonInterp_FIND_VERSION MATCHES "^[0-9]+\\.[0-9]+(\\.[0-9]+.*)?$") ++else(PythonInterp_FIND_VERSION) ++ set(_PYTHON_FIND_OTHER_VERSIONS ${_PYTHON3_VERSIONS} ${_PYTHON2_VERSIONS} ${_PYTHON1_VERSIONS}) ++endif(PythonInterp_FIND_VERSION) ++ ++list(APPEND _Python_NAMES python) ++ + # Search for the current active python version first +-find_program(PYTHON_EXECUTABLE NAMES python) ++find_program(PYTHON_EXECUTABLE NAMES ${_Python_NAMES}) + + # Set up the versions we know about, in the order we will search. Always add + # the user supplied additional versions to the front. + set(_Python_VERSIONS + ${Python_ADDITIONAL_VERSIONS} +- 2.7 2.6 2.5 2.4 2.3 2.2 2.1 2.0 1.6 1.5) ++ ${_PYTHON_FIND_OTHER_VERSIONS} ++ ) ++ ++unset(_PYTHON_FIND_OTHER_VERSIONS) ++unset(_PYTHON1_VERSIONS) ++unset(_PYTHON2_VERSIONS) ++unset(_PYTHON3_VERSIONS) + + # Search for newest python version if python executable isn't found + if(NOT PYTHON_EXECUTABLE) +@@ -51,12 +91,47 @@ endif() + + # determine python version string + if(PYTHON_EXECUTABLE) +- execute_process(COMMAND "${PYTHON_EXECUTABLE}" --version ERROR_VARIABLE _VERSION OUTPUT_QUIET ERROR_STRIP_TRAILING_WHITESPACE) +- string(REPLACE "Python " "" PYTHON_VERSION_STRING "${_VERSION}") +- string(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" PYTHON_VERSION_MAJOR "${PYTHON_VERSION_STRING}") +- string(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" PYTHON_VERSION_MINOR "${PYTHON_VERSION_STRING}") +- string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" PYTHON_VERSION_PATCH "${PYTHON_VERSION_STRING}") +-endif() ++ execute_process(COMMAND "${PYTHON_EXECUTABLE}" -c ++ "import sys; sys.stdout.write(';'.join([str(x) for x in sys.version_info[:3]]))" ++ OUTPUT_VARIABLE _VERSION ++ RESULT_VARIABLE _PYTHON_VERSION_RESULT ++ ERROR_QUIET) ++ if(NOT _PYTHON_VERSION_RESULT) ++ string(REPLACE ";" "." PYTHON_VERSION_STRING "${_VERSION}") ++ list(GET _VERSION 0 PYTHON_VERSION_MAJOR) ++ list(GET _VERSION 1 PYTHON_VERSION_MINOR) ++ list(GET _VERSION 2 PYTHON_VERSION_PATCH) ++ if(PYTHON_VERSION_PATCH EQUAL 0) ++ # it's called "Python 2.7", not "2.7.0" ++ string(REGEX REPLACE "\\.0$" "" PYTHON_VERSION_STRING "${PYTHON_VERSION_STRING}") ++ endif() ++ else() ++ # sys.version predates sys.version_info, so use that ++ execute_process(COMMAND "${PYTHON_EXECUTABLE}" -c "import sys; sys.stdout.write(sys.version)" ++ OUTPUT_VARIABLE _VERSION ++ RESULT_VARIABLE _PYTHON_VERSION_RESULT ++ ERROR_QUIET) ++ if(NOT _PYTHON_VERSION_RESULT) ++ string(REGEX REPLACE " .*" "" PYTHON_VERSION_STRING "${_VERSION}") ++ string(REGEX REPLACE "^([0-9]+)\\.[0-9]+.*" "\\1" PYTHON_VERSION_MAJOR "${PYTHON_VERSION_STRING}") ++ string(REGEX REPLACE "^[0-9]+\\.([0-9])+.*" "\\1" PYTHON_VERSION_MINOR "${PYTHON_VERSION_STRING}") ++ if(PYTHON_VERSION_STRING MATCHES "^[0-9]+\\.[0-9]+\\.[0-9]+.*") ++ string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" PYTHON_VERSION_PATCH "${PYTHON_VERSION_STRING}") ++ else() ++ set(PYTHON_VERSION_PATCH "0") ++ endif() ++ else() ++ # sys.version was first documented for Python 1.5, so assume ++ # this is older. ++ set(PYTHON_VERSION_STRING "1.4") ++ set(PYTHON_VERSION_MAJOR "1") ++ set(PYTHON_VERSION_MAJOR "4") ++ set(PYTHON_VERSION_MAJOR "0") ++ endif() ++ endif() ++ unset(_PYTHON_VERSION_RESULT) ++ unset(_VERSION) ++endif(PYTHON_EXECUTABLE) + + # handle the QUIETLY and REQUIRED arguments and set PYTHONINTERP_FOUND to TRUE if + # all listed variables are TRUE diff --git a/debian/patches/series b/debian/patches/series index 1bd211684..9eada996a 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -3,3 +3,4 @@ multiarch_findgtk2_fix.diff manpage_fixes.diff mipsel_is_little_endian.diff paths_in_regex_espace_metachars.diff +backport_findpython_fixes.diff