84 changed files with 3654 additions and 329 deletions
@ -0,0 +1,66 @@
|
||||
cmake_minimum_required(VERSION 3.5) |
||||
project (noisicaä) |
||||
|
||||
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/cmake) |
||||
|
||||
find_package(Cython REQUIRED) |
||||
|
||||
if("$ENV{VIRTUAL_ENV}" STREQUAL "") |
||||
message(FATAL_ERROR "Not running in a virtual env.") |
||||
endif("$ENV{VIRTUAL_ENV}" STREQUAL "") |
||||
|
||||
find_package(PythonLibs REQUIRED) |
||||
include_directories(${PYTHON_INCLUDE_DIRS}) |
||||
|
||||
set(ENV{PKG_CONFIG_PATH} $ENV{VIRTUAL_ENV}/lib/pkgconfig) |
||||
find_package(PkgConfig) |
||||
pkg_check_modules(LIBSRATOM REQUIRED sratom-0) |
||||
pkg_check_modules(LIBLILV REQUIRED lilv-0) |
||||
pkg_check_modules(LIBSNDFILE REQUIRED sndfile) |
||||
pkg_check_modules(LIBFLUIDSYNTH REQUIRED fluidsynth) |
||||
|
||||
set(LIBCSOUND_INCLUDE_DIRS) |
||||
set(LIBCSOUND_LIBRARIES csound64) |
||||
|
||||
include_directories(${CMAKE_CURRENT_LIST_DIR}) |
||||
include_directories($ENV{VIRTUAL_ENV}/include) |
||||
link_directories($ENV{VIRTUAL_ENV}/lib) |
||||
|
||||
macro(add_python_package) |
||||
foreach(src __init__.py ${ARGN}) |
||||
add_custom_command( |
||||
OUTPUT ${src} |
||||
COMMAND ln -sf ${CMAKE_CURRENT_LIST_DIR}/${src} ${src} |
||||
DEPENDS ${CMAKE_CURRENT_LIST_DIR}/${src} |
||||
) |
||||
endforeach(src) |
||||
file(RELATIVE_PATH pkg_path ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_LIST_DIR}) |
||||
string(REGEX REPLACE "/" "." pkg_target ${pkg_path}) |
||||
add_custom_target("pkg-${pkg_target}" ALL DEPENDS __init__.py ${ARGN}) |
||||
endmacro(add_python_package) |
||||
|
||||
macro(add_cython_module mod lang) |
||||
file(RELATIVE_PATH pkg_path ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_LIST_DIR}) |
||||
string(REGEX REPLACE "/" "." pkg_target ${pkg_path}) |
||||
add_cython_target(${mod} ${mod}.pyx ${lang} PY3) |
||||
add_library(${pkg_target}.${mod} MODULE ${${mod}}) |
||||
set_target_properties(${pkg_target}.${mod} PROPERTIES PREFIX "" OUTPUT_NAME ${mod}) |
||||
set(${mod}.so ${pkg_target}.${mod}) |
||||
endmacro(add_cython_module) |
||||
|
||||
macro(add_capnp src) |
||||
add_custom_command( |
||||
OUTPUT ${src} |
||||
COMMAND ln -sf ${CMAKE_CURRENT_LIST_DIR}/${src} ${src} |
||||
DEPENDS ${CMAKE_CURRENT_LIST_DIR}/${src} |
||||
) |
||||
file(RELATIVE_PATH pkg_path ${CMAKE_SOURCE_DIR} ${CMAKE_CURRENT_LIST_DIR}) |
||||
string(REGEX REPLACE "/" "." pkg_target ${pkg_path}) |
||||
add_custom_target(${pkg_target}.${src} ALL DEPENDS ${src}) |
||||
endmacro(add_capnp) |
||||
|
||||
add_subdirectory(noisicore) |
||||
add_subdirectory(noisicaa) |
||||
add_subdirectory(noisidev) |
||||
|
||||
file(COPY data DESTINATION .) |
||||
@ -1,6 +1,8 @@
|
||||
#!/bin/bash |
||||
|
||||
LIBDIR=$(readlink -f "$(dirname "$0")/..") |
||||
LIBDIR=$(readlink -f "$(dirname "$0")/../build") |
||||
(cd $LIBDIR && make) |
||||
export PYTHONPATH="$LIBDIR:$PYTHONPATH" |
||||
export LD_LIBRARY_PATH=${VIRTUAL_ENV}/lib |
||||
cd $HOME |
||||
exec python3 -m noisicaa.editor_main "$@" |
||||
|
||||
@ -0,0 +1,78 @@
|
||||
#.rst: |
||||
# |
||||
# Find ``cython`` executable. |
||||
# |
||||
# This module will set the following variables in your project: |
||||
# |
||||
# ``CYTHON_EXECUTABLE`` |
||||
# path to the ``cython`` program |
||||
# |
||||
# ``CYTHON_VERSION`` |
||||
# version of ``cython`` |
||||
# |
||||
# ``CYTHON_FOUND`` |
||||
# true if the program was found |
||||
# |
||||
# For more information on the Cython project, see http://cython.org/. |
||||
# |
||||
# *Cython is a language that makes writing C extensions for the Python language |
||||
# as easy as Python itself.* |
||||
# |
||||
#============================================================================= |
||||
# Copyright 2011 Kitware, Inc. |
||||
# |
||||
# Licensed under the Apache License, Version 2.0 (the "License"); |
||||
# you may not use this file except in compliance with the License. |
||||
# You may obtain a copy of the License at |
||||
# |
||||
# http://www.apache.org/licenses/LICENSE-2.0 |
||||
# |
||||
# Unless required by applicable law or agreed to in writing, software |
||||
# distributed under the License is distributed on an "AS IS" BASIS, |
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
# See the License for the specific language governing permissions and |
||||
# limitations under the License. |
||||
#============================================================================= |
||||
|
||||
# Use the Cython executable that lives next to the Python executable |
||||
# if it is a local installation. |
||||
find_package(PythonInterp) |
||||
if(PYTHONINTERP_FOUND) |
||||
get_filename_component(_python_path ${PYTHON_EXECUTABLE} PATH) |
||||
find_program(CYTHON_EXECUTABLE |
||||
NAMES cython cython.bat cython3 |
||||
HINTS ${_python_path} |
||||
DOC "path to the cython executable") |
||||
else() |
||||
find_program(CYTHON_EXECUTABLE |
||||
NAMES cython cython.bat cython3 |
||||
DOC "path to the cython executable") |
||||
endif() |
||||
|
||||
if(CYTHON_EXECUTABLE) |
||||
set(CYTHON_version_command ${CYTHON_EXECUTABLE} --version) |
||||
|
||||
execute_process(COMMAND ${CYTHON_version_command} |
||||
OUTPUT_VARIABLE CYTHON_version_output |
||||
ERROR_VARIABLE CYTHON_version_error |
||||
RESULT_VARIABLE CYTHON_version_result |
||||
OUTPUT_STRIP_TRAILING_WHITESPACE) |
||||
|
||||
if(NOT ${CYTHON_version_result} EQUAL 0) |
||||
set(_error_msg "Command \"${CYTHON_version_command}\" failed with") |
||||
set(_error_msg "${_error_msg} output:\n${CYTHON_version_error}") |
||||
message(SEND_ERROR "${_error_msg}") |
||||
else() |
||||
if("${CYTHON_version_output}" MATCHES "^[Cc]ython version ([^,]+)") |
||||
set(CYTHON_VERSION "${CMAKE_MATCH_1}") |
||||
endif() |
||||
endif() |
||||
endif() |
||||
|
||||
include(FindPackageHandleStandardArgs) |
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(Cython REQUIRED_VARS CYTHON_EXECUTABLE) |
||||
|
||||
mark_as_advanced(CYTHON_EXECUTABLE) |
||||
|
||||
include(UseCython) |
||||
|
||||
@ -0,0 +1,63 @@
|
||||
#.rst: |
||||
# |
||||
# Find the include directory for numpy/arrayobject.h |
||||
# |
||||
# This module sets the following variables: |
||||
# |
||||
# ``NumPy_FOUND`` |
||||
# True if NumPy was found. |
||||
# ``NumPy_INCLUDE_DIR`` |
||||
# The include directories needed to use NumpPy. |
||||
# ``NumPy_VERSION`` |
||||
# The version of NumPy found. |
||||
# |
||||
# |
||||
# The module will also explicitly define one cache variable: |
||||
# |
||||
# ``NumPy_INCLUDE_DIR`` |
||||
# |
||||
|
||||
if(NOT NumPy_FOUND) |
||||
set(_find_extra_args) |
||||
if(NumPy_FIND_REQUIRED) |
||||
list(APPEND _find_extra_args REQUIRED) |
||||
endif() |
||||
if(NumPy_FIND_QUIET) |
||||
list(APPEND _find_extra_args QUIET) |
||||
endif() |
||||
find_package(PythonInterp ${_find_extra_args}) |
||||
find_package(PythonLibs ${_find_extra_args}) |
||||
|
||||
if(PYTHON_EXECUTABLE) |
||||
execute_process(COMMAND "${PYTHON_EXECUTABLE}" |
||||
-c "import numpy; print(numpy.get_include())" |
||||
OUTPUT_VARIABLE _numpy_include_dir |
||||
OUTPUT_STRIP_TRAILING_WHITESPACE |
||||
ERROR_QUIET |
||||
) |
||||
execute_process(COMMAND "${PYTHON_EXECUTABLE}" |
||||
-c "import numpy; print(numpy.__version__)" |
||||
OUTPUT_VARIABLE NumPy_VERSION |
||||
OUTPUT_STRIP_TRAILING_WHITESPACE |
||||
ERROR_QUIET |
||||
) |
||||
endif() |
||||
endif() |
||||
|
||||
find_path(NumPy_INCLUDE_DIR |
||||
numpy/arrayobject.h |
||||
PATHS "${_numpy_include_dir}" "${PYTHON_INCLUDE_DIR}" |
||||
PATH_SUFFIXES numpy/core/include |
||||
) |
||||
|
||||
set(NumPy_INCLUDE_DIRS ${NumPy_INCLUDE_DIR}) |
||||
|
||||
# handle the QUIETLY and REQUIRED arguments and set NumPy_FOUND to TRUE if |
||||
# all listed variables are TRUE |
||||
include(FindPackageHandleStandardArgs) |
||||
find_package_handle_standard_args(NumPy |
||||
REQUIRED_VARS NumPy_INCLUDE_DIR |
||||
VERSION_VAR NumPy_VERSION |
||||
) |
||||
|
||||
mark_as_advanced(NumPy_INCLUDE_DIR) |
||||
@ -0,0 +1,539 @@
|
||||
#.rst: |
||||
# |
||||
# This module defines CMake functions to build Python extension modules and |
||||
# stand-alone executables. |
||||
# |
||||
# The following variables are defined: |
||||
# :: |
||||
# |
||||
# PYTHON_PREFIX - absolute path to the current Python |
||||
# distribution's prefix |
||||
# PYTHON_SITE_PACKAGES_DIR - absolute path to the current Python |
||||
# distribution's site-packages directory |
||||
# PYTHON_RELATIVE_SITE_PACKAGES_DIR - path to the current Python |
||||
# distribution's site-packages directory |
||||
# relative to its prefix |
||||
# PYTHON_SEPARATOR - separator string for file path |
||||
# components. Equivalent to ``os.sep`` in |
||||
# Python. |
||||
# PYTHON_PATH_SEPARATOR - separator string for PATH-style |
||||
# environment variables. Equivalent to |
||||
# ``os.pathsep`` in Python. |
||||
# |
||||
# |
||||
# The following functions are defined: |
||||
# |
||||
# .. cmake:command:: python_extension_module |
||||
# |
||||
# For libraries meant to be used as Python extension modules, either dynamically |
||||
# loaded or directly linked. Amend the configuration of the library target |
||||
# (created using ``add_library``) with additional options needed to build and |
||||
# use the referenced library as a Python extension module. |
||||
# |
||||
# python_extension_module(<Target> |
||||
# [LINKED_MODULES_VAR <LinkedModVar>] |
||||
# [FORWARD_DECL_MODULES_VAR <ForwardDeclModVar>] |
||||
# [MODULE_SUFFIX <ModuleSuffix>]) |
||||
# |
||||
# Only extension modules that are configured to be built as MODULE libraries can |
||||
# be runtime-loaded through the standard Python import mechanism. All other |
||||
# modules can only be included in standalone applications that are written to |
||||
# expect their presence. In addition to being linked against the libraries for |
||||
# these modules, such applications must forward declare their entry points and |
||||
# initialize them prior to use. To generate these forward declarations and |
||||
# initializations, see ``python_modules_header``. |
||||
# |
||||
# If ``<Target>`` does not refer to a target, then it is assumed to refer to an |
||||
# extension module that is not linked at all, but compiled along with other |
||||
# source files directly into an executable. Adding these modules does not cause |
||||
# any library configuration modifications, and they are not added to the list of |
||||
# linked modules. They still must be forward declared and initialized, however, |
||||
# and so are added to the forward declared modules list. |
||||
# |
||||
# Options: |
||||
# |
||||
# ``LINKED_MODULES_VAR <LinkedModVar>`` |
||||
# Name of the variable referencing a list of extension modules whose libraries |
||||
# must be linked into the executables of any stand-alone applications that use |
||||
# them. By default, the global property ``PY_LINKED_MODULES_LIST`` is used. |
||||
# |
||||
# ``FORWARD_DECL_MODULES_VAR <ForwardDeclModVar>`` |
||||
# Name of the variable referencing a list of extension modules whose entry |
||||
# points must be forward declared and called by any stand-alone applications |
||||
# that use them. By default, the global property |
||||
# ``PY_FORWARD_DECL_MODULES_LIST`` is used. |
||||
# |
||||
# ``MODULE_SUFFIX <ModuleSuffix>`` |
||||
# Suffix appended to the python extension module file. |
||||
# The default suffix is retrieved using ``sysconfig.get_config_var("SO")"``, |
||||
# if not available, the default is then ``.so`` on unix and ``.pyd`` on |
||||
# windows. |
||||
# Setting the variable ``PYTHON_EXTENSION_MODULE_SUFFIX`` in the caller |
||||
# scope defines the value used for all extensions not having a suffix |
||||
# explicitly specified using ``MODULE_SUFFIX`` parameter. |
||||
# |
||||
# |
||||
# .. cmake:command:: python_standalone_executable |
||||
# |
||||
# python_standalone_executable(<Target>) |
||||
# |
||||
# For standalone executables that initialize their own Python runtime |
||||
# (such as when building source files that include one generated by Cython with |
||||
# the --embed option). Amend the configuration of the executable target |
||||
# (created using ``add_executable``) with additional options needed to properly |
||||
# build the referenced executable. |
||||
# |
||||
# |
||||
# .. cmake:command:: python_modules_header |
||||
# |
||||
# Generate a header file that contains the forward declarations and |
||||
# initialization routines for the given list of Python extension modules. |
||||
# ``<Name>`` is the logical name for the header file (no file extensions). |
||||
# ``<HeaderFilename>`` is the actual destination filename for the header file |
||||
# (e.g.: decl_modules.h). |
||||
# |
||||
# python_modules_header(<Name> [HeaderFilename] |
||||
# [FORWARD_DECL_MODULES_LIST <ForwardDeclModList>] |
||||
# [HEADER_OUTPUT_VAR <HeaderOutputVar>] |
||||
# [INCLUDE_DIR_OUTPUT_VAR <IncludeDirOutputVar>]) |
||||
# |
||||
# If only ``<Name>`` is provided, and it ends in the ".h" extension, then it |
||||
# is assumed to be the ``<HeaderFilename>``. The filename of the header file |
||||
# without the extension is used as the logical name. If only ``<Name>`` is |
||||
# provided, and it does not end in the ".h" extension, then the |
||||
# ``<HeaderFilename>`` is assumed to ``<Name>.h``. |
||||
# |
||||
# The exact contents of the generated header file depend on the logical |
||||
# ``<Name>``. It should be set to a value that corresponds to the target |
||||
# application, or for the case of multiple applications, some identifier that |
||||
# conveyes its purpose. It is featured in the generated multiple inclusion |
||||
# guard as well as the names of the generated initialization routines. |
||||
# |
||||
# The generated header file includes forward declarations for all listed |
||||
# modules, as well as implementations for the following class of routines: |
||||
# |
||||
# ``int <Name>_<Module>(void)`` |
||||
# Initializes the python extension module, ``<Module>``. Returns an integer |
||||
# handle to the module. |
||||
# |
||||
# ``void <Name>_LoadAllPythonModules(void)`` |
||||
# Initializes all listed python extension modules. |
||||
# |
||||
# ``void CMakeLoadAllPythonModules(void);`` |
||||
# Alias for ``<Name>_LoadAllPythonModules`` whose name does not depend on |
||||
# ``<Name>``. This function is excluded during preprocessing if the |
||||
# preprocessing macro ``EXCLUDE_LOAD_ALL_FUNCTION`` is defined. |
||||
# |
||||
# ``void Py_Initialize_Wrapper();`` |
||||
# Wrapper arpund ``Py_Initialize()`` that initializes all listed python |
||||
# extension modules. This function is excluded during preprocessing if the |
||||
# preprocessing macro ``EXCLUDE_PY_INIT_WRAPPER`` is defined. If this |
||||
# function is generated, then ``Py_Initialize()`` is redefined to a macro |
||||
# that calls this function. |
||||
# |
||||
# Options: |
||||
# |
||||
# ``FORWARD_DECL_MODULES_LIST <ForwardDeclModList>`` |
||||
# List of extension modules for which to generate forward declarations of |
||||
# their entry points and their initializations. By default, the global |
||||
# property ``PY_FORWARD_DECL_MODULES_LIST`` is used. |
||||
# |
||||
# ``HEADER_OUTPUT_VAR <HeaderOutputVar>`` |
||||
# Name of the variable to set to the path to the generated header file. By |
||||
# default, ``<Name>`` is used. |
||||
# |
||||
# ``INCLUDE_DIR_OUTPUT_VAR <IncludeDirOutputVar>`` |
||||
# Name of the variable to set to the path to the directory containing the |
||||
# generated header file. By default, ``<Name>_INCLUDE_DIRS`` is used. |
||||
# |
||||
# Defined variables: |
||||
# |
||||
# ``<HeaderOutputVar>`` |
||||
# The path to the generated header file |
||||
# |
||||
# ``<IncludeDirOutputVar>`` |
||||
# Directory containing the generated header file |
||||
# |
||||
# |
||||
# Example usage |
||||
# ^^^^^^^^^^^^^ |
||||
# |
||||
# .. code-block:: cmake |
||||
# |
||||
# find_package(PythonInterp) |
||||
# find_package(PythonLibs) |
||||
# find_package(PythonExtensions) |
||||
# find_package(Cython) |
||||
# find_package(Boost COMPONENTS python) |
||||
# |
||||
# # Simple Cython Module -- no executables |
||||
# add_cython_target(_module.pyx) |
||||
# add_library(_module MODULE ${_module}) |
||||
# python_extension_module(_module) |
||||
# |
||||
# # Mix of Cython-generated code and C++ code using Boost Python |
||||
# # Stand-alone executable -- no modules |
||||
# include_directories(${Boost_INCLUDE_DIRS}) |
||||
# add_cython_target(main.pyx CXX EMBED_MAIN) |
||||
# add_executable(main boost_python_module.cxx ${main}) |
||||
# target_link_libraries(main ${Boost_LIBRARIES}) |
||||
# python_standalone_executable(main) |
||||
# |
||||
# # stand-alone executable with three extension modules: |
||||
# # one statically linked, one dynamically linked, and one loaded at runtime |
||||
# # |
||||
# # Freely mixes Cython-generated code, code using Boost-Python, and |
||||
# # hand-written code using the CPython API. |
||||
# |
||||
# # module1 -- statically linked |
||||
# add_cython_target(module1.pyx) |
||||
# add_library(module1 STATIC ${module1}) |
||||
# python_extension_module(module1 |
||||
# LINKED_MODULES_VAR linked_module_list |
||||
# FORWARD_DECL_MODULES_VAR fdecl_module_list) |
||||
# |
||||
# # module2 -- dynamically linked |
||||
# include_directories({Boost_INCLUDE_DIRS}) |
||||
# add_library(module2 SHARED boost_module2.cxx) |
||||
# target_link_libraries(module2 ${Boost_LIBRARIES}) |
||||
# python_extension_module(module2 |
||||
# LINKED_MODULES_VAR linked_module_list |
||||
# FORWARD_DECL_MODULES_VAR fdecl_module_list) |
||||
# |
||||
# # module3 -- loaded at runtime |
||||
# add_cython_target(module3a.pyx) |
||||
# add_library(module1 MODULE ${module3a} module3b.cxx) |
||||
# target_link_libraries(module3 ${Boost_LIBRARIES}) |
||||
# python_extension_module(module3 |
||||
# LINKED_MODULES_VAR linked_module_list |
||||
# FORWARD_DECL_MODULES_VAR fdecl_module_list) |
||||
# |
||||
# # application executable -- generated header file + other source files |
||||
# python_modules_header(modules |
||||
# FORWARD_DECL_MODULES_LIST ${fdecl_module_list}) |
||||
# include_directories(${modules_INCLUDE_DIRS}) |
||||
# |
||||
# add_cython_target(mainA) |
||||
# add_cython_target(mainC) |
||||
# add_executable(main ${mainA} mainB.cxx ${mainC} mainD.c) |
||||
# |
||||
# target_link_libraries(main ${linked_module_list} ${Boost_LIBRARIES}) |
||||
# python_standalone_executable(main) |
||||
# |
||||
#============================================================================= |
||||
# Copyright 2011 Kitware, Inc. |
||||
# |
||||
# Licensed under the Apache License, Version 2.0 (the "License"); |
||||
# you may not use this file except in compliance with the License. |
||||
# You may obtain a copy of the License at |
||||
# |
||||
# http://www.apache.org/licenses/LICENSE-2.0 |
||||
# |
||||
# Unless required by applicable law or agreed to in writing, software |
||||
# distributed under the License is distributed on an "AS IS" BASIS, |
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
# See the License for the specific language governing permissions and |
||||
# limitations under the License. |
||||
#============================================================================= |
||||
|
||||
find_package(PythonInterp REQUIRED) |
||||
find_package(PythonLibs) |
||||
include(targetLinkLibrariesWithDynamicLookup) |
||||
|
||||
set(_command " |
||||
import distutils.sysconfig |
||||
import itertools |
||||
import os |
||||
import os.path |
||||
import site |
||||
import sys |
||||
import sysconfig |
||||
|
||||
result = None |
||||
rel_result = None |
||||
candidate_lists = [] |
||||
|
||||
try: |
||||
candidate_lists.append((distutils.sysconfig.get_python_lib(),)) |
||||
except AttributeError: pass |
||||
|
||||
try: |
||||
candidate_lists.append(site.getsitepackages()) |
||||
except AttributeError: pass |
||||
|
||||
try: |
||||
candidate_lists.append((site.getusersitepackages(),)) |
||||
except AttributeError: pass |
||||
|
||||
candidates = itertools.chain.from_iterable(candidate_lists) |
||||
|
||||
for candidate in candidates: |
||||
rel_candidate = os.path.relpath( |
||||
candidate, sys.prefix) |
||||
if not rel_candidate.startswith(\"..\"): |
||||
result = candidate |
||||
rel_result = rel_candidate |
||||
break |
||||
|
||||
sys.stdout.write(\";\".join(( |
||||
os.sep, |
||||
os.pathsep, |
||||
sys.prefix, |
||||
result, |
||||
rel_result, |
||||
sysconfig.get_config_var('SO') |
||||
))) |
||||
") |
||||
|
||||
execute_process(COMMAND "${PYTHON_EXECUTABLE}" -c "${_command}" |
||||
OUTPUT_VARIABLE _list |
||||
RESULT_VARIABLE _result) |
||||
|
||||
list(GET _list 0 _item) |
||||
set(PYTHON_SEPARATOR "${_item}") |
||||
mark_as_advanced(PYTHON_SEPARATOR) |
||||
|
||||
list(GET _list 1 _item) |
||||
set(PYTHON_PATH_SEPARATOR "${_item}") |
||||
mark_as_advanced(PYTHON_PATH_SEPARATOR) |
||||
|
||||
list(GET _list 2 _item) |
||||
set(PYTHON_PREFIX "${_item}") |
||||
mark_as_advanced(PYTHON_PREFIX) |
||||
|
||||
list(GET _list 3 _item) |
||||
set(PYTHON_SITE_PACKAGES_DIR "${_item}") |
||||
mark_as_advanced(PYTHON_SITE_PACKAGES_DIR) |
||||
|
||||
list(GET _list 4 _item) |
||||
set(PYTHON_RELATIVE_SITE_PACKAGES_DIR "${_item}") |
||||
mark_as_advanced(PYTHON_RELATIVE_SITE_PACKAGES_DIR) |
||||
|
||||
if(NOT DEFINED PYTHON_EXTENSION_MODULE_SUFFIX) |
||||
list(GET _list 5 _item) |
||||
set(PYTHON_EXTENSION_MODULE_SUFFIX "${_item}") |
||||
endif() |
||||
|
||||
function(python_extension_module _target) |
||||
set(one_ops LINKED_MODULES_VAR FORWARD_DECL_MODULES_VAR MODULE_SUFFIX) |
||||
cmake_parse_arguments(_args "" "${one_ops}" "" ${ARGN}) |
||||
|
||||
set(_lib_type "NA") |
||||
if(TARGET ${_target}) |
||||
get_property(_lib_type TARGET ${_target} PROPERTY TYPE) |
||||
endif() |
||||
|
||||
set(_is_non_lib TRUE) |
||||
|
||||
set(_is_static_lib FALSE) |
||||
if(_lib_type STREQUAL "STATIC_LIBRARY") |
||||
set(_is_static_lib TRUE) |
||||
set(_is_non_lib FALSE) |
||||
endif() |
||||
|
||||
set(_is_shared_lib FALSE) |
||||
if(_lib_type STREQUAL "SHARED_LIBRARY") |
||||
set(_is_shared_lib TRUE) |
||||
set(_is_non_lib FALSE) |
||||
endif() |
||||
|
||||
set(_is_module_lib FALSE) |
||||
if(_lib_type STREQUAL "MODULE_LIBRARY") |
||||
set(_is_module_lib TRUE) |
||||
set(_is_non_lib FALSE) |
||||
endif() |
||||
|
||||
if(_is_static_lib OR _is_shared_lib OR _is_non_lib) |
||||
|
||||
if(_is_static_lib OR _is_shared_lib) |
||||
if(_args_LINKED_MODULES_VAR) |
||||
set(${_args_LINKED_MODULES_VAR} |
||||
${${_args_LINKED_MODULES_VAR}} ${_target} PARENT_SCOPE) |
||||
else() |
||||
set_property(GLOBAL APPEND PROPERTY PY_LINKED_MODULES_LIST ${_target}) |
||||
endif() |
||||
endif() |
||||
|
||||
if(_args_FORWARD_DECL_MODULES_VAR) |
||||
set(${_args_FORWARD_DECL_MODULES_VAR} |
||||
${${_args_FORWARD_DECL_MODULES_VAR}} ${_target} PARENT_SCOPE) |
||||
else() |
||||
set_property(GLOBAL APPEND PROPERTY |
||||
PY_FORWARD_DECL_MODULES_LIST ${_target}) |
||||
endif() |
||||
endif() |
||||
|
||||
if(NOT _is_non_lib) |
||||
include_directories("${PYTHON_INCLUDE_DIRS}") |
||||
endif() |
||||
|
||||
if(_is_module_lib) |
||||
set_target_properties(${_target} PROPERTIES |
||||
PREFIX "${PYTHON_MODULE_PREFIX}") |
||||
endif() |
||||
|
||||
if(_is_module_lib OR _is_shared_lib) |
||||
if(_is_module_lib) |
||||
|
||||
if(NOT _args_MODULE_SUFFIX) |
||||
set(_args_MODULE_SUFFIX "${PYTHON_EXTENSION_MODULE_SUFFIX}") |
||||
endif() |
||||
|
||||
if(_args_MODULE_SUFFIX STREQUAL "" AND WIN32 AND NOT CYGWIN) |
||||
set(_args_MODULE_SUFFIX ".pyd") |
||||
endif() |
||||
|
||||
if(NOT _args_MODULE_SUFFIX STREQUAL "") |
||||
set_target_properties(${_target} |
||||
PROPERTIES SUFFIX ${_args_MODULE_SUFFIX}) |
||||
endif() |
||||
endif() |
||||
|
||||
target_link_libraries_with_dynamic_lookup(${_target} ${PYTHON_LIBRARIES}) |
||||
endif() |
||||
endfunction() |
||||
|
||||
function(python_standalone_executable _target) |
||||
include_directories(${PYTHON_INCLUDE_DIRS}) |
||||
target_link_libraries(${_target} ${PYTHON_LIBRARIES}) |
||||
endfunction() |
||||
|
||||
function(python_modules_header _name) |
||||
set(one_ops FORWARD_DECL_MODULES_LIST |
||||
HEADER_OUTPUT_VAR |
||||
INCLUDE_DIR_OUTPUT_VAR) |
||||
cmake_parse_arguments(_args "" "${one_ops}" "" ${ARGN}) |
||||
|
||||
list(GET _args_UNPARSED_ARGUMENTS 0 _arg0) |
||||
# if present, use arg0 as the input file path |
||||
if(_arg0) |
||||
set(_source_file ${_arg0}) |
||||
|
||||
# otherwise, must determine source file from name, or vice versa |
||||
else() |
||||
get_filename_component(_name_ext "${_name}" EXT) |
||||
|
||||
# if extension provided, _name is the source file |
||||
if(_name_ext) |
||||
set(_source_file ${_name}) |
||||
get_filename_component(_name "${_source_file}" NAME_WE) |
||||
|
||||
# otherwise, assume the source file is ${_name}.h |
||||
else() |
||||
set(_source_file ${_name}.h) |
||||
endif() |
||||
endif() |
||||
|
||||
if(_args_FORWARD_DECL_MODULES_LIST) |
||||
set(static_mod_list ${_args_FORWARD_DECL_MODULES_LIST}) |
||||
else() |
||||
get_property(static_mod_list GLOBAL PROPERTY PY_FORWARD_DECL_MODULES_LIST) |
||||
endif() |
||||
|
||||
string(REPLACE "." "_" _header_name "${_name}") |
||||
string(TOUPPER ${_header_name} _header_name_upper) |
||||
set(_header_name_upper "_${_header_name_upper}_H") |
||||
set(generated_file ${CMAKE_CURRENT_BINARY_DIR}/${_source_file}) |
||||
|
||||
set(generated_file_tmp "${generated_file}.in") |
||||
file(WRITE ${generated_file_tmp} |
||||
"/* Created by CMake. DO NOT EDIT; changes will be lost. */\n") |
||||
|
||||
set(_chunk "") |
||||
set(_chunk "${_chunk}#ifndef ${_header_name_upper}\n") |
||||
set(_chunk "${_chunk}#define ${_header_name_upper}\n") |
||||
set(_chunk "${_chunk}\n") |
||||
set(_chunk "${_chunk}#include <Python.h>\n") |
||||
set(_chunk "${_chunk}\n") |
||||
set(_chunk "${_chunk}#ifdef __cplusplus\n") |
||||
set(_chunk "${_chunk}extern \"C\" {\n") |
||||
set(_chunk "${_chunk}#endif /* __cplusplus */\n") |
||||
set(_chunk "${_chunk}\n") |
||||
set(_chunk "${_chunk}#if PY_MAJOR_VERSION < 3\n") |
||||
file(APPEND ${generated_file_tmp} "${_chunk}") |
||||
|
||||
foreach(_module ${static_mod_list}) |
||||
file(APPEND ${generated_file_tmp} |
||||
"PyMODINIT_FUNC init${PYTHON_MODULE_PREFIX}${_module}(void);\n") |
||||
endforeach() |
||||
|
||||
file(APPEND ${generated_file_tmp} "#else /* PY_MAJOR_VERSION >= 3*/\n") |
||||
|
||||
foreach(_module ${static_mod_list}) |
||||
file(APPEND ${generated_file_tmp} |
||||
"PyMODINIT_FUNC PyInit_${PYTHON_MODULE_PREFIX}${_module}(void);\n") |
||||
endforeach() |
||||
|
||||
set(_chunk "") |
||||
set(_chunk "${_chunk}#endif /* PY_MAJOR_VERSION >= 3*/\n\n") |
||||
set(_chunk "${_chunk}#ifdef __cplusplus\n") |
||||
set(_chunk "${_chunk}}\n") |
||||
set(_chunk "${_chunk}#endif /* __cplusplus */\n") |
||||
set(_chunk "${_chunk}\n") |
||||
file(APPEND ${generated_file_tmp} "${_chunk}") |
||||
|
||||
foreach(_module ${static_mod_list}) |
||||
set(_import_function "${_header_name}_${_module}") |
||||
set(_prefixed_module "${PYTHON_MODULE_PREFIX}${_module}") |
||||
|
||||
set(_chunk "") |
||||
set(_chunk "${_chunk}int ${_import_function}(void)\n") |
||||
set(_chunk "${_chunk}{\n") |
||||
set(_chunk "${_chunk} static char name[] = \"${_prefixed_module}\";\n") |
||||
set(_chunk "${_chunk} #if PY_MAJOR_VERSION < 3\n") |
||||
set(_chunk "${_chunk} return PyImport_AppendInittab(") |
||||
set(_chunk "${_chunk}name, init${_prefixed_module});\n") |
||||
set(_chunk "${_chunk} #else /* PY_MAJOR_VERSION >= 3 */\n") |
||||
set(_chunk "${_chunk} return PyImport_AppendInittab(") |
||||
set(_chunk "${_chunk}name, PyInit_${_prefixed_module});\n") |
||||
set(_chunk "${_chunk} #endif /* PY_MAJOR_VERSION >= 3 */\n") |
||||
set(_chunk "${_chunk}}\n\n") |
||||
file(APPEND ${generated_file_tmp} "${_chunk}") |
||||
endforeach() |
||||
|
||||
file(APPEND ${generated_file_tmp} |
||||
"void ${_header_name}_LoadAllPythonModules(void)\n{\n") |
||||
foreach(_module ${static_mod_list}) |
||||
file(APPEND ${generated_file_tmp} " ${_header_name}_${_module}();\n") |
||||
endforeach() |
||||
file(APPEND ${generated_file_tmp} "}\n\n") |
||||
|
||||
set(_chunk "") |
||||
set(_chunk "${_chunk}#ifndef EXCLUDE_LOAD_ALL_FUNCTION\n") |
||||
set(_chunk "${_chunk}void CMakeLoadAllPythonModules(void)\n") |
||||
set(_chunk "${_chunk}{\n") |
||||
set(_chunk "${_chunk} ${_header_name}_LoadAllPythonModules();\n") |
||||
set(_chunk "${_chunk}}\n") |
||||
set(_chunk "${_chunk}#endif /* !EXCLUDE_LOAD_ALL_FUNCTION */\n\n") |
||||
|
||||
set(_chunk "${_chunk}#ifndef EXCLUDE_PY_INIT_WRAPPER\n") |
||||
set(_chunk "${_chunk}static void Py_Initialize_Wrapper()\n") |
||||
set(_chunk "${_chunk}{\n") |
||||
set(_chunk "${_chunk} ${_header_name}_LoadAllPythonModules();\n") |
||||
set(_chunk "${_chunk} Py_Initialize();\n") |
||||
set(_chunk "${_chunk}}\n") |
||||
set(_chunk "${_chunk}#define Py_Initialize Py_Initialize_Wrapper\n") |
||||
set(_chunk "${_chunk}#endif /* !EXCLUDE_PY_INIT_WRAPPER */\n\n") |
||||
|
||||
set(_chunk "${_chunk}#endif /* !${_header_name_upper} */\n") |
||||
file(APPEND ${generated_file_tmp} "${_chunk}") |
||||
|
||||
# with configure_file() cmake complains that you may not use a file created |
||||
# using file(WRITE) as input file for configure_file() |
||||
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different |
||||
"${generated_file_tmp}" "${generated_file}" |
||||
OUTPUT_QUIET ERROR_QUIET) |
||||
|
||||
set(_header_output_var ${_name}) |
||||
if(_args_HEADER_OUTPUT_VAR) |
||||
set(_header_output_var ${_args_HEADER_OUTPUT_VAR}) |
||||
endif() |
||||
set(${_header_output_var} ${generated_file} PARENT_SCOPE) |
||||
|
||||
set(_include_dir_var ${_name}_INCLUDE_DIRS) |
||||
if(_args_INCLUDE_DIR_OUTPUT_VAR) |
||||
set(_include_dir_var ${_args_INCLUDE_DIR_OUTPUT_VAR}) |
||||
endif() |
||||
set(${_include_dirs_var} ${CMAKE_CURRENT_BINARY_DIR} PARENT_SCOPE) |
||||
endfunction() |
||||
|
||||
@ -0,0 +1,395 @@
|
||||
#.rst: |
||||
# |
||||
# The following functions are defined: |
||||
# |
||||
# .. cmake:command:: add_cython_target |
||||
# |
||||
# Create a custom rule to generate the source code for a Python extension module |
||||
# using cython. |
||||
# |
||||
# add_cython_target(<Name> [<CythonInput>] |
||||
# [EMBED_MAIN] |
||||
# [C | CXX] |
||||
# [PY2 | PY3] |
||||
# [OUTPUT_VAR <OutputVar>]) |
||||
# |
||||
# ``<Name>`` is the name of the new target, and ``<CythonInput>`` |
||||
# is the path to a cython source file. Note that, despite the name, no new |
||||
# targets are created by this function. Instead, see ``OUTPUT_VAR`` for |
||||
# retrieving the path to the generated source for subsequent targets. |
||||
# |
||||
# If only ``<Name>`` is provided, and it ends in the ".pyx" extension, then it |
||||
# is assumed to be the ``<CythonInput>``. The name of the input without the |
||||
# extension is used as the target name. If only ``<Name>`` is provided, and it |
||||
# does not end in the ".pyx" extension, then the ``<CythonInput>`` is assumed to |
||||
# be ``<Name>.pyx``. |
||||
# |
||||
# The Cython include search path is amended with any entries found in the |
||||
# ``INCLUDE_DIRECTORIES`` property of the directory containing the |
||||
# ``<CythonInput>`` file. Use ``iunclude_directories`` to add to the Cython |
||||
# include search path. |
||||
# |
||||
# Options: |
||||
# |
||||
# ``EMBED_MAIN`` |
||||
# Embed a main() function in the generated output (for stand-alone |
||||
# applications that initialize their own Python runtime). |
||||
# |
||||
# ``C | CXX`` |
||||
# Force the generation of either a C or C++ file. By default, a C file is |
||||
# generated, unless the C language is not enabled for the project; in this |
||||
# case, a C++ file is generated by default. |
||||
# |
||||
# ``PY2 | PY3`` |
||||
# Force compilation using either Python-2 or Python-3 syntax and code |
||||
# semantics. By default, Python-2 syntax and semantics are used if the major |
||||
# version of Python found is 2. Otherwise, Python-3 syntax and sematics are |
||||
# used. |
||||
# |
||||
# ``OUTPUT_VAR <OutputVar>`` |
||||
# Set the variable ``<OutputVar>`` in the parent scope to the path to the |
||||
# generated source file. By default, ``<Name>`` is used as the output |
||||
# variable name. |
||||
# |
||||
# Defined variables: |
||||
# |
||||
# ``<OutputVar>`` |
||||
# The path of the generated source file. |
||||
# |
||||
# Cache variables that effect the behavior include: |
||||
# |
||||
# ``CYTHON_ANNOTATE`` |
||||
# whether to create an annotated .html file when compiling |
||||
# |
||||
# ``CYTHON_FLAGS`` |
||||
# additional flags to pass to the Cython compiler |
||||
# |
||||
# Example usage |
||||
# ^^^^^^^^^^^^^ |
||||
# |
||||
# .. code-block:: cmake |
||||
# |
||||
# find_package(Cython) |
||||
# |
||||
# # Note: In this case, either one of these arguments may be omitted; their |
||||
# # value would have been inferred from that of the other. |
||||
# add_cython_target(cy_code cy_code.pyx) |
||||
# |
||||
# add_library(cy_code MODULE ${cy_code}) |
||||
# target_link_libraries(cy_code ...) |
||||
# |
||||
#============================================================================= |
||||
# Copyright 2011 Kitware, Inc. |
||||
# |
||||
# Licensed under the Apache License, Version 2.0 (the "License"); |
||||
# you may not use this file except in compliance with the License. |
||||
# You may obtain a copy of the License at |
||||
# |
||||
# http://www.apache.org/licenses/LICENSE-2.0 |
||||
# |
||||
# Unless required by applicable law or agreed to in writing, software |
||||
# distributed under the License is distributed on an "AS IS" BASIS, |
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
# See the License for the specific language governing permissions and |
||||
# limitations under the License. |
||||
#============================================================================= |
||||
|
||||
# Configuration options. |
||||
set(CYTHON_ANNOTATE OFF |
||||
CACHE BOOL "Create an annotated .html file when compiling *.pyx.") |
||||
|
||||
set(CYTHON_FLAGS "" CACHE STRING |
||||
"Extra flags to the c | ||||