Files
dl_old/third/python-cmake/cmake/Extensions.cmake
T
2026-02-28 14:40:03 +08:00

244 lines
9.9 KiB
CMake
Vendored

# This function adds a python extension to the buildsystem.
#
# Usage:
#
# add_python_extension(
# extension_name
# SOURCES source1.c source2.c ...
# [ REQUIRES variable1 variable2 ... ]
# [ DEFINITIONS define1 define2 ... ]
# [ LIBRARIES lib1 lib2 ... ]
# [ INCLUDEDIRS dir1 dir2 ... ]
# [ BUILTIN | ALWAYS_BUILTIN | NEVER_BUILTIN ]
# )
#
# extension_name: the name of the library without any .so extension.
# SOURCES: a list of filenames realtive to the Modules/ directory that make
# up this extension.
# REQUIRES: this extension will not be built unless all the variables listed
# here evaluate to true. You should include any variables you use
# in the LIBRARIES and INCLUDEDIRS sections.
# DEFINITIONS: an optional list of definitions to pass to the compiler while
# building this module. Do not include the -D prefix.
# LIBRARIES: an optional list of additional libraries.
# INCLUDEDIRS: an optional list of additional include directories.
# BUILTIN: if this is set the module will be compiled statically into
# libpython by default. The user can still override by setting
# BUILTIN_[extension_name]=OFF.
# ALWAYS_BUILTIN: if this is set the module will always be compiled statically into
# libpython.
# NEVER_BUILTIN: if this is set the module will never be compiled statically into
# libpython. If WITH_STATIC_DEPENDENCIES is ON, extension is disabled.
# NO_INSTALL: do not install or package the extension.
#
# Two user-settable options are created for each extension added:
# ENABLE_[extension_name] defaults to ON. If set to OFF the extension will
# not be added at all.
# BUILTIN_[extension_name] defaults to the value of
# BUILD_EXTENSIONS_AS_BUILTIN, which defaults to OFF,
# unless BUILTIN is set when calling
# add_python_extension. Adds the extension source
# files to libpython instead of compiling a separate
# library.
# These options convert the extension_name to upper case first and remove any
# leading underscores. So add_python_extension(_foo ...) will create the
# options ENABLE_FOO and BUILTIN_FOO.
function(add_python_extension name)
set(options BUILTIN ALWAYS_BUILTIN NEVER_BUILTIN NO_INSTALL)
set(oneValueArgs)
set(multiValueArgs REQUIRES SOURCES DEFINITIONS LIBRARIES INCLUDEDIRS)
cmake_parse_arguments(ADD_PYTHON_EXTENSION
"${options}"
"${oneValueArgs}"
"${multiValueArgs}"
${ARGN}
)
# Remove _ from the beginning of the name.
string(REGEX REPLACE "^_" "" pretty_name "${name}")
# Upper case the name.
string(TOUPPER "${pretty_name}" upper_name)
# Add a prefix to the target name so it doesn't clash with any system
# libraries that we might want to link against (eg. readline)
set(target_name extension_${pretty_name})
set(enable_default ON)
if(ADD_PYTHON_EXTENSION_NEVER_BUILTIN AND WITH_STATIC_DEPENDENCIES)
set(enable_default OFF)
endif()
# Add options that the user can set to control whether this extension is
# compiled, and whether it is compiled in to libpython itself.
option(ENABLE_${upper_name}
"Controls whether the \"${name}\" extension will be built"
${enable_default}
)
if(ENABLE_${upper_name})
mark_as_advanced(FORCE ENABLE_${upper_name})
else()
mark_as_advanced(CLEAR ENABLE_${upper_name})
endif()
if(ADD_PYTHON_EXTENSION_NEVER_BUILTIN AND WITH_STATIC_DEPENDENCIES AND ENABLE_${upper_name})
set(reason " because extension is declared as NEVER_BUILTIN and WITH_STATIC_DEPENDENCIES is ON")
set(ENABLE_${upper_name} OFF CACHE BOOL "Forced to OFF${reason}" FORCE)
message(STATUS "Setting ENABLE_${upper_name} to OFF${reason}")
endif()
# Check all the things we require are found.
set(missing_deps "")
foreach(dep ${ADD_PYTHON_EXTENSION_REQUIRES} ENABLE_${upper_name})
string(REPLACE " " ";" list_dep ${dep})
if(NOT (${list_dep}))
set(missing_deps "${missing_deps}${dep} ")
endif()
endforeach()
if(ADD_PYTHON_EXTENSION_NEVER_BUILTIN)
set(BUILTIN_${upper_name} 0)
elseif(ADD_PYTHON_EXTENSION_ALWAYS_BUILTIN)
set(BUILTIN_${upper_name} 1)
else()
# Add options that the extention is either external to libpython or
# builtin. These will be marked as advanced unless different from default
# values
if(NOT ADD_PYTHON_EXTENSION_BUILTIN)
set(ADD_PYTHON_EXTENSION_BUILTIN ${BUILD_EXTENSIONS_AS_BUILTIN})
endif()
cmake_dependent_option(
BUILTIN_${upper_name}
"If this is set the \"${name}\" extension will be compiled in to libpython"
${ADD_PYTHON_EXTENSION_BUILTIN}
"NOT missing_deps"
OFF
)
if(NOT missing_deps)
if((BUILTIN_${upper_name} AND BUILD_EXTENSIONS_AS_BUILTIN)
OR (NOT BUILTIN_${upper_name} AND NOT BUILD_EXTENSIONS_AS_BUILTIN))
mark_as_advanced(FORCE BUILTIN_${upper_name})
else()
mark_as_advanced(CLEAR BUILTIN_${upper_name})
endif()
endif()
endif()
# If any dependencies were missing don't include this extension.
if(missing_deps)
string(STRIP "${missing_deps}" missing_deps)
set(extensions_disabled "${extensions_disabled}${name} (not set: ${missing_deps});"
CACHE INTERNAL "" FORCE)
return()
else()
set(extensions_enabled "${extensions_enabled}${name};" CACHE INTERNAL "" FORCE)
endif()
# Callers to this function provide source files relative to the Modules/
# directory. We need to get absolute paths for them all.
set(absolute_sources "")
foreach(source ${ADD_PYTHON_EXTENSION_SOURCES})
get_filename_component(ext ${source} EXT)
# Treat assembler sources differently
if(ext STREQUAL ".S")
set_source_files_properties(Modules/${source} PROPERTIES LANGUAGE ASM)
endif()
set(absolute_src ${source})
if(NOT IS_ABSOLUTE ${source})
set(absolute_src ${SRC_DIR}/Modules/${source})
endif()
list(APPEND absolute_sources ${absolute_src})
endforeach()
if(BUILTIN_${upper_name})
if(PY_VERSION VERSION_GREATER_EQUAL "3.8")
list(APPEND ADD_PYTHON_EXTENSION_DEFINITIONS Py_BUILD_CORE_BUILTIN)
endif()
# This will be compiled into libpython instead of as a separate library
set_property(GLOBAL APPEND PROPERTY builtin_extensions ${name})
set_property(GLOBAL APPEND PROPERTY extension_${name}_sources ${absolute_sources})
set_property(GLOBAL APPEND PROPERTY extension_${name}_link_libraries ${ADD_PYTHON_EXTENSION_LIBRARIES})
set_property(GLOBAL APPEND PROPERTY extension_${name}_includedirs ${ADD_PYTHON_EXTENSION_INCLUDEDIRS})
set_property(GLOBAL APPEND PROPERTY extension_${name}_definitions ${ADD_PYTHON_EXTENSION_DEFINITIONS})
elseif(WIN32 AND NOT BUILD_LIBPYTHON_SHARED)
# Extensions cannot be built against a static libpython on windows
else()
add_library(${target_name} SHARED ${absolute_sources})
target_include_directories(${target_name} PUBLIC "${ADD_PYTHON_EXTENSION_INCLUDEDIRS}")
if(PY_VERSION VERSION_GREATER_EQUAL "3.8")
list(APPEND ADD_PYTHON_EXTENSION_DEFINITIONS Py_BUILD_CORE_MODULE)
endif()
if(WIN32)
string(REGEX MATCH "Py_LIMITED_API" require_limited_api "${ADD_PYTHON_EXTENSION_DEFINITIONS}")
if(require_limited_api STREQUAL "")
list(APPEND ADD_PYTHON_EXTENSION_LIBRARIES libpython-shared)
else()
list(APPEND ADD_PYTHON_EXTENSION_LIBRARIES libpython3-shared)
endif()
endif()
target_link_libraries(${target_name} ${ADD_PYTHON_EXTENSION_LIBRARIES})
if(WIN32)
#list(APPEND ADD_PYTHON_EXTENSION_DEFINITIONS Py_NO_ENABLE_SHARED)
if(MINGW)
set_target_properties(${target_name} PROPERTIES
LINK_FLAGS -Wl,--enable-auto-import
)
endif()
set_target_properties(${target_name} PROPERTIES
SUFFIX .pyd
)
endif()
if(APPLE)
set_target_properties(${target_name} PROPERTIES
LINK_FLAGS -Wl,-undefined,dynamic_lookup
SUFFIX .so
)
endif()
# Turn off the "lib" prefix and add any compiler definitions
set_target_properties(${target_name} PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/${ARCHIVEDIR}
LIBRARY_OUTPUT_DIRECTORY ${EXTENSION_BUILD_DIR}
RUNTIME_OUTPUT_DIRECTORY ${EXTENSION_BUILD_DIR}
OUTPUT_NAME "${name}$<$<AND:$<BOOL:${UNIX}>,$<VERSION_GREATER_EQUAL:${PY_VERSION},3.8>>:.${SOABI}>"
PREFIX ""
)
set_target_properties(${target_name} PROPERTIES
POSITION_INDEPENDENT_CODE ON
)
if(ADD_PYTHON_EXTENSION_DEFINITIONS)
set_target_properties(${target_name} PROPERTIES
COMPILE_DEFINITIONS "${ADD_PYTHON_EXTENSION_DEFINITIONS}")
endif()
if(NOT ADD_PYTHON_EXTENSION_NO_INSTALL)
install(TARGETS ${target_name}
ARCHIVE DESTINATION ${ARCHIVEDIR}
LIBRARY DESTINATION ${EXTENSION_INSTALL_DIR}
RUNTIME DESTINATION ${EXTENSION_INSTALL_DIR})
endif()
endif()
endfunction()
function(show_extension_summary)
if(extensions_disabled)
message(STATUS "")
message(STATUS "The following extensions will NOT be built:")
message(STATUS "")
foreach(line ${extensions_disabled})
message(STATUS " ${line}")
endforeach()
message(STATUS "")
endif()
endfunction()