set(CMAKE_LEGACY_CYGWIN_WIN32 0) if(WIN32) # We want to use WiX 4.x but cpack only supports that from 3.30. set(CADABRA_CMAKE_VERSION 3.30) else() set(CADABRA_CMAKE_VERSION 3.12) endif() # Policy settings for CMake to resolve ambiguities. if(POLICY CMP0042) cmake_policy(SET CMP0042 NEW) message(STATUS "Set CMake policy CMP0042 to NEW") endif() if(POLICY CMP0054) cmake_policy(SET CMP0054 NEW) message(STATUS "Set CMake policy CMP0054 to NEW") endif() if(POLICY CMP0127) cmake_policy(SET CMP0127 NEW) message(STATUS "Set CMake policy CMP0127 to NEW") endif() if(POLICY CMP0148) cmake_policy(SET CMP0148 NEW) message(STATUS "Set CMake policy CMP0148 to NEW") endif() if(POLICY CMP0167) cmake_policy(SET CMP0167 NEW) message(STATUS "Set CMake policy CMP0167 to NEW") endif() if(POLICY CMP0094) cmake_policy(SET CMP0094 NEW) message(STATUS "Set CMake policy CMP0094 to NEW (use first Python found)") endif() if(POLICY CMP0169) cmake_policy(SET CMP0169 NEW) message(STATUS "Set CMake policy CMP0169 to NEW (use new FetchContent)") # CMake 3.30: call FetchContent_Populate() with just the name of a # dependency. This modern alternative was introduced in cmake 3.14 # but we still support 3.12; we call the old behaviour in # frontend/gtkmm/CMakeLists.txt endif() if(POLICY CMP0177) cmake_policy(SET CMP0177 NEW) message(STATUS "Set CMake policy CMP0177 to NEW (destination paths are normalised)") endif() if(POLICY CMP0087) cmake_policy(SET CMP0087 NEW) message(STATUS "Set CMake policy CMP0089 to NEW (evaluate generator expressions in install(CODE))") endif() cmake_minimum_required(VERSION ${CADABRA_CMAKE_VERSION}) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) project(Cadabra) if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") set(MACOS TRUE) endif() #--------------------------------------------------------------------------- # Preamble #--------------------------------------------------------------------------- set(CMAKE_EXPORT_COMPILE_COMMANDS ON) # Aliases for directories set(CADABRA_ROOT_DIR ${CMAKE_SOURCE_DIR}) set(CADABRA_CLIENT_SERVER_DIR ${CADABRA_ROOT_DIR}/client_server) set(CADABRA_CORE_DIR ${CADABRA_ROOT_DIR}/core) set(CADABRA_FRONTEND_DIR ${CADABRA_ROOT_DIR}/frontend) set(CADABRA_IMAGES_DIR ${CADABRA_ROOT_DIR}/images) set(CADABRA_LIBS_DIR ${CADABRA_ROOT_DIR}/libs) include(cmake/functions.cmake) # Include Visual Studio specific build commands if (MSVC) # https://developercommunity.visualstudio.com/content/problem/618088/cmake-msvc-toolset-version-is-incorrect-in-visual.html if ((MSVC_VERSION EQUAL 1921 OR MSVC_VERSION EQUAL 1922) AND MSVC_TOOLSET_VERSION EQUAL 141) set(MSVC_TOOLSET_VERSION 142) endif() message(STATUS "MSVC_VERSION = ${MSVC_VERSION}, MSVC_TOOLSET_VERSION = ${MSVC_TOOLSET_VERSION}") include(cmake/windows.cmake) endif() # Make sure the build type is non-empty. if(NOT DEFINED CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "") set(CMAKE_BUILD_TYPE "Release") endif() set(CADABRA_BUILD_TYPE "${CMAKE_BUILD_TYPE}") if (CMAKE_BUILD_TYPE MATCHES "^Debug$") set(CADABRA_DEBUG_BUILD TRUE) endif() message(STATUS "Build type = ${CMAKE_BUILD_TYPE}") # Set path to additional cmake files set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules") if (APPLE) set(ENV{PKG_CONFIG_PATH} "/usr/local/opt/libffi/lib/pkgconfig:") endif() set(PKG_CONFIG_USE_STATIC_LIBS OFF) if(NOT APPLE) find_package(TBB QUIET) if(TBB_FOUND) message(STATUS "TBB found, will make some operations parallel") else() message(STATUS "TBB not found, parallel operations disabled") endif() else() message(STATUS "Apple's toolchain not yet supporting TBB properly, disabled") endif() # Get version information. include(cmake/version.cmake) print_header("Building Cadabra version ${CADABRA_VERSION_SEM} (${SYSTEM_BITS}-bit)") message(STATUS "Build id '${CADABRA_VERSION_BUILD}' dated ${CADABRA_VERSION_DATE}") message(STATUS "Build mode is set to '${CMAKE_BUILD_TYPE}'") string(TOLOWER ${CMAKE_SYSTEM_PROCESSOR} STANDARD_ARCH_NAME) if(STANDARD_ARCH_NAME STREQUAL "aarch64") set(STANDARD_ARCH_NAME "arm64") endif() if(STANDARD_ARCH_NAME STREQUAL "amd64") set(STANDARD_ARCH_NAME "x86_64") endif() message(STATUS "Architecture is '${CMAKE_SYSTEM_PROCESSOR}' (package names will use '${STANDARD_ARCH_NAME}')") if(WIN32) if("${STANDARD_ARCH_NAME}" STREQUAL "x86_64") set(MSYS_ENV "ucrt64") set(WIX_SHORT_ARCH "x64") else() set(MSYS_ENV "clangarm64") set(WIX_SHORT_ARCH "arm64") endif() message(STATUS "MSYS environment set to ${MSYS_ENV}") endif() # Store the version number in a build/VERSION file (so that e.g. github # actions can pick it up). file(WRITE build/VERSION "${CADABRA_VERSION_SEM}") file(WRITE build/GIT_TAG_VERSION "${CADABRA_VERSION_GITHUB_TAG}") # Notify about install directory if ("${CMAKE_INSTALL_PREFIX}" STREQUAL "") message(STATUS "Install directory not set") else() message(STATUS "Install directory set to ${CMAKE_INSTALL_PREFIX}") endif() # Turn Mathematica support on/off. option(ENABLE_MATHEMATICA "Enable Mathematica support" OFF) # Are we trying to build cadabra as a c++ library? option(BUILD_AS_CPP_LIBRARY "Build cadabra as a C++ library" OFF) if (BUILD_AS_CPP_LIBRARY) enable_testing() add_subdirectory(c++lib) configure_file( "${PROJECT_SOURCE_DIR}/core/Config.hh.in" "${PROJECT_SOURCE_DIR}/core/Config.hh" ) # Bail out early. return() endif() # Switch between GTK4 and GTK3. option(USE_GTK4 "Build for GTK4 (instead of GTK3)" OFF) # Include packaging logic. include(cmake/packaging.cmake) #--------------------------------------------------------------------------- # User options and other notifications #--------------------------------------------------------------------------- # option(MSVC_TARGET_CONSOLE "Force Release book on MSVC to display a console window" OFF) option(APPIMAGE_MODE "Run in AppImage mode, overriding path settings" OFF) if(APPIMAGE_MODE) message(STATUS "Building for AppImage packaging (Debian paths, MicroTeX)") if("${CMAKE_INSTALL_PREFIX}" STREQUAL "/usr") else() MESSAGE(FATAL_ERROR "Building with -DAPPIMAGE_MODE=ON also requires -DCMAKE_INSTALL_PREFIX=/usr") endif() endif() option(PACKAGING_MODE "Run in packaging mode, overriding path settings" OFF) if (PACKAGING_MODE) message(STATUS "Building in packaging mode") if("${CMAKE_INSTALL_PREFIX}" STREQUAL "/usr") else() MESSAGE(FATAL_ERROR "Building with -DPACKAGING_MODE=ON also requires -DCMAKE_INSTALL_PREFIX=/usr") endif() else() message(STATUS "Building in user mode") endif() option(ENABLE_JUPYTER "Enable building the Xeus-based Jupyter kernel" OFF) option(ENABLE_PY_JUPYTER "Enable building the default Jupyter kernel" ON) if(ENABLE_JUPYTER) # Currently only possible when building against Conda. set(CONDA_FOUND TRUE) else() set(CONDA_FOUND FALSE) endif() option(BUILD_TESTS "Build tests" ON) if (BUILD_TESTS) message(STATUS "Building tests") # Allows tests to be built in all subdirectories. enable_testing() endif() option(ENABLE_FRONTEND "Enable the UI frontend" ON) option(ENABLE_SYSTEM_JSONCPP "Use the system-provided jsoncpp library" OFF) option(INSTALL_TARGETS_ONLY "Only install targets; skipping icons, shared libraries etc..." OFF) if (INSTALL_TARGETS_ONLY) message(STATUS "INSTALL_TARGETS_ONLY is enabled, please make sure all auxillary files and programs Cadabra requires are already installed") endif() #--------------------------------------------------------------------------- # Compiler flags. #--------------------------------------------------------------------------- # - Set the C++ standard to C++17 # - Turn optimizations on # - Turn off warnings we don't need include(CheckIPOSupported) check_ipo_supported(RESULT IPO_SUPPORTED OUTPUT error) if( IPO_SUPPORTED ) message(STATUS "IPO / LTO enabled") else() message(STATUS "IPO / LTO not supported: <${error}>") endif() # GCC if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX) if (ENABLE_FRONTEND) if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9) message(FATAL_ERROR "GCC version must be at least 4.9 for regex support! See http://askubuntu.com/questions/428198/getting-installing-gcc-g-4-9-on-ubuntu and then set the environment variables CXX to g++-4.9 and CC to gcc-4.9. You may have to erase the build directory before re-running cmake.") endif() if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 14.0) message(STATUS "This version of g++ (${CMAKE_CXX_COMPILER_VERSION}) incorrectly warns about possibly uninitialised memory when using std::variant containing a std::shared_ptr. Disabling this warning.") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-maybe-uninitialized") endif() endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O2 -Wall -Wextra -Wunused -Wno-psabi -Wno-unknown-pragmas -Wno-misleading-indentation -fvisibility=hidden -Wno-unused-but-set-variable -Wno-unused-parameter") endif() # Clang if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") # For Clang, need to additionally check version to avoid compiler bugs if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.5) message(FATAL_ERROR "Clang version must be at least 3.5 to avoid known bugs.") endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O2 -fvisibility=hidden -Wall -Wextra -Wunused -Wno-unused-parameter -Wno-null-pointer-subtraction") endif() # Visual Studio if(MSVC) set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) # Disable specific warnings set(MSVC_FLAGS "/wd4250" # inherits via dominance (rampant in the GTKMM codebase) "/wd4101" # unreferenced local variable "/wd4244" # conversion from x to y, possible loss of data "/wd4267" # same as 4244 "/wd4305" # truncation from '' to 'char' "/wd4309" # truncation of constant value "/wd4390" # empty control statement, due to a DEBUG macro which requires trailing ; "/wd4996" # deprecated POSIX functions "-D_CRT_SECURE_NO_WARNINGS" # don't warn about deprecated functions "-D_SCL_SECURE_NO_WARNINGS" # don't warn about unsafe function calls (e.g. std::copy with raw pointers) "-DNOMINMAX" # prevent windows headers from defining min and max macros "-DWIN32_LEAN_AND_MEAN" # stop windows from including a bunch of garbage "-DBOOST_ALL_DYN_LINK" # ensure boost's auto-linking is enabled ) foreach(FLAG ${MSVC_FLAGS}) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAG}") endforeach() endif() #--------------------------------------------------------------------------- # Configure the various parts of Cadabra. #--------------------------------------------------------------------------- # if(MATHEMATICA_FOUND) # # To avoid issues finding Mathematica's libWSTP64i4, # # when linking to Mathematica we set the RPATH. # # That's not something we want to do in general, as e.g. Debian's # # packages are not supposed to set RPATH. # SET(CMAKE_SKIP_BUILD_RPATH FALSE) # SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) # SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") # SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) # endif() configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/config/postinst.in" "${CMAKE_CURRENT_BINARY_DIR}/postinst" @ONLY ) configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/config/install_script.iss.in" "${CMAKE_CURRENT_SOURCE_DIR}/config/install_script.iss" ) configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/config/pre_install.rtf.in" "${CMAKE_CURRENT_SOURCE_DIR}/config/pre_install.rtf" ) configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/config/science.cadabra.cadabra2-gtk.desktop.in" "${CMAKE_CURRENT_SOURCE_DIR}/config/science.cadabra.cadabra2-gtk.desktop" ) configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/frontend/gtkmm/science.cadabra.cadabra2-gtk.appdata.xml.in" "${CMAKE_CURRENT_SOURCE_DIR}/frontend/gtkmm/science.cadabra.cadabra2-gtk.appdata.xml" ) #--------------------------------------------------------------------------- # Configure Mathematica (if enabled). #--------------------------------------------------------------------------- if(ENABLE_MATHEMATICA) print_header("Configuring Mathematica") cmake_policy(SET CMP0077 NEW) set(Mathematica_USE_STATIC_LIBRARIES TRUE) find_package(Mathematica COMPONENTS WSTP) endif() #--------------------------------------------------------------------------- # Configure Python. #--------------------------------------------------------------------------- print_header("Configuring Python") include(GNUInstallDirs) set(Python_POSTFIX "3") find_package(Python REQUIRED COMPONENTS Interpreter Development) set(PYTHON_EXECUTABLE ${Python_EXECUTABLE} CACHE INTERNAL "") set(PYBIND11_PYTHON_VERSION ${Python_VERSION} CACHE INTERNAL "") find_package(pybind11 CONFIG) if (NOT pybind11_FOUND OR pybind11_VERSION VERSION_LESS 2.13.6) if(pybind11_FOUND) message(STATUS "Found pybind11 with version ${pybind11_VERSION} < 2.13.6, using included pybind11 instead.") else() message(STATUS "System-supplied pybind11 not found, using included pybind11.") endif() add_subdirectory(libs/pybind11) endif() message(STATUS "Found python ${Python_LIBRARIES}") message(STATUS "Python version is ${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}.") # The PYTHON_SITE_PATH variable is used for installation purposes # only. It is ideally a path relative to CMAKE_INSTALL_PREFIX, not an # absolute path which uses this variable explictly. See the CMake docs # for `install`. if(WIN32) set(PYTHON_SITE_PATH lib/python${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}/site-packages) # NOTE: if you change the CDB_BIN_PATH, you also need to change the stripping # logic in InstallPrefix.cc. Note that CDB_BIN_PATH needs to be a relative path. set(CDB_BIN_PATH .) else() set(CDB_BIN_PATH bin) if(PACKAGING_MODE AND IS_DEBIAN_PACKAGE) # Debian packages install all their Python things in 'dist-packages', not 'site-packages'. set(PYTHON_SITE_PATH lib/python${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}/dist-packages) # set(Python_SITE_DIST "dist-packages") elseif(APPIMAGE_MODE) set(PYTHON_SITE_PATH lib/python${Python_VERSION_MAJOR}.${Python_VERSION_MINOR}/dist-packages) set(Python_SITE_DIST "dist-packages") else() # The builder can override the path by setting it externally. if(NOT DEFINED PYTHON_SITE_PATH) # set(PYTHON_SITE_PATH ${Python_SITEARCH}) # For everyone else there is 'site-packages' which we get from # calling into python's 'site' package (and hoping that the 0th # element is where we should be writing). execute_process( COMMAND ${Python_EXECUTABLE} -c "import site; print(site.getsitepackages()[0])" OUTPUT_VARIABLE PYTHON_SITE_PATH OUTPUT_STRIP_TRAILING_WHITESPACE ) endif() endif() endif() if(IS_ABSOLUTE ${PYTHON_SITE_PATH}) # CPack on windows complains if `install` commands contain absolute paths, # so we do our best to make PYTHON_SITE_PATH relative to CMAKE_INSTALL_PREFIX. # Of course, the net effect will be the same, as `install` with a relative # DESTINATION will prepend CMAKE_INSTALL_PREFIX. message(STATUS "Making PYTHON_SITE_PATH relative if possible") string(REPLACE "${CMAKE_INSTALL_PREFIX}/" "" PYTHON_SITE_PATH_REL "${PYTHON_SITE_PATH}") set(PYTHON_SITE_PATH ${PYTHON_SITE_PATH_REL}) else() message(STATUS "PYTHON_SITE_PATH is already relative") endif() message(STATUS "PYTHON_SITE_PATH = ${PYTHON_SITE_PATH}") if(IS_ABSOLUTE ${PYTHON_SITE_PATH}) message(STATUS "Installing Cadabra Python module in ${PYTHON_SITE_PATH}") message(STATUS "Installing Cadabra packages in ${PYTHON_SITE_PATH}/cdb/") else() message(STATUS "Installing Cadabra Python module in ${CMAKE_INSTALL_PREFIX}/${PYTHON_SITE_PATH}") message(STATUS "Installing Cadabra packages in ${CMAKE_INSTALL_PREFIX}/${PYTHON_SITE_PATH}/cdb/") endif() message(STATUS "Installing binaries in ${CMAKE_INSTALL_PREFIX}/bin/") message(STATUS "Installing manual pages in ${CMAKE_INSTALL_PREFIX}/share/man/") message(STATUS "Installing fonts/icons in ${CMAKE_INSTALL_PREFIX}/share/cadabra2/") if("${Python_CDB_EXECUTABLE}" STREQUAL "") # We start the cadabra2 python script by using the current environment, # so that e.g. Fedora 42 does not hard-code the python path as a # dependency. However, on macOS with Homebrew, we need to be able # to override this because otherwise we will not be running in the # venv which homebrew created for our package. See cadabra2.rb and # cadabra2-devel.rb where this is used. set(Python_CDB_EXECUTABLE "/usr/bin/env python3") endif() message(STATUS "Starting cadabra2 using '${Python_CDB_EXECUTABLE}'") message(STATUS "For reference:") message(STATUS " Python executable (Python_EXECUTABLE) ${Python_EXECUTABLE}") message(STATUS " Python standard platform-independent installation directory (Python_STDLIB) ${Python_STDLIB}") message(STATUS " Python standard platform-dependent installation directory (Python_STDARCH) ${Python_STDARCH}") message(STATUS " Python 3rd-party platform-independent installation directory (Python_SITELIB) ${Python_SITELIB}") message(STATUS " Python 3rd-party platform-dependent installation directory (Python_SITEARCH) ${Python_SITEARCH}") # We need to give our Python module an abi-name extension # so that it can be installed in a folder which does not # contain the abi name. See # https://www.python.org/dev/peps/pep-3149/ execute_process( COMMAND ${Python_EXECUTABLE} -c "import sysconfig; print(sysconfig.get_config_var('SOABI'))" OUTPUT_VARIABLE Python_SOABI OUTPUT_STRIP_TRAILING_WHITESPACE ) message(STATUS "Python abi name ${Python_SOABI}") # Suffixes if(WIN32) set(STATIC_LIB_SUFFIX "lib") set(SHARED_LIB_SUFFIX "dll") set(Python_MOD_SUFFIX "pyd") set(CMAKE_FIND_LIBRARY_PREFIXES "lib" ${CMAKE_FIND_LIBRARY_PREFIXES}) set(CMAKE_SHARED_LIBRARY_SUFFIX ".dll") set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll.a") else() set(STATIC_LIB_SUFFIX "a") set(SHARED_LIB_SUFFIX "so") set(Python_MOD_EXT "so") set(Python_MOD_SUFFIX "${Python_SOABI}.so") endif() message(STATUS "Python module extension ${Python_MOD_SUFFIX}") #--------------------------------------------------------------------------- # Add subdirectories to project. #--------------------------------------------------------------------------- print_header("Build tools and options") # Mimalloc makes the cadabra2 module crash when run # as jupyter kernel, so disable for now. #find_package(mimalloc 2.0 QUIET) if(mimalloc_FOUND) message(STATUS "Using mimalloc allocator") else() message(STATUS "Using glibc allocator") endif() find_package(Catch2 3 QUIET) # This is optional; we will not run the C++ tests if Catch2 is not found if(Catch2_FOUND) message(STATUS "Will run C++ tests with Catch2") include(Catch) else() message(STATUS "Catch2 not found, will not run C++ tests") endif() # Jupyter kernel print_header("Configuring Jupyter kernel") if(ENABLE_JUPYTER) message(STATUS "Building the Xeus-based Jupyter kernel") # Currently only possible when building against Conda. set(CONDA_FOUND TRUE) else() set(CONDA_FOUND FALSE) if(ENABLE_PY_JUPYTER) message(STATUS "Building the default Jupyter kernel") else() message(STATUS "Not building a Jupyter kernel") endif() endif() if(ENABLE_PY_JUPYTER) add_subdirectory(jupyterkernel) endif() # Core/packages add_subdirectory(client_server) add_subdirectory(core) # Frontend if(ENABLE_FRONTEND) set(ENABLE_MICROTEX TRUE) if(ENABLE_MICROTEX) set(USE_MICROTEX TRUE) set(tinyxml2_BUILD_TESTING FALSE) endif() add_subdirectory(frontend) endif() # Tests if(BUILD_TESTS) add_subdirectory(tests) endif() add_subdirectory(web2 EXCLUDE_FROM_ALL) # Generate the core/Config.hh file; this needs to come as late as possible # in this CMakeLists.txt to ensure that all variables have been set. configure_file( "${PROJECT_SOURCE_DIR}/core/Config.hh.in" "${PROJECT_SOURCE_DIR}/core/Config.hh" ) # Some additional logic to install all runtime dependencies of our binaries # into the target installation directory on windows. if(WIN32) set(EXECUTABLES core/cadabra2-cli core/cdb-nbtool client_server/cadabra-server frontend/gtkmm/cadabra2-gtk ) list(JOIN EXECUTABLES " " LEXECUTABLES) # Custom command to run ldd, get dependencies, and install these in a # folder ready to be processed by `install`. The 'ldd' command does not # run on the '*.pyd' file, but if we rename or copy it to have extension '.dll' # all goes through fine... set(LDDSTR "ldd /${MSYS_ENV}/lib/gdk-pixbuf-2.0/2.10.0/loaders/pixbufloader_svg.dll core/cadabra2.dll ${LEXECUTABLES} | sed -e '/not found/d' -e '/Windows/d' -e '/System32/d' -e '/SysWOW64/d' | grep '=>' | sed -e 's/^[^=]*=>[ ]*\\([^ ]*\\).*/\\1/' | sort | uniq > ${CMAKE_BINARY_DIR}/ldd_dependencies.txt") message(STATUS "Determining dependencies using command ${LDDSTR}") add_custom_command( OUTPUT dummy1 COMMAND cp core/cadabra2.pyd core/cadabra2.dll COMMAND ${CMAKE_COMMAND} -E env bash -c "${LDDSTR}" COMMAND touch dummy1 VERBATIM DEPENDS core/cadabra2.pyd ${EXECUTABLES} COMMENT "Using ldd to determine dependencies of ${EXECUTABLES}" ) add_custom_command( OUTPUT dummy2 DEPENDS dummy1 COMMAND ${CMAKE_COMMAND} -E env bash -c "cat ${CMAKE_BINARY_DIR}/ldd_dependencies.txt && mkdir -p ${CMAKE_SOURCE_DIR}/deps && for f in `cat ${CMAKE_BINARY_DIR}/ldd_dependencies.txt`; do cp \${f} ${CMAKE_SOURCE_DIR}/deps/; done" COMMAND touch dummy2 VERBATIM COMMENT "Copying dependencies into ${CMAKE_SOURCE_DIR}/deps" ) add_custom_target("do_deps" ALL DEPENDS dummy2) # Install all the dependencies into the root destination folder. install(DIRECTORY deps/ DESTINATION . FILES_MATCHING PATTERN "*.dll") # And install a few more which, for reasons unknown, are not reported by dll. install(CODE "execute_process(COMMAND ls \"/${MSYS_ENV}/bin\") " ) winstall(FILES /${MSYS_ENV}/bin/libcharset-1.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/librsvg-2-2.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libxml2-2.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/liblzma-5.dll DESTINATION .) # FIXME: these can be found by running ldd on numpy and matplotlib dlls. winstall(FILES /${MSYS_ENV}/bin/libopenblas.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libgomp-1.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libgfortran-5.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libquadmath-0.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libsharpyuv-0.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libjpeg-8.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libtiff-6.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libdeflate.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libjbig-0.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libLerc.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libwebp-7.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libzstd.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libimagequant.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libopenjp2-7.dll DESTINATION .) # These are necessary only on ARM64. winstall(FILES /${MSYS_ENV}/bin/libgmp-10.dll DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/libgmpxx-4.dll DESTINATION .) # We need gdbus to setup the dbus, needed by Glib, otherwise anything # gtk-related will just bail out at start. We also need the helper # program to spawn programs using Glib. winstall(FILES /${MSYS_ENV}/bin/gdbus.exe DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/gspawn-win64-helper.exe DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/gspawn-win64-helper-console.exe DESTINATION .) winstall(FILES /${MSYS_ENV}/bin/gdk-pixbuf-query-loaders.exe DESTINATION .) endif() #--------------------------------------------------------------------------- # Provide uninstall target. #--------------------------------------------------------------------------- configure_file( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake" IMMEDIATE @ONLY ) add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake" ) #--------------------------------------------------------------------------- # Provide target to build AppImage. #--------------------------------------------------------------------------- # if(APPIMAGE_MODE) # add_custom_target(appimage # COMMAND mkdir -p AppDir/${Python_SITELIB} # COMMAND cp -a ${CMAKE_SOURCE_DIR}/config/AppRun AppDir/ # COMMAND chmod gou+x ${CMAKE_SOURCE_DIR}/config/AppRun AppDir/AppRun # COMMAND cp -a ${Python_SITELIB}/setuptools AppDir/${Python_SITELIB}/ # COMMAND cp -a ${Python_STDARCH}/* AppDir/${Python_STDARCH}/ # ) # endif() if(WIN32) add_custom_target(windows-installer COMMAND cpack # COMMAND osslsigncode sign -pkcs12 "/mnt/c/path/to/certificate.p12" -pass "certificate password" -n "Cadabra2" -i "https://cadabra.science" -t "http://timestamp.comodoca.com/authenticode" -in "cadabra2-${CADABRA_VERSION_SEM}-win64.exe" -out "cadabra2-${CADABRA_VERSION_SEM}-win64-installer.exe" COMMAND gh auth setup-git COMMAND release upload "${CADABRA_VERSION_SEM}" cadabra2-${CADABRA_VERSION_SEM}-win64.msi --clobber ) endif() print_header("All scripts completed")