diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml new file mode 100644 index 00000000000..9c350fe13c7 --- /dev/null +++ b/.github/workflows/cmake.yml @@ -0,0 +1,91 @@ +--- +name: CMake + +on: + push: + paths-ignore: + - 'doc/**' + branches: + - main + - releasebranch_* + pull_request: + paths-ignore: + - 'doc/**' + +concurrency: + group: ${{ github.workflow }}-${{ github.head_ref || github.ref }} + cancel-in-progress: true + +env: + CMAKE_UNITY_BUILD: OFF + +permissions: + contents: read + +jobs: + + build-cmake: + runs-on: ubuntu-22.04 + env: + CMakeVersion: "3.16.0" + steps: + - name: Checkout GRASS + uses: actions/checkout@v4.1.1 + - name: Install CMake + run: | + cd ${GITHUB_WORKSPACE} + arch=$(uname -s)-$(uname -m) + wget https://github.com/Kitware/CMake/releases/download/v3.16.0/cmake-3.16.0-${arch}.tar.gz + tar xzf cmake-${{ env.CMakeVersion }}-${arch}.tar.gz + echo "CMAKE_DIR=$GITHUB_WORKSPACE/cmake-${{ env.CMakeVersion }}-${arch}/bin" >> $GITHUB_ENV + echo "$GITHUB_WORKSPACE/cmake-${{ env.CMakeVersion }}-${arch}/bin" >> $GITHUB_PATH + - run: | + cmake --version + - name: Install dependencies + run: | + sudo apt-get update -y + sudo apt-get install -y wget git gawk findutils ninja-build + xargs -a <(awk '! /^ *(#|$)/' ".github/workflows/apt.txt") -r -- \ + sudo apt-get install -y --no-install-recommends --no-install-suggests + - name: Print build environment variables + shell: bash -el {0} + run: | + printenv | sort + gcc --version + ldd --version + - name: Create installation directory + run: | + mkdir $HOME/install + - name: Configure + run: | + cmake ${CMAKE_OPTIONS} -S $GITHUB_WORKSPACE -B $GITHUB_WORKSPACE/build -G Ninja \ + -DCMAKE_C_FLAGS="-I/usr/include -I/usr/include/gdal" \ + -DCMAKE_CXX_FLAGS="-I/usr/include -I/usr/include/gdal" \ + -DCMAKE_INSTALL_PREFIX=$HOME/install -DWITH_NLS=OFF -DWITH_GUI=OFF -DWITH_DOCS=OFF + - name: Print CMakeCache.txt + shell: bash -el {0} + run: | + cat ${GITHUB_WORKSPACE}/build/CMakeCache.txt + - name: Build + run: | + cmake --build build --verbose -j$(nproc) + - name: Install + run: | + cmake --install $GITHUB_WORKSPACE/build --verbose + - name: Add the bin directory to PATH + run: | + echo "$HOME/install/bin" >> $GITHUB_PATH + - name: Print installed versions + if: always() + run: .github/workflows/print_versions.sh + - name: Test executing of the grass command + run: .github/workflows/test_simple.sh + - name: Run tests + run: .github/workflows/test_thorough.sh --config .gunittest.cfg --min-success 72 + - name: Make HTML test report available + if: ${{ !cancelled() }} + uses: actions/upload-artifact@65c4c4a1ddee5b72f698fdd19549f0f0fb45cf08 # v4.6.0 + with: + name: testreport-CMake + path: testreport + retention-days: 3 diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 00000000000..e909d2b50c1 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,337 @@ +################################################################################ +# +# AUTHOR(S): Rashad Kanavath, Huidae Cho and Nicklas Larsson (main authors) +# +# PURPOSE: CMakeLists.txt root that adds options to activate/deactivate +# 3rd party libraries +# +# COPYRIGHT: (C) 2020-2025 by the GRASS Development Team +# +# SPDX-License-Identifier: GPL-2.0-or-later +# +################################################################################ + +cmake_minimum_required(VERSION 3.16) +set(CMAKE_DISABLE_IN_SOURCE_BUILD ON) + +#[[ +if(DEFINED ENV{VCPKG_DEFAULT_TRIPLET} AND NOT DEFINED VCPKG_TARGET_TRIPLET) +set(VCPKG_TARGET_TRIPLET "$ENV{VCPKG_DEFAULT_TRIPLET}" CACHE STRING "") +endif() +]] + +project(GRASS) +string(TOLOWER ${PROJECT_NAME} PROJECT_NAME_LOWER) + +set(BUILD_SHARED_LIBS ON) +# message(FATAL_ERROR "VCPKG_TARGET_TRIPLET=${VCPKG_TARGET_TRIPLET}") +if(MSVC) + if(BUILD_SHARED_LIBS) + set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE) + endif() + set_property(GLOBAL PROPERTY USE_FOLDERS ON) +endif() + +set(CMAKE_MODULE_PATH + "${CMAKE_SOURCE_DIR}/cmake/find_scripts;${CMAKE_SOURCE_DIR}/cmake/modules;${CMAKE_MODULE_PATH}" +) + +if(NOT CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 11) + set(CMAKE_CXX_STANDARD_REQUIRED ON) +endif() + +if(NOT CMAKE_C_STANDARD) + set(CMAKE_C_STANDARD 11) + set(CMAKE_C_STANDARD_REQUIRED ON) +endif() + +set(x11_default_option_enabled ON) +set(nls_default_option_enabled ON) +if(WIN32) + set(x11_default_option_enabled OFF) + set(nls_default_option_enabled OFF) +elseif(APPLE) + set(x11_default_option_enabled OFF) +endif() +set(lfs_default_option_enabled ON) + +# Configure CCache if available +if(NOT MSVC) + option(USE_CCACHE "Use ccache" ON) + if(USE_CCACHE) + find_program(CCACHE_FOUND ccache) + if(CCACHE_FOUND) + set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache) + set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache) + message(STATUS "ccache found") + endif(CCACHE_FOUND) + endif(USE_CCACHE) +endif(NOT MSVC) + +if(USE_ALTERNATE_LINKER) + include("cmake/modules/linker.cmake") +endif() + +if(CMAKE_BUILD_TYPE) + set(grass_build_type "${CMAKE_BUILD_TYPE}") + if(MSVC) + set(find_library_suffix "") + else() + string(TOLOWER "${grass_build_type}" grass_build_type_lc) + set(find_library_suffix "_RELEASE") + if(grass_build_type_lc STREQUAL "debug") + set(find_library_suffix "_DEBUG") + endif() + endif() +else() + set(find_library_suffix "") + if(MSVC) + set(CMAKE_BUILD_TYPE "DEBUG") + endif() +endif() + +# Graphics options +option(WITH_X11 "Build with X11 support ." ${x11_default_option_enabled}) +option(WITH_OPENGL "Build with opengl support ." ON) +option(WITH_CAIRO "Build with cairo support ." ON) +option(WITH_LIBPNG "Build with libpng support ." OFF) + +# Data storage options +option(WITH_SQLITE "Build with SQLite support" ON) +option(WITH_POSTGRES "Build with Postgres support" OFF) +option(WITH_MYSQL "Build with MySQL support" OFF) +if(WIN32) + option(WITH_ODBC "Build with ODBC support" OFF) +endif() +option(WITH_ZSTD "Build with zstd support" ON) +option(WITH_BZLIB "Build with bzlib support" OFF) + +# Command-line options +option(WITH_READLINE "Build with Readline support" OFF) + +# Language options +option(WITH_FREETYPE "Build with FreeType support" ON) +option(WITH_NLS "Build with NLS support" ${nls_default_option_enabled}) + +# Computing options +option(WITH_FFTW "Build with FFTW support" ON) +option(WITH_CBLAS "Build with CBLAS support" ON) +option(WITH_LAPACKE "Build with LAPACKE support" ON) +option(WITH_OPENMP "Build with OpenMP support" ON) + +# Data format options +option(WITH_TIFF "Build with LibTIFF support ." ON) +option(WITH_NETCDF "Build with NetCDF support" OFF) +option(WITH_GEOS "Build with GEOS support" OFF) +option(WITH_PDAL "Build with PDAL support" ON) +option(WITH_LIBLAS "Build with libLAS support" OFF) +option(WITH_OPENDWG "Build with OpenDWG support" OFF) + +# Other options +option(WITH_LARGEFILES "Build with large file support" + ${lfs_default_option_enabled}) +option(WITH_DOCS "Build documentation" ON) +option(WITH_GUI "Build GUI" ON) +option(WITH_FHS "Install with FHS" OFF) + +include(check_target) +include(CheckDependentLibraries) + +include(get_host_arch) +get_host_arch(BUILD_ARCH) + +include(get_versions) +get_versions("include/VERSION" GRASS_VERSION_MAJOR GRASS_VERSION_MINOR + GRASS_VERSION_RELEASE GRASS_VERSION_DATE) + +set(GRASS_VERSION_NUMBER + ${GRASS_VERSION_MAJOR}.${GRASS_VERSION_MINOR}.${GRASS_VERSION_RELEASE}) +message(STATUS "GRASS_VERSION_NUMBER = '${GRASS_VERSION_NUMBER}'") +set(GRASS_VERSION_UPDATE_PKG "0.2") + +# Setup GRASS install directories +include(GRASSInstallDirs) + +# Setup build locations. +if(MSVC) + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${CMAKE_BUILD_TYPE} ${OUTDIR}/${GRASS_INSTALL_LIBDIR}) +elseif(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY) + set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTDIR}/${GRASS_INSTALL_LIBDIR}) +endif() +if(MSVC) + set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${CMAKE_BUILD_TYPE} ${OUTDIR}/${GRASS_INSTALL_LIBDIR}) +elseif(NOT CMAKE_ARCHIVE_OUTPUT_DIRECTORY) + set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTDIR}/${GRASS_INSTALL_LIBDIR}) +endif() + +if(APPLE) + if(POLICY CMP0042) + cmake_policy(SET CMP0042 NEW) + endif() + set(CMAKE_MACOSX_RPATH TRUE) +endif() + +set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${GRASS_INSTALL_LIBDIR}") +set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) + +# TODO: a proper fix to this workaround +if(WITH_FHS) + file(CREATE_LINK ${OUTDIR}/${GRASS_INSTALL_DEMODIR} + ${RUNTIME_GISBASE}/demolocation SYMBOLIC) + file(CREATE_LINK ${OUTDIR}/${GRASS_INSTALL_FONTSDIR} ${RUNTIME_GISBASE}/fonts + SYMBOLIC) + file(CREATE_LINK ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/colors + ${RUNTIME_GISBASE}/etc/colors SYMBOLIC) + file(CREATE_LINK ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/colors.desc + ${RUNTIME_GISBASE}/etc/colors.desc SYMBOLIC) + file(CREATE_LINK ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/element_list + ${RUNTIME_GISBASE}/etc/element_list SYMBOLIC) + file(CREATE_LINK ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/renamed_options + ${RUNTIME_GISBASE}/etc/renamed_options SYMBOLIC) + file(CREATE_LINK ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/VERSIONNUMBER + ${RUNTIME_GISBASE}/etc/VERSIONNUMBER SYMBOLIC) + file(MAKE_DIRECTORY "${GISBASE}/gui/wxpython") + file(CREATE_LINK ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/wxpython/xml + ${RUNTIME_GISBASE}/gui/wxpython/xml SYMBOLIC) +endif() + +include(set_compiler_flags) +set_compiler_flags() +include(Configure) + +include(repo_status) +repo_status("${CMAKE_CURRENT_LIST_DIR}") + +enable_testing() + +include(build_module) +include(build_program) +include(build_program_in_subdir) +include(build_library_in_subdir) +include(copy_python_files_in_subdir) +include(build_script_in_subdir) +include(build_gui_in_subdir) +include(generate_html) + +set(MKHTML_PY ${CMAKE_BINARY_DIR}/utils/mkhtml.py) +set(THUMBNAILS_PY ${CMAKE_BINARY_DIR}/utils/thumbnails.py) +set(HTML2MAN VERSION_NUMBER=${GRASS_VERSION_NUMBER} ${PYTHON_EXECUTABLE} + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/g.html2man.py) + +set(env_path "$ENV{PATH}") + +if(WIN32) + set(NULL_DEVICE nul) + set(SEARCH_COMMAND findstr /v) + set(HTML_SEARCH_STR "\"\|\| \"") + set(sep "\;") + string(REPLACE ";" "${sep}" env_path "${env_path}") + set(grass_env_command + ${CMAKE_COMMAND} -E env "PATH=${BIN_DIR}${sep}${SCRIPTS_DIR}${sep}${env_path}${sep}${LIB_DIR}" + "PYTHONPATH=${ETC_PYTHON_DIR}${sep}${GUI_WXPYTHON_DIR}${sep}$ENV{PYTHONPATH}" + "GRASS_PYTHON=${PYTHON_EXECUTABLE}" "GISBASE=${RUN_GISBASE_NATIVE}" "GISRC=${GISRC}" "LC_ALL=C" "LANG=C" + "ARCH=${BUILD_ARCH}" "ARCH_DISTDIR=${RUN_GISBASE_NATIVE}" + "LANGUAGE=C" "MODULE_TOPDIR=${MODULE_TOPDIR}" "HTMLDIR=${DOC_DIR}" + "LC_ALL=C" "LANG=C" + "LANGUAGE=C" + "VERSION_NUMBER=\"${GRASS_VERSION_NUMBER}\"" + "VERSION_DATE=\"${GRASS_VERSION_DATE}\"") +else() + set(NULL_DEVICE /dev/null) + set(SEARCH_COMMAND grep -v) + set(HTML_SEARCH_STR "\'\|\| \'") + set(sep ":") + set(grass_env_command + ${CMAKE_COMMAND} -E env "PATH=${BIN_DIR}${sep}${SCRIPTS_DIR}${sep}${env_path}" + "PYTHONPATH=${ETC_PYTHON_DIR}${sep}${GUI_WXPYTHON_DIR}${sep}$ENV{PYTHONPATH}" + "LD_LIBRARY_PATH=${LIB_DIR}${sep}$ENV{LD_LIBRARY_PATH}" + "GISBASE=${RUN_GISBASE_NATIVE}" "GISRC=${GISRC}" "LC_ALL=C" "LANG=C" + "ARCH=${BUILD_ARCH}" "ARCH_DISTDIR=${RUN_GISBASE_NATIVE}" + "LANGUAGE=C" "MODULE_TOPDIR=${MODULE_TOPDIR}" "HTMLDIR=${DOC_DIR}" + "VERSION_NUMBER=\"${GRASS_VERSION_NUMBER}\"" + "VERSION_DATE=\"${GRASS_VERSION_DATE}\"") +endif() + +set(NO_HTML_DESCR_TARGETS "g.parser;ximgview;test.raster3d.lib") + +add_subdirectory(include) + +include_directories("${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}") +if(MSVC) + include_directories("${CMAKE_SOURCE_DIR}/msvc") +endif() + +# TODO: fix this hack +include_directories(${PostgreSQL_INCLUDE_DIR}) +include_directories(${PROJ_INCLUDE_DIR}) +include_directories(/opt/local/include) + +add_subdirectory(lib) +add_subdirectory(python) +add_subdirectory(utils) +set(modules_list) + +set(ALL_SUBDIRS + db + display + general + imagery + misc + ps + raster + raster3d + scripts + temporal + vector) + +foreach(d ${ALL_SUBDIRS}) + add_subdirectory(${d}) +endforeach() +add_custom_target( + ALL_MODULES + DEPENDS ${modules_list} + COMMENT "Building all modules.") + +if(WITH_GUI) + add_subdirectory(gui) +endif() + +if(WITH_DOCS) + add_subdirectory(doc) + add_subdirectory(man) +endif() + +add_custom_target( + r_colors_thumbnails ALL + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/colortables + COMMAND ${grass_env_command} ${PYTHON_EXECUTABLE} ${THUMBNAILS_PY} + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/colortables + BYPRODUCTS ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/colortables + COMMENT "Creating thumbnails" + DEPENDS ALL_MODULES) +install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/colortables + DESTINATION ${GRASS_INSTALL_DOCDIR}) + +set(misc_files + AUTHORS + CITING + contributors_extra.csv + contributors.csv + COPYING + GPL.TXT + INSTALL.md + REQUIREMENTS.md + translators.csv) +install(FILES ${misc_files} DESTINATION ${GRASS_INSTALL_MISCDIR}) + +if(WITH_NLS) + add_subdirectory(locale) +endif() + +# TODO: To be discussed - add_subdirectory(testsuite) - add_subdirectory(macosx) + +if(WITH_X11) + build_program_in_subdir(visualization/ximgview DEPENDS grass_gis X11) +endif() diff --git a/cmake/ctypesgen.cmake b/cmake/ctypesgen.cmake new file mode 100644 index 00000000000..6664ba066f8 --- /dev/null +++ b/cmake/ctypesgen.cmake @@ -0,0 +1,63 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: Cmake building of lib/python/ctypes (TODO) +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +set(ENV{GISRC} + "${OUTDIR}/${GRASS_INSTALL_DEMODIR}/.grassrc${GRASS_VERSION_MAJOR}${GRASS_VERSION_MINOR}" +) +set(ENV{GISBASE} "${OUTDIR}/${GISBASE_DIR}") +set(ENV{PATH} + "${OUTDIR}/${GRASS_INSTALL_BINDIR}:${OUTDIR}/${GRASS_INSTALL_SCRIPTDIR}:$ENV{PATH}" +) +set(ENV{PYTHONPATH} + "${OUTDIR}/${GRASS_INSTALL_GUIDIR}/wxpython:${OUTDIR}/${GRASS_INSTALL_PYDIR}:$ENV{PYTHONPATH}" +) +if(NOT MSVC) + set(ENV{LD_LIBRARY_PATH} + "${OUTDIR}/${GRASS_INSTALL_LIBDIR}:$ENV{LD_LIBRARY_PATH}") +endif() +set(ENV{LC_ALL} C) + +set(LIBRARIES) +foreach(LIB ${LIBS}) + list(APPEND LIBRARIES --library=${LIB}) +endforeach() + +set(HEADERS) +foreach(HDR ${HDRS}) + list(APPEND HEADERS "${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/${HDR}") +endforeach() + +foreach(req OUT_FILE HDRS LIBS CTYPESGEN_PY COMPILER) + if(NOT DEFINED ${req} OR "${${req}}" STREQUAL "") + message(FATAL_ERROR "you must set ${req}") + endif() +endforeach() + +if(MSVC) + set(CTYPESFLAGS "${COMPILER} -E -DPACKAGE=\"grasslibs\"") +else() + set(CTYPESFLAGS + "${COMPILER} -E -DPACKAGE=\"grasslibs\" -D__GLIBC_HAVE_LONG_LONG") +endif() + +message( + STATUS + "Running ${PYTHON_EXECUTABLE} ${CTYPESGEN_PY} --cpp=${CTYPESFLAGS} --no-embed-preamble --strip-build-path ${RUNTIME_GISBASE} --includedir=\"${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}\" ${LIBRARIES} ${HEADERS} --output=${OUT_FILE}" +) +execute_process( + COMMAND + ${PYTHON_EXECUTABLE} ${CTYPESGEN_PY} --cpp=${CTYPESFLAGS} + --no-embed-preamble --strip-build-path ${RUNTIME_GISBASE} + --includedir="${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}" ${LIBRARIES} ${HEADERS} + --output=${OUT_FILE} + OUTPUT_VARIABLE ctypesgen_OV + ERROR_VARIABLE ctypesgen_EV + RESULT_VARIABLE ctypesgen_RV) +if(ctypesgen_RV) + message(FATAL_ERROR "ctypesgen.py: ${ctypesgen_EV} \n ${ctypesgen_OV}") +endif() diff --git a/cmake/find_scripts/FindBLAS.cmake b/cmake/find_scripts/FindBLAS.cmake new file mode 100644 index 00000000000..2dc12b19344 --- /dev/null +++ b/cmake/find_scripts/FindBLAS.cmake @@ -0,0 +1,1426 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindBLAS +-------- + +Find Basic Linear Algebra Subprograms (BLAS) library + +This module finds an installed Fortran library that implements the +`BLAS linear-algebra interface`_. + +At least one of the ``C``, ``CXX``, or ``Fortran`` languages must be enabled. + +.. _`BLAS linear-algebra interface`: https://netlib.org/blas/ + +Input Variables +^^^^^^^^^^^^^^^ + +The following variables may be set to influence this module's behavior: + +``BLA_STATIC`` + if ``ON`` use static linkage + +``BLA_VENDOR`` + Set to one of the :ref:`BLAS/LAPACK Vendors` to search for BLAS only + from the specified vendor. If not set, all vendors are considered. + +``BLA_F95`` + if ``ON`` tries to find the BLAS95 interfaces + +``BLA_PREFER_PKGCONFIG`` + .. versionadded:: 3.11 + + if set ``pkg-config`` will be used to search for a BLAS library first + and if one is found that is preferred + +``BLA_PKGCONFIG_BLAS`` + .. versionadded:: 3.25 + + If set, the ``pkg-config`` method will look for this module name instead of + just ``blas``. + +``BLA_SIZEOF_INTEGER`` + .. versionadded:: 3.22 + + Specify the BLAS/LAPACK library integer size: + + ``4`` + Search for a BLAS/LAPACK with 32-bit integer interfaces. + ``8`` + Search for a BLAS/LAPACK with 64-bit integer interfaces. + ``ANY`` + Search for any BLAS/LAPACK. + Most likely, a BLAS/LAPACK with 32-bit integer interfaces will be found. + +Imported targets +^^^^^^^^^^^^^^^^ + +This module defines the following :prop_tgt:`IMPORTED` targets: + +``BLAS::BLAS`` + .. versionadded:: 3.18 + + The libraries to use for BLAS, if found. + +Result Variables +^^^^^^^^^^^^^^^^ + +This module defines the following variables: + +``BLAS_FOUND`` + library implementing the BLAS interface is found +``BLAS_LINKER_FLAGS`` + uncached list of required linker flags (excluding ``-l`` and ``-L``). +``BLAS_LIBRARIES`` + uncached list of libraries (using full path name) to link against + to use BLAS (may be empty if compiler implicitly links BLAS) +``BLAS95_LIBRARIES`` + uncached list of libraries (using full path name) to link against + to use BLAS95 interface +``BLAS95_FOUND`` + library implementing the BLAS95 interface is found + +.. _`BLAS/LAPACK Vendors`: + +BLAS/LAPACK Vendors +^^^^^^^^^^^^^^^^^^^ + +``Generic`` + Generic reference implementation + +``ACML``, ``ACML_MP``, ``ACML_GPU`` + AMD Core Math Library + +``AOCL``, ``AOCL_mt`` + .. versionadded:: 3.27 + + AMD Optimizing CPU Libraries + +``Apple``, ``NAS`` + Apple BLAS (Accelerate), and Apple NAS (vecLib) + +``Arm``, ``Arm_mp``, ``Arm_ilp64``, ``Arm_ilp64_mp`` + .. versionadded:: 3.18 + + Arm Performance Libraries + +``ATLAS`` + Automatically Tuned Linear Algebra Software + +``CXML``, ``DXML`` + Compaq/Digital Extended Math Library + +``EML``, ``EML_mt`` + .. versionadded:: 3.20 + + Elbrus Math Library + +``FLAME`` + .. versionadded:: 3.11 + + BLIS Framework + +``FlexiBLAS`` + .. versionadded:: 3.19 + +``Fujitsu_SSL2``, ``Fujitsu_SSL2BLAMP``, ``Fujitsu_SSL2SVE``, ``Fujitsu_SSL2BLAMPSVE`` + .. versionadded:: 3.20 + + Fujitsu SSL2 serial and parallel blas/lapack with SVE instructions + +``Goto`` + GotoBLAS + +``IBMESSL``, ``IBMESSL_SMP`` + + IBM Engineering and Scientific Subroutine Library + +``Intel`` + Intel MKL 32 bit and 64 bit obsolete versions + +``Intel10_32`` + Intel MKL v10 32 bit, threaded code + +``Intel10_64lp`` + Intel MKL v10+ 64 bit, threaded code, lp64 model + +``Intel10_64lp_seq`` + Intel MKL v10+ 64 bit, sequential code, lp64 model + +``Intel10_64ilp`` + .. versionadded:: 3.13 + + Intel MKL v10+ 64 bit, threaded code, ilp64 model + +``Intel10_64ilp_seq`` + .. versionadded:: 3.13 + + Intel MKL v10+ 64 bit, sequential code, ilp64 model + +``Intel10_64_dyn`` + .. versionadded:: 3.17 + + Intel MKL v10+ 64 bit, single dynamic library + +``libblastrampoline`` + .. versionadded:: 3.30 + + A BLAS/LAPACK demuxing library using PLT trampolines + +``NVHPC`` + .. versionadded:: 3.21 + + NVIDIA HPC SDK + +``OpenBLAS`` + .. versionadded:: 3.6 + +``PhiPACK`` + Portable High Performance ANSI C (PHiPAC) + +``SCSL``, ``SCSL_mp`` + Scientific Computing Software Library + +``SGIMATH`` + SGI Scientific Mathematical Library + +``SunPerf`` + Sun Performance Library + +.. _`Intel MKL`: + +Intel MKL +^^^^^^^^^ + +To use the Intel MKL implementation of BLAS, a project must enable at least +one of the ``C`` or ``CXX`` languages. Set ``BLA_VENDOR`` to an Intel MKL +variant either on the command-line as ``-DBLA_VENDOR=Intel10_64lp`` or in +project code: + +.. code-block:: cmake + + set(BLA_VENDOR Intel10_64lp) + find_package(BLAS) + +In order to build a project using Intel MKL, and end user must first +establish an Intel MKL environment: + +Intel oneAPI + Source the full Intel environment script: + + .. code-block:: shell + + . /opt/intel/oneapi/setvars.sh + + Or, source the MKL component environment script: + + .. code-block:: shell + + . /opt/intel/oneapi/mkl/latest/env/vars.sh + +Intel Classic + Source the full Intel environment script: + + .. code-block:: shell + + . /opt/intel/bin/compilervars.sh intel64 + + Or, source the MKL component environment script: + + .. code-block:: shell + + . /opt/intel/mkl/bin/mklvars.sh intel64 + +The above environment scripts set the ``MKLROOT`` environment variable +to the top of the MKL installation. They also add the location of the +runtime libraries to the dynamic library loader environment variable for +your platform (e.g. ``LD_LIBRARY_PATH``). This is necessary for programs +linked against MKL to run. + +.. note:: + + As of Intel oneAPI 2021.2, loading only the MKL component does not + make all of its dependencies available. In particular, the ``iomp5`` + library must be available separately, or provided by also loading + the compiler component environment: + + .. code-block:: shell + + . /opt/intel/oneapi/compiler/latest/env/vars.sh + +#]=======================================================================] + +# The approach follows that of the ``autoconf`` macro file, ``acx_blas.m4`` +# (distributed at http://ac-archive.sourceforge.net/ac-archive/acx_blas.html). + +# Check the language being used +if(NOT (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED OR CMAKE_Fortran_COMPILER_LOADED)) + if(BLAS_FIND_REQUIRED) + message(FATAL_ERROR "FindBLAS requires Fortran, C, or C++ to be enabled.") + else() + message(STATUS "Looking for BLAS... - NOT found (Unsupported languages)") + return() + endif() +endif() + +function(_add_blas_target) + if(BLAS_FOUND AND NOT TARGET BLAS::BLAS) + add_library(BLAS::BLAS INTERFACE IMPORTED) + if(BLAS_LIBRARIES) + set_target_properties(BLAS::BLAS PROPERTIES + INTERFACE_LINK_LIBRARIES "${BLAS_LIBRARIES}" + ) + endif() + if(BLAS_LINKER_FLAGS) + set_target_properties(BLAS::BLAS PROPERTIES + INTERFACE_LINK_OPTIONS "${BLAS_LINKER_FLAGS}" + ) + endif() + endif() +endfunction() + +if(CMAKE_Fortran_COMPILER_LOADED) + include(CheckFortranFunctionExists) +else() + include(CheckFunctionExists) +endif() +include(FindPackageHandleStandardArgs) + +if(BLA_PREFER_PKGCONFIG) + if(NOT BLA_PKGCONFIG_BLAS) + set(BLA_PKGCONFIG_BLAS "blas") + endif() + find_package(PkgConfig QUIET) + if(PKG_CONFIG_FOUND) + pkg_check_modules(PKGC_BLAS QUIET ${BLA_PKGCONFIG_BLAS}) + if(PKGC_BLAS_FOUND) + set(BLAS_FOUND ${PKGC_BLAS_FOUND}) + set(BLAS_LIBRARIES "${PKGC_BLAS_LINK_LIBRARIES}") + set(BLAS_INCLUDE_DIRS "${PKGC_BLAS_INCLUDE_DIRS}") + _add_blas_target() + return() + endif() + endif() +endif() + +# TODO: move this stuff to a separate module + +function(CHECK_BLAS_LIBRARIES LIBRARIES _prefix _name _flags _list _deps _addlibdir _subdirs) + # This function checks for the existence of the combination of libraries + # given by _list. If the combination is found, this checks whether can link + # against that library combination using the name of a routine given by _name + # using the linker flags given by _flags. If the combination of libraries is + # found and passes the link test, ${LIBRARIES} is set to the list of complete + # library paths that have been found. Otherwise, ${LIBRARIES} is set to FALSE. + + set(_libraries_work TRUE) + set(_libraries) + set(_combined_name) + + if(BLA_STATIC) + if(WIN32) + set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES}) + else() + set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) + endif() + else() + if(CMAKE_SYSTEM_NAME STREQUAL "Linux") + # for ubuntu's libblas3gf and liblapack3gf packages + set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf) + endif() + endif() + + set(_extaddlibdir "${_addlibdir}") + if(WIN32) + list(APPEND _extaddlibdir ENV LIB) + elseif(APPLE) + list(APPEND _extaddlibdir ENV DYLD_LIBRARY_PATH) + else() + list(APPEND _extaddlibdir ENV LD_LIBRARY_PATH) + endif() + list(APPEND _extaddlibdir "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}") + + foreach(_library ${_list}) + if(_library MATCHES "^-") + # Respect linker flags as-is (required by MKL) + list(APPEND _libraries "${_library}") + else() + string(REGEX REPLACE "[^A-Za-z0-9]" "_" _lib_var "${_library}") + string(APPEND _combined_name "_${_lib_var}") + if(NOT "${_deps}" STREQUAL "") + string(APPEND _combined_name "_deps") + endif() + if(_libraries_work) + find_library(${_prefix}_${_lib_var}_LIBRARY + NAMES ${_library} + NAMES_PER_DIR + PATHS ${_extaddlibdir} + PATH_SUFFIXES ${_subdirs} + ) + mark_as_advanced(${_prefix}_${_lib_var}_LIBRARY) + list(APPEND _libraries ${${_prefix}_${_lib_var}_LIBRARY}) + set(_libraries_work ${${_prefix}_${_lib_var}_LIBRARY}) + endif() + endif() + endforeach() + + foreach(_flag ${_flags}) + string(REGEX REPLACE "[^A-Za-z0-9]" "_" _flag_var "${_flag}") + string(APPEND _combined_name "_${_flag_var}") + endforeach() + if(_libraries_work) + # Test this combination of libraries. + set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${_libraries} ${_deps}) + set(CMAKE_REQUIRED_QUIET ${BLAS_FIND_QUIETLY}) + if(CMAKE_Fortran_COMPILER_LOADED) + check_fortran_function_exists("${_name}" ${_prefix}${_combined_name}_WORKS) + else() + check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS) + endif() + set(CMAKE_REQUIRED_LIBRARIES) + set(_libraries_work ${${_prefix}${_combined_name}_WORKS}) + endif() + + if(_libraries_work) + if("${_list}" STREQUAL "") + set(_libraries "${LIBRARIES}-PLACEHOLDER-FOR-EMPTY-LIBRARIES") + else() + list(APPEND _libraries ${_deps}) + endif() + else() + set(_libraries FALSE) + endif() + set(${LIBRARIES} "${_libraries}" PARENT_SCOPE) +endfunction() + +set(BLAS_LINKER_FLAGS) +set(BLAS_LIBRARIES) +set(BLAS95_LIBRARIES) +set(_blas_fphsa_req_var BLAS_LIBRARIES) +if(NOT BLA_VENDOR) + if(NOT "$ENV{BLA_VENDOR}" STREQUAL "") + set(BLA_VENDOR "$ENV{BLA_VENDOR}") + else() + set(BLA_VENDOR "All") + endif() +endif() + +if(NOT BLA_SIZEOF_INTEGER) + # in the reality we do not know which API of BLAS/LAPACK is masked in library + set(_blas_sizeof_integer "ANY") +elseif((BLA_SIZEOF_INTEGER STREQUAL "ANY") OR + (BLA_SIZEOF_INTEGER STREQUAL "4") OR + (BLA_SIZEOF_INTEGER STREQUAL "8")) + set(_blas_sizeof_integer ${BLA_SIZEOF_INTEGER}) +else() + message(FATAL_ERROR "BLA_SIZEOF_INTEGER can have only , ANY, 4, or 8 values") +endif() + +# Implicitly linked BLAS libraries? +if(BLA_VENDOR STREQUAL "All") + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "" + "" + "" + "" + ) + endif() + if(BLAS_WORKS) + # Give a more helpful "found" message + set(BLAS_WORKS "implicitly linked") + set(_blas_fphsa_req_var BLAS_WORKS) + endif() +endif() + +# BLAS in the Intel MKL 10+ library? +if(BLA_VENDOR MATCHES "Intel" OR BLA_VENDOR STREQUAL "All") + if(NOT BLAS_LIBRARIES) + if(CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED) + # System-specific settings + if(WIN32) + if(BLA_STATIC) + set(BLAS_mkl_DLL_SUFFIX "") + else() + set(BLAS_mkl_DLL_SUFFIX "_dll") + endif() + else() + if(BLA_STATIC) + set(BLAS_mkl_START_GROUP "-Wl,--start-group") + set(BLAS_mkl_END_GROUP "-Wl,--end-group") + else() + set(BLAS_mkl_START_GROUP "") + set(BLAS_mkl_END_GROUP "") + endif() + # Switch to GNU Fortran support layer if needed (but not on Apple, where MKL does not provide it) + if(CMAKE_Fortran_COMPILER_LOADED AND (CMAKE_Fortran_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "LCC") AND NOT APPLE) + set(BLAS_mkl_INTFACE "gf") + set(BLAS_mkl_THREADING "gnu") + set(BLAS_mkl_OMP "gomp") + else() + set(BLAS_mkl_INTFACE "intel") + set(BLAS_mkl_THREADING "intel") + set(BLAS_mkl_OMP "iomp5") + endif() + set(BLAS_mkl_LM "-lm") + set(BLAS_mkl_LDL "-ldl") + endif() + + if(BLAS_FIND_QUIETLY OR NOT BLAS_FIND_REQUIRED) + find_package(Threads) + else() + find_package(Threads REQUIRED) + endif() + + if(_blas_sizeof_integer EQUAL 8) + set(BLAS_mkl_ILP_MODE "ilp64") + elseif(_blas_sizeof_integer EQUAL 4) + set(BLAS_mkl_ILP_MODE "lp64") + else() + if(BLA_VENDOR MATCHES "_64ilp") + set(BLAS_mkl_ILP_MODE "ilp64") + else() + set(BLAS_mkl_ILP_MODE "lp64") + endif() + endif() + + set(BLAS_SEARCH_LIBS "") + + if(BLA_F95) + set(BLAS_mkl_SEARCH_SYMBOL "sgemm_f95") + set(_BLAS_LIBRARIES BLAS95_LIBRARIES) + if(WIN32) + # Find the main file (32-bit or 64-bit) + set(BLAS_SEARCH_LIBS_WIN_MAIN "") + if(BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN + "mkl_blas95${BLAS_mkl_DLL_SUFFIX} mkl_intel_c${BLAS_mkl_DLL_SUFFIX}") + endif() + + if(BLA_VENDOR MATCHES "^Intel10_64i?lp" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN + "mkl_blas95_${BLAS_mkl_ILP_MODE}${BLAS_mkl_DLL_SUFFIX} mkl_intel_${BLAS_mkl_ILP_MODE}${BLAS_mkl_DLL_SUFFIX}") + endif() + + # Add threading/sequential libs + set(BLAS_SEARCH_LIBS_WIN_THREAD "") + if(BLA_VENDOR MATCHES "^Intel10_64i?lp$" OR BLA_VENDOR STREQUAL "All") + # old version + list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD + "libguide40 mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}") + # mkl >= 10.3 + list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD + "libiomp5md mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}") + endif() + if(BLA_VENDOR MATCHES "^Intel10_64i?lp_seq$" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD + "mkl_sequential${BLAS_mkl_DLL_SUFFIX}") + endif() + + # Cartesian product of the above + foreach(MAIN ${BLAS_SEARCH_LIBS_WIN_MAIN}) + foreach(THREAD ${BLAS_SEARCH_LIBS_WIN_THREAD}) + list(APPEND BLAS_SEARCH_LIBS + "${MAIN} ${THREAD} mkl_core${BLAS_mkl_DLL_SUFFIX}") + endforeach() + endforeach() + else() + if(BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") + # old version + list(APPEND BLAS_SEARCH_LIBS + "mkl_blas95 mkl_${BLAS_mkl_INTFACE} mkl_${BLAS_mkl_THREADING}_thread mkl_core guide") + + # mkl >= 10.3 + list(APPEND BLAS_SEARCH_LIBS + "${BLAS_mkl_START_GROUP} mkl_blas95 mkl_${BLAS_mkl_INTFACE} mkl_${BLAS_mkl_THREADING}_thread mkl_core ${BLAS_mkl_END_GROUP} ${BLAS_mkl_OMP}") + endif() + if(BLA_VENDOR MATCHES "^Intel10_64i?lp$" OR BLA_VENDOR STREQUAL "All") + # old version + list(APPEND BLAS_SEARCH_LIBS + "mkl_blas95 mkl_${BLAS_mkl_INTFACE}_${BLAS_mkl_ILP_MODE} mkl_${BLAS_mkl_THREADING}_thread mkl_core guide") + + # mkl >= 10.3 + list(APPEND BLAS_SEARCH_LIBS + "${BLAS_mkl_START_GROUP} mkl_blas95_${BLAS_mkl_ILP_MODE} mkl_${BLAS_mkl_INTFACE}_${BLAS_mkl_ILP_MODE} mkl_${BLAS_mkl_THREADING}_thread mkl_core ${BLAS_mkl_END_GROUP} ${BLAS_mkl_OMP}") + endif() + if(BLA_VENDOR MATCHES "^Intel10_64i?lp_seq$" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS + "${BLAS_mkl_START_GROUP} mkl_blas95_${BLAS_mkl_ILP_MODE} mkl_${BLAS_mkl_INTFACE}_${BLAS_mkl_ILP_MODE} mkl_sequential mkl_core ${BLAS_mkl_END_GROUP}") + endif() + endif() + else() + set(BLAS_mkl_SEARCH_SYMBOL sgemm) + set(_BLAS_LIBRARIES BLAS_LIBRARIES) + if(WIN32) + # Find the main file (32-bit or 64-bit) + set(BLAS_SEARCH_LIBS_WIN_MAIN "") + if(BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN + "mkl_intel_c${BLAS_mkl_DLL_SUFFIX}") + endif() + if(BLA_VENDOR MATCHES "^Intel10_64i?lp" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS_WIN_MAIN + "mkl_intel_${BLAS_mkl_ILP_MODE}${BLAS_mkl_DLL_SUFFIX}") + endif() + + # Add threading/sequential libs + set(BLAS_SEARCH_LIBS_WIN_THREAD "") + if(BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD + "libiomp5md mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}") + endif() + if(BLA_VENDOR MATCHES "^Intel10_64i?lp$" OR BLA_VENDOR STREQUAL "All") + # old version + list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD + "libguide40 mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}") + # mkl >= 10.3 + list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD + "libiomp5md mkl_intel_thread${BLAS_mkl_DLL_SUFFIX}") + endif() + if(BLA_VENDOR MATCHES "^Intel10_64i?lp_seq$" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS_WIN_THREAD + "mkl_sequential${BLAS_mkl_DLL_SUFFIX}") + endif() + + # Cartesian product of the above + foreach(MAIN ${BLAS_SEARCH_LIBS_WIN_MAIN}) + foreach(THREAD ${BLAS_SEARCH_LIBS_WIN_THREAD}) + list(APPEND BLAS_SEARCH_LIBS + "${MAIN} ${THREAD} mkl_core${BLAS_mkl_DLL_SUFFIX}") + endforeach() + endforeach() + else() + if(BLA_VENDOR STREQUAL "Intel10_32" OR BLA_VENDOR STREQUAL "All") + # old version + list(APPEND BLAS_SEARCH_LIBS + "mkl_${BLAS_mkl_INTFACE} mkl_${BLAS_mkl_THREADING}_thread mkl_core guide") + + # mkl >= 10.3 + list(APPEND BLAS_SEARCH_LIBS + "${BLAS_mkl_START_GROUP} mkl_${BLAS_mkl_INTFACE} mkl_${BLAS_mkl_THREADING}_thread mkl_core ${BLAS_mkl_END_GROUP} ${BLAS_mkl_OMP}") + endif() + if(BLA_VENDOR MATCHES "^Intel10_64i?lp$" OR BLA_VENDOR STREQUAL "All") + # old version + list(APPEND BLAS_SEARCH_LIBS + "mkl_${BLAS_mkl_INTFACE}_${BLAS_mkl_ILP_MODE} mkl_${BLAS_mkl_THREADING}_thread mkl_core guide") + + # mkl >= 10.3 + list(APPEND BLAS_SEARCH_LIBS + "${BLAS_mkl_START_GROUP} mkl_${BLAS_mkl_INTFACE}_${BLAS_mkl_ILP_MODE} mkl_${BLAS_mkl_THREADING}_thread mkl_core ${BLAS_mkl_END_GROUP} ${BLAS_mkl_OMP}") + endif() + if(BLA_VENDOR MATCHES "^Intel10_64i?lp_seq$" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS + "${BLAS_mkl_START_GROUP} mkl_${BLAS_mkl_INTFACE}_${BLAS_mkl_ILP_MODE} mkl_sequential mkl_core ${BLAS_mkl_END_GROUP}") + endif() + + #older versions of intel mkl libs + if(BLA_VENDOR STREQUAL "Intel" OR BLA_VENDOR STREQUAL "All") + list(APPEND BLAS_SEARCH_LIBS + "mkl") + list(APPEND BLAS_SEARCH_LIBS + "mkl_ia32") + list(APPEND BLAS_SEARCH_LIBS + "mkl_em64t") + endif() + endif() + endif() + + if(BLA_VENDOR MATCHES "^Intel10_64_dyn$" OR BLA_VENDOR STREQUAL "All") + # mkl >= 10.3 with single dynamic library + list(APPEND BLAS_SEARCH_LIBS + "mkl_rt") + endif() + + # MKL uses a multitude of partially platform-specific subdirectories: + if(BLA_VENDOR STREQUAL "Intel10_32") + set(BLAS_mkl_ARCH_NAME "ia32") + else() + set(BLAS_mkl_ARCH_NAME "intel64") + endif() + if(WIN32) + set(BLAS_mkl_OS_NAME "win") + elseif(APPLE) + set(BLAS_mkl_OS_NAME "mac") + else() + set(BLAS_mkl_OS_NAME "lin") + endif() + if(DEFINED ENV{MKLROOT}) + file(TO_CMAKE_PATH "$ENV{MKLROOT}" BLAS_mkl_MKLROOT) + # If MKLROOT points to the subdirectory 'mkl', use the parent directory instead + # so we can better detect other relevant libraries in 'compiler' or 'tbb': + get_filename_component(BLAS_mkl_MKLROOT_LAST_DIR "${BLAS_mkl_MKLROOT}" NAME) + if(BLAS_mkl_MKLROOT_LAST_DIR STREQUAL "mkl") + get_filename_component(BLAS_mkl_MKLROOT "${BLAS_mkl_MKLROOT}" DIRECTORY) + endif() + endif() + set(BLAS_mkl_LIB_PATH_SUFFIXES + "compiler/lib" "compiler/lib/${BLAS_mkl_ARCH_NAME}_${BLAS_mkl_OS_NAME}" + "compiler/lib/${BLAS_mkl_ARCH_NAME}" + "mkl/lib" "mkl/lib/${BLAS_mkl_ARCH_NAME}_${BLAS_mkl_OS_NAME}" + "mkl/lib/${BLAS_mkl_ARCH_NAME}" + "lib" "lib/${BLAS_mkl_ARCH_NAME}_${BLAS_mkl_OS_NAME}" + "lib/${BLAS_mkl_ARCH_NAME}" + ) + + foreach(_search ${BLAS_SEARCH_LIBS}) + string(REPLACE " " ";" _search ${_search}) + if(NOT ${_BLAS_LIBRARIES}) + check_blas_libraries( + ${_BLAS_LIBRARIES} + BLAS + ${BLAS_mkl_SEARCH_SYMBOL} + "" + "${_search}" + "${CMAKE_THREAD_LIBS_INIT};${BLAS_mkl_LM};${BLAS_mkl_LDL}" + "${BLAS_mkl_MKLROOT}" + "${BLAS_mkl_LIB_PATH_SUFFIXES}" + ) + endif() + endforeach() + + unset(_search) + unset(BLAS_mkl_ILP_MODE) + unset(BLAS_mkl_INTFACE) + unset(BLAS_mkl_THREADING) + unset(BLAS_mkl_OMP) + unset(BLAS_mkl_DLL_SUFFIX) + unset(BLAS_mkl_LM) + unset(BLAS_mkl_LDL) + unset(BLAS_mkl_MKLROOT) + unset(BLAS_mkl_MKLROOT_LAST_DIR) + unset(BLAS_mkl_ARCH_NAME) + unset(BLAS_mkl_OS_NAME) + unset(BLAS_mkl_LIB_PATH_SUFFIXES) + endif() + endif() +endif() + +if(BLA_F95) + find_package_handle_standard_args(BLAS REQUIRED_VARS BLAS95_LIBRARIES) + set(BLAS95_FOUND ${BLAS_FOUND}) + if(BLAS_FOUND) + set(BLAS_LIBRARIES "${BLAS95_LIBRARIES}") + endif() +endif() + +# gotoblas? (http://www.tacc.utexas.edu/tacc-projects/gotoblas2) +if(BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All") + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "goto2" + "" + "" + "" + ) + endif() +endif() + +# FlexiBLAS? (http://www.mpi-magdeburg.mpg.de/mpcsc/software/FlexiBLAS/) +if(BLA_VENDOR STREQUAL "FlexiBLAS" OR BLA_VENDOR STREQUAL "All") + set(_blas_flexiblas_lib "flexiblas") + + if(_blas_sizeof_integer EQUAL 8) + string(APPEND _blas_flexiblas_lib "64") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_flexiblas_lib}" + "" + "" + "" + ) + endif() + + unset(_blas_flexiblas_lib) +endif() + +# OpenBLAS? (http://www.openblas.net) +if(BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All") + set(_blas_openblas_lib "openblas") + + if(_blas_sizeof_integer EQUAL 8) + if(MINGW) + string(APPEND _blas_openblas_lib "_64") + else() + string(APPEND _blas_openblas_lib "64") + endif() + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_openblas_lib}" + "" + "" + "" + ) + endif() + if(NOT BLAS_LIBRARIES AND (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED)) + if(BLAS_FIND_QUIETLY OR NOT BLAS_FIND_REQUIRED) + find_package(Threads) + else() + find_package(Threads REQUIRED) + endif() + set(_threadlibs "${CMAKE_THREAD_LIBS_INIT}") + if(BLA_STATIC) + if (CMAKE_C_COMPILER_LOADED) + find_package(OpenMP QUIET COMPONENTS C) + list(PREPEND _threadlibs "${OpenMP_C_LIBRARIES}") + elseif(CMAKE_CXX_COMPILER_LOADED) + find_package(OpenMP QUIET COMPONENTS CXX) + list(PREPEND _threadlibs "${OpenMP_CXX_LIBRARIES}") + endif() + endif() + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_openblas_lib}" + "${_threadlibs}" + "" + "" + ) + unset(_threadlibs) + endif() + + unset(_blas_openblas_lib) +endif() + +# ArmPL blas library? (https://developer.arm.com/tools-and-software/server-and-hpc/compile/arm-compiler-for-linux/arm-performance-libraries) +if(BLA_VENDOR MATCHES "Arm" OR BLA_VENDOR STREQUAL "All") + + # Check for 64bit Integer support + if(_blas_sizeof_integer EQUAL 8) + set(_blas_armpl_lib "armpl_ilp64") + elseif(_blas_sizeof_integer EQUAL 4) + set(_blas_armpl_lib "armpl_lp64") + else() + if(BLA_VENDOR MATCHES "_ilp64") + set(_blas_armpl_lib "armpl_ilp64") + else() + set(_blas_armpl_lib "armpl_lp64") + endif() + endif() + + # Check for OpenMP support, VIA BLA_VENDOR of Arm_mp or Arm_ipl64_mp + if(BLA_VENDOR MATCHES "_mp") + string(APPEND _blas_armpl_lib "_mp") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_armpl_lib}" + "" + "" + "" + ) + endif() + unset(_blas_armpl_lib) +endif() + +# FLAME's blis library? (https://github.com/flame/blis) +if(BLA_VENDOR STREQUAL "FLAME" OR BLA_VENDOR STREQUAL "All") + set(_blas_flame_lib "blis") + + if(_blas_sizeof_integer EQUAL 8) + string(APPEND _blas_flame_lib "64") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_flame_lib}" + "" + "" + "" + ) + endif() + + unset(_blas_flame_lib) +endif() + +# AOCL's blis library? (https://developer.amd.com/amd-aocl/) +if(BLA_VENDOR MATCHES "AOCL" OR BLA_VENDOR STREQUAL "All") + set(_blas_aocl_lib "blis") + + if(_blas_sizeof_integer EQUAL 8) + set(_blas_aocl_subdir "ILP64") + else() + set(_blas_aocl_subdir "LP64") + endif() + + # Check for multi-threaded support + if(BLA_VENDOR MATCHES "_mt") + string(APPEND _blas_aocl_lib "-mt") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_aocl_lib}" + "" + "" + "${_blas_aocl_subdir}" + ) + endif() + + unset(_blas_aocl_lib) + unset(_blas_aocl_subdir) +endif() + +# BLAS in the ATLAS library? (http://math-atlas.sourceforge.net/) +if(BLA_VENDOR STREQUAL "ATLAS" OR BLA_VENDOR STREQUAL "All") + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + dgemm + "" + "blas;f77blas;atlas" + "" + "" + "" + ) + endif() +endif() + +# BLAS in PhiPACK libraries? (requires generic BLAS lib, too) +if(BLA_VENDOR STREQUAL "PhiPACK" OR BLA_VENDOR STREQUAL "All") + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "sgemm;dgemm;blas" + "" + "" + "" + ) + endif() +endif() + +# BLAS in Alpha CXML library? +if(BLA_VENDOR STREQUAL "CXML" OR BLA_VENDOR STREQUAL "All") + if(_blas_sizeof_integer EQUAL 8) + if(BLA_VENDOR STREQUAL "CXML") + message(FATAL_ERROR "CXML does not support Int64 type") + endif() + else() + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "cxml" + "" + "" + "" + ) + endif() + endif() +endif() + +# BLAS in Alpha DXML library? (now called CXML, see above) +if(BLA_VENDOR STREQUAL "DXML" OR BLA_VENDOR STREQUAL "All") + if(_blas_sizeof_integer EQUAL 8) + if(BLA_VENDOR STREQUAL "DXML") + message(FATAL_ERROR "DXML does not support Int64 type") + endif() + else() + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "dxml" + "" + "" + "" + ) + endif() + endif() +endif() + +# BLAS in Sun Performance library? +if(BLA_VENDOR STREQUAL "SunPerf" OR BLA_VENDOR STREQUAL "All") + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "-xlic_lib=sunperf" + "sunperf;sunmath" + "" + "" + "" + ) + if(BLAS_LIBRARIES) + set(BLAS_LINKER_FLAGS "-xlic_lib=sunperf") + endif() + endif() +endif() + +# BLAS in SCSL library? (SGI/Cray Scientific Library) +if(BLA_VENDOR MATCHES "SCSL" OR BLA_VENDOR STREQUAL "All") + set(_blas_scsl_lib "scs") + + if(_blas_sizeof_integer EQUAL 8) + string(APPEND _blas_scsl_lib "_i8") + endif() + if(BLA_VENDOR MATCHES "_mp") + string(APPEND _blas_scsl_lib "_mp") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_scsl_lib}" + "" + "" + "" + ) + endif() + + unset(_blas_scsl_lib) +endif() + +# BLAS in SGIMATH library? +if(BLA_VENDOR STREQUAL "SGIMATH" OR BLA_VENDOR STREQUAL "All") + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "complib.sgimath" + "" + "" + "" + ) + endif() +endif() + +# BLAS in IBM ESSL library? +if(BLA_VENDOR MATCHES "IBMESSL" OR BLA_VENDOR STREQUAL "All") + set(_blas_essl_lib "essl") + + if(BLA_VENDOR MATCHES "_SMP") + string(APPEND _blas_essl_lib "smp") + endif() + if(_blas_sizeof_integer EQUAL 8) + string(APPEND _blas_essl_lib "6464") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_essl_lib}" + "" + "" + "" + ) + endif() + + unset(_blas_essl_lib) +endif() + +# BLAS in acml library? +if(BLA_VENDOR MATCHES "ACML" OR BLA_VENDOR STREQUAL "All") + if(((BLA_VENDOR STREQUAL "ACML") AND (NOT BLAS_ACML_LIB_DIRS)) OR + ((BLA_VENDOR STREQUAL "ACML_MP") AND (NOT BLAS_ACML_MP_LIB_DIRS)) OR + ((BLA_VENDOR STREQUAL "ACML_GPU") AND (NOT BLAS_ACML_GPU_LIB_DIRS)) + ) + # try to find acml in "standard" paths + if(WIN32) + file(GLOB _ACML_ROOT "C:/AMD/acml*/ACML-EULA.txt") + else() + file(GLOB _ACML_ROOT "/opt/acml*/ACML-EULA.txt") + endif() + if(WIN32) + file(GLOB _ACML_GPU_ROOT "C:/AMD/acml*/GPGPUexamples") + else() + file(GLOB _ACML_GPU_ROOT "/opt/acml*/GPGPUexamples") + endif() + list(GET _ACML_ROOT 0 _ACML_ROOT) + list(GET _ACML_GPU_ROOT 0 _ACML_GPU_ROOT) + if(_ACML_ROOT) + get_filename_component(_ACML_ROOT ${_ACML_ROOT} PATH) + if(_blas_sizeof_integer EQUAL 8) + set(_ACML_PATH_SUFFIX "_int64") + else() + set(_ACML_PATH_SUFFIX "") + endif() + if(CMAKE_Fortran_COMPILER_ID STREQUAL "Intel") + set(_ACML_COMPILER32 "ifort32") + set(_ACML_COMPILER64 "ifort64") + elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "IntelLLVM") + # 32-bit not supported + set(_ACML_COMPILER64 "ifx") + elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "SunPro") + set(_ACML_COMPILER32 "sun32") + set(_ACML_COMPILER64 "sun64") + elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "PGI") + set(_ACML_COMPILER32 "pgi32") + if(WIN32) + set(_ACML_COMPILER64 "win64") + else() + set(_ACML_COMPILER64 "pgi64") + endif() + elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "Open64") + # 32 bit builds not supported on Open64 but for code simplicity + # We'll just use the same directory twice + set(_ACML_COMPILER32 "open64_64") + set(_ACML_COMPILER64 "open64_64") + elseif(CMAKE_Fortran_COMPILER_ID STREQUAL "NAG") + set(_ACML_COMPILER32 "nag32") + set(_ACML_COMPILER64 "nag64") + else() + set(_ACML_COMPILER32 "gfortran32") + set(_ACML_COMPILER64 "gfortran64") + endif() + + if(BLA_VENDOR STREQUAL "ACML_MP") + set(_ACML_MP_LIB_DIRS + "${_ACML_ROOT}/${_ACML_COMPILER32}_mp${_ACML_PATH_SUFFIX}/lib" + "${_ACML_ROOT}/${_ACML_COMPILER64}_mp${_ACML_PATH_SUFFIX}/lib") + else() + set(_ACML_LIB_DIRS + "${_ACML_ROOT}/${_ACML_COMPILER32}${_ACML_PATH_SUFFIX}/lib" + "${_ACML_ROOT}/${_ACML_COMPILER64}${_ACML_PATH_SUFFIX}/lib") + endif() + endif() +elseif(BLAS_${BLA_VENDOR}_LIB_DIRS) + set(_${BLA_VENDOR}_LIB_DIRS ${BLAS_${BLA_VENDOR}_LIB_DIRS}) +endif() + +if(BLA_VENDOR STREQUAL "ACML_MP") + foreach(BLAS_ACML_MP_LIB_DIRS ${_ACML_MP_LIB_DIRS}) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" "acml_mp;acml_mv" "" ${BLAS_ACML_MP_LIB_DIRS} "" + ) + if(BLAS_LIBRARIES) + break() + endif() + endforeach() +elseif(BLA_VENDOR STREQUAL "ACML_GPU") + foreach(BLAS_ACML_GPU_LIB_DIRS ${_ACML_GPU_LIB_DIRS}) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" "acml;acml_mv;CALBLAS" "" ${BLAS_ACML_GPU_LIB_DIRS} "" + ) + if(BLAS_LIBRARIES) + break() + endif() + endforeach() +else() + foreach(BLAS_ACML_LIB_DIRS ${_ACML_LIB_DIRS}) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" "acml;acml_mv" "" ${BLAS_ACML_LIB_DIRS} "" + ) + if(BLAS_LIBRARIES) + break() + endif() + endforeach() +endif() + +# Either acml or acml_mp should be in LD_LIBRARY_PATH but not both +if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "acml;acml_mv" + "" + "" + "" + ) +endif() +if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "acml_mp;acml_mv" + "" + "" + "" + ) +endif() +if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "acml;acml_mv;CALBLAS" + "" + "" + "" + ) +endif() +endif() # ACML + +# Apple BLAS library? +if(BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All") + if(_blas_sizeof_integer EQUAL 8) + if(BLA_VENDOR STREQUAL "Apple") + message(FATAL_ERROR "Accelerate Framework does not support Int64 type") + endif() + else() + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + dgemm + "" + "Accelerate" + "" + "" + "" + ) + endif() + endif() +endif() + +# Apple NAS (vecLib) library? +if(BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All") + if(_blas_sizeof_integer EQUAL 8) + if(BLA_VENDOR STREQUAL "NAS") + message(FATAL_ERROR "Accelerate Framework does not support Int64 type") + endif() + else() + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + dgemm + "" + "vecLib" + "" + "" + "" + ) + endif() + endif() +endif() + +# Elbrus Math Library? +if(BLA_VENDOR MATCHES "EML" OR BLA_VENDOR STREQUAL "All") + + set(_blas_eml_lib "eml") + + if(_blas_sizeof_integer EQUAL 8) + string(APPEND _blas_eml_lib "_ilp64") + endif() + # Check for OpenMP support, VIA BLA_VENDOR of eml_mt + if(BLA_VENDOR MATCHES "_mt") + string(APPEND _blas_eml_lib "_mt") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_eml_lib}" + "" + "" + "" + ) + endif() + unset(_blas_eml_lib) +endif() + +# Fujitsu SSL2 Library? +if(NOT BLAS_LIBRARIES + AND (BLA_VENDOR MATCHES "^Fujitsu_SSL2" OR BLA_VENDOR STREQUAL "All")) + set(_blas_fjlapack_lib "fjlapack") + set(_blas_fjlapack_flags "-Kopenmp") + + if(BLA_VENDOR MATCHES "BLAMP") + string(APPEND _blas_fjlapack_lib "ex") + endif() + if(BLA_VENDOR MATCHES "SVE") + string(APPEND _blas_fjlapack_lib "sve") + endif() + if(_blas_sizeof_integer EQUAL 8) + string(APPEND _blas_fjlapack_lib "_ilp64") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "${_blas_fjlapack_flags}" + "${_blas_fjlapack_lib}" + "" + "" + "" + ) + if(BLAS_LIBRARIES) + set(BLAS_LINKER_FLAGS ${_blas_fjlapack_flags}) + endif() + endif() + + unset(_blas_fjlapack_flags) + unset(_blas_fjlapack_lib) +endif() + +# BLAS in nVidia HPC SDK? (https://developer.nvidia.com/hpc-sdk) +if(BLA_VENDOR STREQUAL "NVHPC" OR BLA_VENDOR STREQUAL "All") + set(_blas_nvhpc_lib "blas") + + if(_blas_sizeof_integer EQUAL 8) + string(APPEND _blas_nvhpc_lib "_ilp64") + elseif(_blas_sizeof_integer EQUAL 4) + string(APPEND _blas_nvhpc_lib "_lp64") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_nvhpc_lib}" + "" + "" + "" + ) + endif() + + # an additional check for NVHPC 2020 + # which does not have differentiation + # between lp64 and ilp64 modes + if(NOT BLAS_LIBRARIES AND NOT _blas_sizeof_integer EQUAL 8) + set(_blas_nvhpc_lib "blas") + + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_nvhpc_lib}" + "" + "" + "" + ) + endif() + + unset(_blas_nvhpc_lib) +endif() + +# libblastrampoline? (https://github.com/JuliaLinearAlgebra/libblastrampoline/tree/main) +if(BLA_VENDOR STREQUAL "libblastrampoline" OR BLA_VENDOR STREQUAL "All") + set(_blas_libblastrampoline_lib "blastrampoline") + + if(WIN32) + # Windows appends the version number to the library + string(APPEND _blas_libblastrampoline_lib "-5") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_libblastrampoline_lib}" + "" + "" + "" + ) + endif() + + unset(_blas_libblastrampoline_lib) +endif() + +# Generic BLAS library? +if(BLA_VENDOR STREQUAL "Generic" OR + BLA_VENDOR STREQUAL "All") + set(_blas_generic_lib "blas") + + if(_blas_sizeof_integer EQUAL 8) + string(APPEND _blas_generic_lib "64") + endif() + + if(NOT BLAS_LIBRARIES) + check_blas_libraries( + BLAS_LIBRARIES + BLAS + sgemm + "" + "${_blas_generic_lib}" + "" + "" + "" + ) + endif() + + unset(_blas_generic_lib) +endif() + +# On compilers that implicitly link BLAS (i.e. CrayPrgEnv) we used a +# placeholder for empty BLAS_LIBRARIES to get through our logic above. +if(BLAS_LIBRARIES STREQUAL "BLAS_LIBRARIES-PLACEHOLDER-FOR-EMPTY-LIBRARIES") + set(BLAS_LIBRARIES "") +endif() + +if(NOT BLA_F95) + find_package_handle_standard_args(BLAS REQUIRED_VARS ${_blas_fphsa_req_var}) +endif() + +_add_blas_target() +unset(_blas_fphsa_req_var) +unset(_blas_sizeof_integer) +unset(_BLAS_LIBRARIES) diff --git a/cmake/find_scripts/FindCairo.cmake b/cmake/find_scripts/FindCairo.cmake new file mode 100644 index 00000000000..c6551cb0fdc --- /dev/null +++ b/cmake/find_scripts/FindCairo.cmake @@ -0,0 +1,125 @@ +#[[ +- Try to find Cairo +Once done, this will define + + CAIRO_FOUND - system has Cairo + CAIRO_INCLUDE_DIRS - the Cairo include directories + CAIRO_LIBRARIES - link these to use Cairo + +Copyright (C) 2012 Raphael Kubo da Costa + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND ITS CONTRIBUTORS ``AS +IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR ITS +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +#]] + +find_package(PkgConfig QUIET) +pkg_check_modules(PC_CAIRO cairo QUIET) # FIXME: After we require CMake 2.8.2 we + # can pass QUIET to this call. + +find_path( + CAIRO_INCLUDE_DIRS + NAMES cairo.h + HINTS ${PC_CAIRO_INCLUDEDIR} ${PC_CAIRO_INCLUDE_DIRS} + PATH_SUFFIXES cairo) + +find_library( + CAIRO_LIBRARY_RELEASE + NAMES cairo + HINTS ${PC_CAIRO_LIBDIR} ${PC_CAIRO_LIBRARY_DIRS}) + +find_library( + CAIRO_LIBRARY_DEBUG + NAMES cairod + HINTS ${PC_CAIRO_LIBDIR} ${PC_CAIRO_LIBRARY_DIRS}) + +set(CAIRO_LIBRARY) +if(CAIRO_LIBRARY_DEBUG) + set(CAIRO_LIBRARY ${CAIRO_LIBRARY_DEBUG}) +elseif(CAIRO_LIBRARY_RELEASE) + set(CAIRO_LIBRARY ${CAIRO_LIBRARY_RELEASE}) +endif() + +if(CAIRO_INCLUDE_DIRS) + if(EXISTS "${CAIRO_INCLUDE_DIRS}/cairo-version.h") + file(READ "${CAIRO_INCLUDE_DIRS}/cairo-version.h" CAIRO_VERSION_CONTENT) + + string(REGEX MATCH "#define +CAIRO_VERSION_MAJOR +([0-9]+)" _dummy + "${CAIRO_VERSION_CONTENT}") + set(CAIRO_VERSION_MAJOR "${CMAKE_MATCH_1}") + + string(REGEX MATCH "#define +CAIRO_VERSION_MINOR +([0-9]+)" _dummy + "${CAIRO_VERSION_CONTENT}") + set(CAIRO_VERSION_MINOR "${CMAKE_MATCH_1}") + + string(REGEX MATCH "#define +CAIRO_VERSION_MICRO +([0-9]+)" _dummy + "${CAIRO_VERSION_CONTENT}") + set(CAIRO_VERSION_MICRO "${CMAKE_MATCH_1}") + + set(CAIRO_VERSION + "${CAIRO_VERSION_MAJOR}.${CAIRO_VERSION_MINOR}.${CAIRO_VERSION_MICRO}") + endif() +endif() + +# FIXME: Should not be needed anymore once we start depending on CMake 2.8.3 +set(VERSION_OK TRUE) +if(Cairo_FIND_VERSION) + if(Cairo_FIND_VERSION_EXACT) + if("${Cairo_FIND_VERSION}" VERSION_EQUAL "${CAIRO_VERSION}") + # FIXME: Use IF (NOT ...) with CMake 2.8.2+ to get rid of the ELSE block + else() + set(VERSION_OK FALSE) + endif() + else() + if("${Cairo_FIND_VERSION}" VERSION_GREATER "${CAIRO_VERSION}") + set(VERSION_OK FALSE) + endif() + endif() +endif() + +find_path(FONTCONFIG_INCLUDE_DIR fontconfig/fontconfig.h) + +if(FONTCONFIG_INCLUDE_DIR) + set(CAIRO_INCLUDE_DIRS ${CAIRO_INCLUDE_DIRS} ${FONTCONFIG_INCLUDE_DIR}) +else() + message( + STATUS + "fontconfig/fontconfig.h was not found. \n I had to unset(CAIRO_INCLUDE_DIRS) to make find_package() fail \n " + ) + unset(CAIRO_INCLUDE_DIRS CACHE) +endif() + +find_library(FONTCONFIG_LIBRARY NAMES fontconfig) +if(FONTCONFIG_LIBRARY) + set(CAIRO_LIBRARIES ${CAIRO_LIBRARY} ${FONTCONFIG_LIBRARY}) +else() + message( + STATUS + "fontconfig library file was not found. \n I had to unset(CAIRO_LIBRARIES) to make find_package() fail \n " + ) + unset(CAIRO_LIBRARIES CACHE) +endif() + +mark_as_advanced(CAIRO_INCLUDE_DIRS CAIRO_LIBRARY CAIRO_LIBRARY_RELEASE + CAIRO_LIBRARY_DEBUG FONTCONFIG_LIBRARY FONTCONFIG_INCLUDE_DIR) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Cairo DEFAULT_MSG CAIRO_INCLUDE_DIRS + CAIRO_LIBRARIES VERSION_OK) diff --git a/cmake/find_scripts/FindFFTW-egpbos.cmake b/cmake/find_scripts/FindFFTW-egpbos.cmake new file mode 100644 index 00000000000..1861b54c19d --- /dev/null +++ b/cmake/find_scripts/FindFFTW-egpbos.cmake @@ -0,0 +1,421 @@ +# - Find the FFTW library +# +# Original version of this file: +# Copyright (c) 2015, Wenzel Jakob +# https://github.com/wjakob/layerlab/blob/master/cmake/FindFFTW.cmake, commit 4d58bfdc28891b4f9373dfe46239dda5a0b561c6 +# Modifications: +# Copyright (c) 2017, Patrick Bos +# +# Usage: +# find_package(FFTW [REQUIRED] [QUIET] [COMPONENTS component1 ... componentX] ) +# +# It sets the following variables: +# FFTW_FOUND ... true if fftw is found on the system +# FFTW_[component]_LIB_FOUND ... true if the component is found on the system (see components below) +# FFTW_LIBRARIES ... full paths to all found fftw libraries +# FFTW_[component]_LIB ... full path to one of the components (see below) +# FFTW_INCLUDE_DIRS ... fftw include directory paths +# +# The following variables will be checked by the function +# FFTW_USE_STATIC_LIBS ... if true, only static libraries are found, otherwise both static and shared. +# FFTW_ROOT ... if set, the libraries are exclusively searched +# under this path +# +# This package supports the following components: +# FLOAT_LIB +# DOUBLE_LIB +# LONGDOUBLE_LIB +# FLOAT_THREADS_LIB +# DOUBLE_THREADS_LIB +# LONGDOUBLE_THREADS_LIB +# FLOAT_OPENMP_LIB +# DOUBLE_OPENMP_LIB +# LONGDOUBLE_OPENMP_LIB +# + +# From: https://github.com/egpbos/findFFTW/tree/master + +# TODO (maybe): extend with ExternalProject download + build option +# TODO: put on conda-forge + + +if( NOT FFTW_ROOT AND DEFINED ENV{FFTWDIR} ) + set( FFTW_ROOT $ENV{FFTWDIR} ) +endif() + +# Check if we can use PkgConfig +find_package(PkgConfig) + +#Determine from PKG +if( PKG_CONFIG_FOUND AND NOT FFTW_ROOT ) + pkg_check_modules( PKG_FFTW QUIET "fftw3" ) +endif() + +#Check whether to search static or dynamic libs +set( CMAKE_FIND_LIBRARY_SUFFIXES_SAV ${CMAKE_FIND_LIBRARY_SUFFIXES} ) + +if( ${FFTW_USE_STATIC_LIBS} ) + set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX} ) +else() + set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_SAV} ) +endif() + +if( FFTW_ROOT ) + # find libs + + find_library( + FFTW_DOUBLE_LIB + NAMES "fftw3" libfftw3-3 + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_DOUBLE_THREADS_LIB + NAMES "fftw3_threads" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_DOUBLE_OPENMP_LIB + NAMES "fftw3_omp" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_DOUBLE_MPI_LIB + NAMES "fftw3_mpi" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_FLOAT_LIB + NAMES "fftw3f" libfftw3f-3 + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_FLOAT_THREADS_LIB + NAMES "fftw3f_threads" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_FLOAT_OPENMP_LIB + NAMES "fftw3f_omp" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_FLOAT_MPI_LIB + NAMES "fftw3f_mpi" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_LONGDOUBLE_LIB + NAMES "fftw3l" libfftw3l-3 + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_LONGDOUBLE_THREADS_LIB + NAMES "fftw3l_threads" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_LONGDOUBLE_OPENMP_LIB + NAMES "fftw3l_omp" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTW_LONGDOUBLE_MPI_LIB + NAMES "fftw3l_mpi" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + #find includes + find_path(FFTW_INCLUDE_DIRS + NAMES "fftw3.h" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "include" + NO_DEFAULT_PATH + ) + +else() + + find_library( + FFTW_DOUBLE_LIB + NAMES "fftw3" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTW_DOUBLE_THREADS_LIB + NAMES "fftw3_threads" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTW_DOUBLE_OPENMP_LIB + NAMES "fftw3_omp" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTW_DOUBLE_MPI_LIB + NAMES "fftw3_mpi" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTW_FLOAT_LIB + NAMES "fftw3f" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTW_FLOAT_THREADS_LIB + NAMES "fftw3f_threads" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTW_FLOAT_OPENMP_LIB + NAMES "fftw3f_omp" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTW_FLOAT_MPI_LIB + NAMES "fftw3f_mpi" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTW_LONGDOUBLE_LIB + NAMES "fftw3l" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTW_LONGDOUBLE_THREADS_LIB + NAMES "fftw3l_threads" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library(FFTW_LONGDOUBLE_OPENMP_LIB + NAMES "fftw3l_omp" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library(FFTW_LONGDOUBLE_MPI_LIB + NAMES "fftw3l_mpi" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_path(FFTW_INCLUDE_DIRS + NAMES "fftw3.h" + PATHS ${PKG_FFTW_INCLUDE_DIRS} ${INCLUDE_INSTALL_DIR} + ) + +endif( FFTW_ROOT ) + +#--------------------------------------- components + +if (FFTW_DOUBLE_LIB) + set(FFTW_DOUBLE_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_DOUBLE_LIB}) + add_library(FFTW::Double INTERFACE IMPORTED) + set_target_properties(FFTW::Double + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_DOUBLE_LIB}" + ) +else() + set(FFTW_DOUBLE_LIB_FOUND FALSE) +endif() + +if (FFTW_FLOAT_LIB) + set(FFTW_FLOAT_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_FLOAT_LIB}) + add_library(FFTW::Float INTERFACE IMPORTED) + set_target_properties(FFTW::Float + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_FLOAT_LIB}" + ) +else() + set(FFTW_FLOAT_LIB_FOUND FALSE) +endif() + +if (FFTW_LONGDOUBLE_LIB) + set(FFTW_LONGDOUBLE_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_LONGDOUBLE_LIB}) + add_library(FFTW::LongDouble INTERFACE IMPORTED) + set_target_properties(FFTW::LongDouble + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_LONGDOUBLE_LIB}" + ) +else() + set(FFTW_LONGDOUBLE_LIB_FOUND FALSE) +endif() + +if (FFTW_DOUBLE_THREADS_LIB) + set(FFTW_DOUBLE_THREADS_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_DOUBLE_THREADS_LIB}) + add_library(FFTW::DoubleThreads INTERFACE IMPORTED) + set_target_properties(FFTW::DoubleThreads + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_DOUBLE_THREADS_LIB}" + ) +else() + set(FFTW_DOUBLE_THREADS_LIB_FOUND FALSE) +endif() + +if (FFTW_FLOAT_THREADS_LIB) + set(FFTW_FLOAT_THREADS_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_FLOAT_THREADS_LIB}) + add_library(FFTW::FloatThreads INTERFACE IMPORTED) + set_target_properties(FFTW::FloatThreads + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_FLOAT_THREADS_LIB}" + ) +else() + set(FFTW_FLOAT_THREADS_LIB_FOUND FALSE) +endif() + +if (FFTW_LONGDOUBLE_THREADS_LIB) + set(FFTW_LONGDOUBLE_THREADS_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_LONGDOUBLE_THREADS_LIB}) + add_library(FFTW::LongDoubleThreads INTERFACE IMPORTED) + set_target_properties(FFTW::LongDoubleThreads + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_LONGDOUBLE_THREADS_LIB}" + ) +else() + set(FFTW_LONGDOUBLE_THREADS_LIB_FOUND FALSE) +endif() + +if (FFTW_DOUBLE_OPENMP_LIB) + set(FFTW_DOUBLE_OPENMP_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_DOUBLE_OPENMP_LIB}) + add_library(FFTW::DoubleOpenMP INTERFACE IMPORTED) + set_target_properties(FFTW::DoubleOpenMP + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_DOUBLE_OPENMP_LIB}" + ) +else() + set(FFTW_DOUBLE_OPENMP_LIB_FOUND FALSE) +endif() + +if (FFTW_FLOAT_OPENMP_LIB) + set(FFTW_FLOAT_OPENMP_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_FLOAT_OPENMP_LIB}) + add_library(FFTW::FloatOpenMP INTERFACE IMPORTED) + set_target_properties(FFTW::FloatOpenMP + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_FLOAT_OPENMP_LIB}" + ) +else() + set(FFTW_FLOAT_OPENMP_LIB_FOUND FALSE) +endif() + +if (FFTW_LONGDOUBLE_OPENMP_LIB) + set(FFTW_LONGDOUBLE_OPENMP_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_LONGDOUBLE_OPENMP_LIB}) + add_library(FFTW::LongDoubleOpenMP INTERFACE IMPORTED) + set_target_properties(FFTW::LongDoubleOpenMP + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_LONGDOUBLE_OPENMP_LIB}" + ) +else() + set(FFTW_LONGDOUBLE_OPENMP_LIB_FOUND FALSE) +endif() + +if (FFTW_DOUBLE_MPI_LIB) + set(FFTW_DOUBLE_MPI_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_DOUBLE_MPI_LIB}) + add_library(FFTW::DoubleMPI INTERFACE IMPORTED) + set_target_properties(FFTW::DoubleMPI + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_DOUBLE_MPI_LIB}" + ) +else() + set(FFTW_DOUBLE_MPI_LIB_FOUND FALSE) +endif() + +if (FFTW_FLOAT_MPI_LIB) + set(FFTW_FLOAT_MPI_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_FLOAT_MPI_LIB}) + add_library(FFTW::FloatMPI INTERFACE IMPORTED) + set_target_properties(FFTW::FloatMPI + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_FLOAT_MPI_LIB}" + ) +else() + set(FFTW_FLOAT_MPI_LIB_FOUND FALSE) +endif() + +if (FFTW_LONGDOUBLE_MPI_LIB) + set(FFTW_LONGDOUBLE_MPI_LIB_FOUND TRUE) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTW_LONGDOUBLE_MPI_LIB}) + add_library(FFTW::LongDoubleMPI INTERFACE IMPORTED) + set_target_properties(FFTW::LongDoubleMPI + PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${FFTW_INCLUDE_DIRS}" + INTERFACE_LINK_LIBRARIES "${FFTW_LONGDOUBLE_MPI_LIB}" + ) +else() + set(FFTW_LONGDOUBLE_MPI_LIB_FOUND FALSE) +endif() + +#--------------------------------------- end components + +set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_SAV} ) + +include(FindPackageHandleStandardArgs) + +find_package_handle_standard_args(FFTW + REQUIRED_VARS FFTW_INCLUDE_DIRS + HANDLE_COMPONENTS + ) + +mark_as_advanced( + FFTW_INCLUDE_DIRS + FFTW_LIBRARIES + FFTW_FLOAT_LIB + FFTW_DOUBLE_LIB + FFTW_LONGDOUBLE_LIB + FFTW_FLOAT_THREADS_LIB + FFTW_DOUBLE_THREADS_LIB + FFTW_LONGDOUBLE_THREADS_LIB + FFTW_FLOAT_OPENMP_LIB + FFTW_DOUBLE_OPENMP_LIB + FFTW_LONGDOUBLE_OPENMP_LIB + FFTW_FLOAT_MPI_LIB + FFTW_DOUBLE_MPI_LIB + FFTW_LONGDOUBLE_MPI_LIB + ) diff --git a/cmake/find_scripts/FindFFTW-eigen.cmake b/cmake/find_scripts/FindFFTW-eigen.cmake new file mode 100644 index 00000000000..e0415e3d944 --- /dev/null +++ b/cmake/find_scripts/FindFFTW-eigen.cmake @@ -0,0 +1,119 @@ +# - Find the FFTW library +# +# Usage: +# find_package(FFTW [REQUIRED] [QUIET] ) +# +# It sets the following variables: +# FFTW_FOUND ... true if fftw is found on the system +# FFTW_LIBRARIES ... full path to fftw library +# FFTW_INCLUDES ... fftw include directory +# +# The following variables will be checked by the function +# FFTW_USE_STATIC_LIBS ... if true, only static libraries are found +# FFTW_ROOT ... if set, the libraries are exclusively searched +# under this path +# FFTW_LIBRARY ... fftw library to use +# FFTW_INCLUDE_DIR ... fftw include directory +# + +#If environment variable FFTWDIR is specified, it has same effect as FFTW_ROOT +if( NOT FFTW_ROOT AND ENV{FFTWDIR} ) + set( FFTW_ROOT $ENV{FFTWDIR} ) +endif() + +# Check if we can use PkgConfig +include(CMakeFindDependencyMacro) +find_dependency(PkgConfig) + +#Determine from PKG +if( PKG_CONFIG_FOUND AND NOT FFTW_ROOT ) + pkg_check_modules( PKG_FFTW QUIET "fftw3" ) +endif() + +#Check whether to search static or dynamic libs +set( CMAKE_FIND_LIBRARY_SUFFIXES_SAV ${CMAKE_FIND_LIBRARY_SUFFIXES} ) + +if( ${FFTW_USE_STATIC_LIBS} ) + set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_STATIC_LIBRARY_SUFFIX} ) +else() + set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_SHARED_LIBRARY_SUFFIX} ) +endif() + +if( FFTW_ROOT ) + + #find libs + find_library( + FFTW_LIB + NAMES "fftw3" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTWF_LIB + NAMES "fftw3f" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + find_library( + FFTWL_LIB + NAMES "fftw3l" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "lib" "lib64" + NO_DEFAULT_PATH + ) + + #find includes + find_path( + FFTW_INCLUDES + NAMES "fftw3.h" + PATHS ${FFTW_ROOT} + PATH_SUFFIXES "include" + NO_DEFAULT_PATH + ) + +else() + + find_library( + FFTW_LIB + NAMES "fftw3" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_library( + FFTWF_LIB + NAMES "fftw3f" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + + find_library( + FFTWL_LIB + NAMES "fftw3l" + PATHS ${PKG_FFTW_LIBRARY_DIRS} ${LIB_INSTALL_DIR} + ) + + find_path( + FFTW_INCLUDES + NAMES "fftw3.h" + PATHS ${PKG_FFTW_INCLUDE_DIRS} ${INCLUDE_INSTALL_DIR} + ) + +endif() + +set(FFTW_LIBRARIES ${FFTW_LIB} ${FFTWF_LIB}) + +if(FFTWL_LIB) + set(FFTW_LIBRARIES ${FFTW_LIBRARIES} ${FFTWL_LIB}) +endif() + +set( CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES_SAV} ) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(FFTW DEFAULT_MSG + FFTW_INCLUDES FFTW_LIBRARIES) + +mark_as_advanced(FFTW_INCLUDES FFTW_LIBRARIES FFTW_LIB FFTWF_LIB FFTWL_LIB) diff --git a/cmake/find_scripts/FindFFTW.cmake b/cmake/find_scripts/FindFFTW.cmake new file mode 100644 index 00000000000..f9c92a4c33d --- /dev/null +++ b/cmake/find_scripts/FindFFTW.cmake @@ -0,0 +1,65 @@ +find_path(FFTW_INCLUDE_DIR fftw3.h) + +if(FFTW_INCLUDE_DIR) + set(HAVE_FFTW3_H 1) + message(STATUS "Found fftw3.h in ${FFTW_INCLUDE_DIR}") +else() + find_path(FFTW_INCLUDE_DIR fftw.h) + if(FFTW_INCLUDE_DIR) + set(HAVE_FFTW_H 1) + message(STATUS "Found fftw.h in ${FFTW_INCLUDE_DIR}") + endif() +endif() + +find_path(DFFTW_INCLUDE_DIR dfftw.h) +if(DFFTW_INCLUDE_DIR) + set(HAVE_DFFTW_H 1) + message(STATUS "Found dfftw.h in ${FFTW_INCLUDE_DIR}") +endif() + +# fftw double lib +find_library(FFTWD_LIB fftw3) +find_library(FFTWD_THREADS_LIB fftw3_threads) # threads support + +set(FFTW_LIBRARIES) +if(FFTWD_LIB) + set(FFTWD_FOUND 1) + set(FFTW_LIBRARIES ${FFTWD_LIB}) + if(FFTWD_THREADS_LIB) + set(FFTW_LIBRARIES "${FFTW_LIBRARIES};${FFTWD_THREADS_LIB}") + endif() +endif() + +# Single Precision +find_library(FFTWF_LIB fftw3f) +find_library(FFTWF_THREADS_LIB fftw3f_threads) # threads support + +if(FFTWF_LIB) + set(FFTWF_FOUND 1) + set(FFTW_LIBRARIES "${FFTW_LIBRARIES};${FFTWF_LIB}") + if(FFTWF_THREADS_LIB) + set(FFTW_LIBRARIES "${FFTW_LIBRARIES};${FFTWF_THREADS_LIB}") + endif() +endif() + +if(NOT FFTWD_FOUND AND NOT FFTWF_FOUND) + set(FFTW_FOUND FALSE) +endif() + +mark_as_advanced( + FFTW_LIBRARIES + FFTW_INCLUDE_DIR + DFFTW_INCLUDE_DIR + FFTWF_LIB + FFTWF_THREADS_LIB + FFTWD_LIB + FFTWD_THREADS_LIB) + +# copy HAVE_ to parent scope so that we can use in include/CMakeLists.txt and +# rest +set(HAVE_FFTW3_H ${HAVE_FFTW3_H}) +set(HAVE_FFTW_H ${HAVE_FFTW_H}) +set(HAVE_DFFTW_H ${HAVE_DFFTW_H}) +include(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake) +find_package_handle_standard_args(FFTW REQUIRED_VARS FFTW_LIBRARIES + FFTW_INCLUDE_DIR) diff --git a/cmake/find_scripts/FindFontConfig.cmake b/cmake/find_scripts/FindFontConfig.cmake new file mode 100644 index 00000000000..c7d228c7cc2 --- /dev/null +++ b/cmake/find_scripts/FindFontConfig.cmake @@ -0,0 +1,37 @@ +#[[ +- Find FontConfig library +Find the FontConfig includes and library +This module defines + FONTCONFIG_INCLUDE_DIR, where to find fontconfig.h + FONTCONFIG_LIBRARIES, libraries to link against to use the FontConfig API. + FONTCONFIG_FOUND, If false, do not try to use FontConfig. + +============================================================================= +Copyright 2012 Kitware, Inc. + +Distributed under the OSI-approved BSD License (the "License"); +see accompanying file Copyright.txt for details. + +This software is distributed WITHOUT ANY WARRANTY; without even the +implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +See the License for more information. +============================================================================= +(To distribute this file outside of VTK, substitute the full + License text for the above reference.) +#]] + +find_path(FONTCONFIG_INCLUDE_DIR fontconfig/fontconfig.h) + +find_library(FONTCONFIG_LIBRARY NAMES fontconfig) + +# handle the QUIETLY and REQUIRED arguments and set FONTCONFIG_FOUND to TRUE if +# all listed variables are TRUE +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(FontConfig DEFAULT_MSG FONTCONFIG_LIBRARY + FONTCONFIG_INCLUDE_DIR) + +if(FONTCONFIG_FOUND) + set(FONTCONFIG_LIBRARIES ${FONTCONFIG_LIBRARY}) +endif() + +mark_as_advanced(FONTCONFIG_INCLUDE_DIR FONTCONFIG_LIBRARY FONTCONFIG_LIBRARIES) diff --git a/cmake/find_scripts/FindGDAL.cmake b/cmake/find_scripts/FindGDAL.cmake new file mode 100644 index 00000000000..08479a2d7dd --- /dev/null +++ b/cmake/find_scripts/FindGDAL.cmake @@ -0,0 +1,25 @@ +find_path(GDAL_INCLUDE_DIR gdal.h PATH_SUFFIXES gdal) + +find_library(GDAL_LIBRARY_RELEASE NAMES gdal_i gdal) +find_library(GDAL_LIBRARY_DEBUG NAMES gdald) +set(GDAL_FOUND FALSE) + +set(GDAL_LIBRARY) +if(GDAL_LIBRARY_DEBUG) + set(GDAL_LIBRARY + ${GDAL_LIBRARY_DEBUG} + CACHE FILEPATH "doc") +elseif(GDAL_LIBRARY_RELEASE) + set(GDAL_LIBRARY + ${GDAL_LIBRARY_RELEASE} + CACHE FILEPATH "doc") +endif() + +mark_as_advanced(GDAL_LIBRARY_RELEASE) +mark_as_advanced(GDAL_LIBRARY_DEBUG) +mark_as_advanced(GDAL_LIBRARY) +mark_as_advanced(GDAL_INCLUDE_DIR) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(GDAL DEFAULT_MSG GDAL_LIBRARY + GDAL_INCLUDE_DIR) diff --git a/cmake/find_scripts/FindGEOS.cmake b/cmake/find_scripts/FindGEOS.cmake new file mode 100644 index 00000000000..17fe3831095 --- /dev/null +++ b/cmake/find_scripts/FindGEOS.cmake @@ -0,0 +1,52 @@ +#[[ +File: FindGEOS.cmake + +Find the native GEOS(Geometry Engine - Open Source) includes and libraries. + +This module defines: + +GEOS_INCLUDE_DIR, where to find geos.h, etc. + +GEOS_LIBRARY, libraries to link against to use GEOS. Currently there are +two looked for, geos and geos_c libraries. + +GEOS_FOUND, True if found, false if one of the above are not found. +For ossim, typically geos will be system installed which should be found; +or found in the ossim 3rd party dependencies directory from a geos build +and install. If the latter it will rely on CMAKE_INCLUDE_PATH and +CMAKE_LIBRARY_PATH having the path to the party dependencies directory. + +NOTE: +This script is specialized for ossim, e.g. looking in /usr/local/ossim. + +$Id$ +--- + +--- +Find include path: +Note: Ubuntu 14.04+ did not have geos.h (not included in any ossim src). +Instead looking for Geometry.h +--- +#]] + +find_path(GEOS_INCLUDE_DIR geos_c.h) + +# Find GEOS C library: +find_library(GEOS_C_LIBRARY_RELEASE NAMES geos_c) +find_library(GEOS_C_LIBRARY_DEBUG NAMES geos_cd) +set(GEOS_FOUND FALSE) + +set(GEOS_C_LIBRARY) +if(GEOS_C_LIBRARY_DEBUG) + set(GEOS_C_LIBRARY ${GEOS_C_LIBRARY_DEBUG}) +elseif(GEOS_C_LIBRARY_RELEASE) + set(GEOS_C_LIBRARY ${GEOS_C_LIBRARY_RELEASE}) +endif() + +mark_as_advanced(GEOS_INCLUDE_DIR GEOS_C_LIBRARY GEOS_C_LIBRARY_RELEASE + GEOS_C_LIBRARY_DEBUG) + +# --- This function sets GEOS_FOUND if variables are valid. --- +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(GEOS DEFAULT_MSG GEOS_C_LIBRARY + GEOS_INCLUDE_DIR) diff --git a/cmake/find_scripts/FindIconv.cmake b/cmake/find_scripts/FindIconv.cmake new file mode 100644 index 00000000000..fe9089df133 --- /dev/null +++ b/cmake/find_scripts/FindIconv.cmake @@ -0,0 +1,58 @@ +#[[ +- Try to find Iconv +Once done this will define + +ICONV_FOUND - system has Iconv +ICONV_INCLUDE_DIR - the Iconv include directory +ICONV_LIBRARIES - Link these to use Iconv +ICONV_SECOND_ARGUMENT_IS_CONST - the second argument for iconv() is const +#]] + +include(CheckCXXSourceCompiles) + +if(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) + # Already in cache, be silent + set(ICONV_FIND_QUIETLY TRUE) +endif(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) + +find_path(ICONV_INCLUDE_DIR iconv.h) + +find_library(ICONV_LIBRARIES NAMES iconv libiconv libiconv-2 c) + +if(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) + set(ICONV_FOUND TRUE) +endif(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES) + +set(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR}) +set(CMAKE_REQUIRED_LIBRARIES ${ICONV_LIBRARIES}) +if(ICONV_FOUND) + check_cxx_source_compiles( + " + #include + int main(){ + iconv_t conv = 0; + const char* in = 0; + size_t ilen = 0; + char* out = 0; + size_t olen = 0; + iconv(conv, &in, &ilen, &out, &olen); + return 0; + } +" + ICONV_SECOND_ARGUMENT_IS_CONST) +endif(ICONV_FOUND) +set(CMAKE_REQUIRED_INCLUDES) +set(CMAKE_REQUIRED_LIBRARIES) + +if(ICONV_FOUND) + if(NOT ICONV_FIND_QUIETLY) + message(STATUS "Found Iconv: ${ICONV_LIBRARIES}") + endif(NOT ICONV_FIND_QUIETLY) +else(ICONV_FOUND) + if(Iconv_FIND_REQUIRED) + message(FATAL_ERROR "Could not find Iconv") + endif(Iconv_FIND_REQUIRED) +endif(ICONV_FOUND) + +mark_as_advanced(ICONV_INCLUDE_DIR ICONV_LIBRARIES + ICONV_SECOND_ARGUMENT_IS_CONST) diff --git a/cmake/find_scripts/FindLAPACK.cmake b/cmake/find_scripts/FindLAPACK.cmake new file mode 100644 index 00000000000..8c2094b8edf --- /dev/null +++ b/cmake/find_scripts/FindLAPACK.cmake @@ -0,0 +1,817 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindLAPACK +---------- + +Find Linear Algebra PACKage (LAPACK) library + +This module finds an installed Fortran library that implements the +`LAPACK linear-algebra interface`_. + +At least one of the ``C``, ``CXX``, or ``Fortran`` languages must be enabled. + +.. _`LAPACK linear-algebra interface`: https://netlib.org/lapack/ + +Input Variables +^^^^^^^^^^^^^^^ + +The following variables may be set to influence this module's behavior: + +``BLA_STATIC`` + if ``ON`` use static linkage + +``BLA_VENDOR`` + Set to one of the :ref:`BLAS/LAPACK Vendors` to search for BLAS only + from the specified vendor. If not set, all vendors are considered. + +``BLA_F95`` + if ``ON`` tries to find the BLAS95/LAPACK95 interfaces + +``BLA_PREFER_PKGCONFIG`` + .. versionadded:: 3.20 + + if set ``pkg-config`` will be used to search for a LAPACK library first + and if one is found that is preferred + +``BLA_PKGCONFIG_LAPACK`` + .. versionadded:: 3.25 + + If set, the ``pkg-config`` method will look for this module name instead of + just ``lapack``. + + +``BLA_SIZEOF_INTEGER`` + .. versionadded:: 3.22 + + Specify the BLAS/LAPACK library integer size: + + ``4`` + Search for a BLAS/LAPACK with 32-bit integer interfaces. + ``8`` + Search for a BLAS/LAPACK with 64-bit integer interfaces. + ``ANY`` + Search for any BLAS/LAPACK. + Most likely, a BLAS/LAPACK with 32-bit integer interfaces will be found. + +Imported targets +^^^^^^^^^^^^^^^^ + +This module defines the following :prop_tgt:`IMPORTED` targets: + +``LAPACK::LAPACK`` + .. versionadded:: 3.18 + + The libraries to use for LAPACK, if found. + +Result Variables +^^^^^^^^^^^^^^^^ + +This module defines the following variables: + +``LAPACK_FOUND`` + library implementing the LAPACK interface is found +``LAPACK_LINKER_FLAGS`` + uncached list of required linker flags (excluding ``-l`` and ``-L``). +``LAPACK_LIBRARIES`` + uncached list of libraries (using full path name) to link against + to use LAPACK +``LAPACK95_LIBRARIES`` + uncached list of libraries (using full path name) to link against + to use LAPACK95 +``LAPACK95_FOUND`` + library implementing the LAPACK95 interface is found + +Intel MKL +^^^^^^^^^ + +To use the Intel MKL implementation of LAPACK, a project must enable at least +one of the ``C`` or ``CXX`` languages. Set ``BLA_VENDOR`` to an Intel MKL +variant either on the command-line as ``-DBLA_VENDOR=Intel10_64lp`` or in +project code: + +.. code-block:: cmake + + set(BLA_VENDOR Intel10_64lp) + find_package(LAPACK) + +In order to build a project using Intel MKL, and end user must first +establish an Intel MKL environment. See the :module:`FindBLAS` module +section on :ref:`Intel MKL` for details. + +#]=======================================================================] + +# The approach follows that of the ``autoconf`` macro file, ``acx_lapack.m4`` +# (distributed at http://ac-archive.sourceforge.net/ac-archive/acx_lapack.html). + +if(CMAKE_Fortran_COMPILER_LOADED) + include(CheckFortranFunctionExists) +else() + include(CheckFunctionExists) +endif() +include(FindPackageHandleStandardArgs) + +function(_add_lapack_target) + if(LAPACK_FOUND AND NOT TARGET LAPACK::LAPACK) + add_library(LAPACK::LAPACK INTERFACE IMPORTED) + + # Filter out redundant BLAS info and replace with the BLAS target + set(_lapack_libs "${LAPACK_LIBRARIES}") + set(_lapack_flags "${LAPACK_LINKER_FLAGS}") + if(TARGET BLAS::BLAS) + if(_lapack_libs AND BLAS_LIBRARIES) + foreach(_blas_lib IN LISTS BLAS_LIBRARIES) + list(REMOVE_ITEM _lapack_libs "${_blas_lib}") + endforeach() + endif() + if(_lapack_flags AND BLAS_LINKER_FLAGS) + foreach(_blas_flag IN LISTS BLAS_LINKER_FLAGS) + list(REMOVE_ITEM _lapack_flags "${_blas_flag}") + endforeach() + endif() + list(APPEND _lapack_libs BLAS::BLAS) + endif() + if(_lapack_libs) + set_target_properties(LAPACK::LAPACK PROPERTIES + INTERFACE_LINK_LIBRARIES "${_lapack_libs}" + ) + endif() + if(_lapack_flags) + set_target_properties(LAPACK::LAPACK PROPERTIES + INTERFACE_LINK_OPTIONS "${_lapack_flags}" + ) + endif() + endif() +endfunction() + +# TODO: move this stuff to a separate module + +function(CHECK_LAPACK_LIBRARIES LIBRARIES _prefix _name _flags _list _deps _addlibdir _subdirs _blas) + # This function checks for the existence of the combination of libraries + # given by _list. If the combination is found, this checks whether can link + # against that library combination using the name of a routine given by _name + # using the linker flags given by _flags. If the combination of libraries is + # found and passes the link test, ${LIBRARIES} is set to the list of complete + # library paths that have been found. Otherwise, ${LIBRARIES} is set to FALSE. + + set(_libraries_work TRUE) + set(_libraries) + set(_combined_name) + + if(BLA_STATIC) + if(WIN32) + set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES}) + else() + set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) + endif() + else() + if(CMAKE_SYSTEM_NAME STREQUAL "Linux") + # for ubuntu's libblas3gf and liblapack3gf packages + set(CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES} .so.3gf) + endif() + endif() + + set(_extaddlibdir "${_addlibdir}") + if(WIN32) + list(APPEND _extaddlibdir ENV LIB) + elseif(APPLE) + list(APPEND _extaddlibdir ENV DYLD_LIBRARY_PATH) + else() + list(APPEND _extaddlibdir ENV LD_LIBRARY_PATH) + endif() + list(APPEND _extaddlibdir "${CMAKE_C_IMPLICIT_LINK_DIRECTORIES}") + + foreach(_library ${_list}) + if(_library MATCHES "^-") + # Respect linker flags as-is (required by MKL) + list(APPEND _libraries "${_library}") + else() + string(REGEX REPLACE "[^A-Za-z0-9]" "_" _lib_var "${_library}") + string(APPEND _combined_name "_${_lib_var}") + if(NOT "${_deps}" STREQUAL "") + string(APPEND _combined_name "_deps") + endif() + if(_libraries_work) + find_library(${_prefix}_${_lib_var}_LIBRARY + NAMES ${_library} + NAMES_PER_DIR + PATHS ${_extaddlibdir} + PATH_SUFFIXES ${_subdirs} + ) + mark_as_advanced(${_prefix}_${_lib_var}_LIBRARY) + list(APPEND _libraries ${${_prefix}_${_lib_var}_LIBRARY}) + set(_libraries_work ${${_prefix}_${_lib_var}_LIBRARY}) + endif() + endif() + endforeach() + + foreach(_flag ${_flags}) + string(REGEX REPLACE "[^A-Za-z0-9]" "_" _flag_var "${_flag}") + string(APPEND _combined_name "_${_flag_var}") + endforeach() + if(_libraries_work) + # Test this combination of libraries. + set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${_libraries} ${_blas} ${_deps}) + set(CMAKE_REQUIRED_QUIET ${LAPACK_FIND_QUIETLY}) + if(CMAKE_Fortran_COMPILER_LOADED) + check_fortran_function_exists("${_name}" ${_prefix}${_combined_name}_WORKS) + else() + check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS) + endif() + set(CMAKE_REQUIRED_LIBRARIES) + set(_libraries_work ${${_prefix}${_combined_name}_WORKS}) + endif() + + if(_libraries_work) + if("${_list}${_blas}" STREQUAL "") + set(_libraries "${LIBRARIES}-PLACEHOLDER-FOR-EMPTY-LIBRARIES") + else() + list(APPEND _libraries ${_blas} ${_deps}) + endif() + else() + set(_libraries FALSE) + endif() + set(${LIBRARIES} "${_libraries}" PARENT_SCOPE) +endfunction() + +macro(_lapack_find_dependency dep) + set(_lapack_quiet_arg) + if(LAPACK_FIND_QUIETLY) + set(_lapack_quiet_arg QUIET) + endif() + set(_lapack_required_arg) + if(LAPACK_FIND_REQUIRED) + set(_lapack_required_arg REQUIRED) + endif() + find_package(${dep} ${ARGN} + ${_lapack_quiet_arg} + ${_lapack_required_arg} + ) + if (NOT ${dep}_FOUND) + set(LAPACK_NOT_FOUND_MESSAGE "LAPACK could not be found because dependency ${dep} could not be found.") + endif() + + set(_lapack_required_arg) + set(_lapack_quiet_arg) +endmacro() + +set(LAPACK_LINKER_FLAGS) +set(LAPACK_LIBRARIES) +set(LAPACK95_LIBRARIES) +set(_lapack_fphsa_req_var LAPACK_LIBRARIES) + +# Check the language being used +if(NOT (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED OR CMAKE_Fortran_COMPILER_LOADED)) + set(LAPACK_NOT_FOUND_MESSAGE + "FindLAPACK requires Fortran, C, or C++ to be enabled.") +endif() + +if(NOT BLA_SIZEOF_INTEGER) + # in the reality we do not know which API of BLAS/LAPACK is masked in library + set(_lapack_sizeof_integer "ANY") +elseif((BLA_SIZEOF_INTEGER STREQUAL "ANY") OR + (BLA_SIZEOF_INTEGER STREQUAL "4") OR + (BLA_SIZEOF_INTEGER STREQUAL "8")) + set(_lapack_sizeof_integer ${BLA_SIZEOF_INTEGER}) +else() + message(FATAL_ERROR "BLA_SIZEOF_INTEGER can have only , ANY, 4, or 8 values") +endif() + +# Load BLAS +if(NOT LAPACK_NOT_FOUND_MESSAGE) + _lapack_find_dependency(BLAS) +endif() + +# Search with pkg-config if specified +if(BLA_PREFER_PKGCONFIG) + if(NOT BLA_PKGCONFIG_LAPACK) + set(BLA_PKGCONFIG_LAPACK "lapack") + endif() + find_package(PkgConfig QUIET) + if(PKG_CONFIG_FOUND) + pkg_check_modules(PKGC_LAPACK QUIET ${BLA_PKGCONFIG_LAPACK}) + if(PKGC_LAPACK_FOUND) + set(LAPACK_FOUND TRUE) + set(LAPACK_LIBRARIES "${PKGC_LAPACK_LINK_LIBRARIES}") + set(LAPACK_INCLUDE_DIRS "${PKGC_LAPACK_INCLUDE_DIRS}") + if (BLAS_LIBRARIES) + list(APPEND LAPACK_LIBRARIES "${BLAS_LIBRARIES}") + list(APPEND LAPACK_INCLUDE_DIRS "${BLAS_INCLUDE_DIRS}") + endif() + _add_lapack_target() + return() + endif() + endif() +endif() + +# Search for different LAPACK distributions if BLAS is found +if(NOT LAPACK_NOT_FOUND_MESSAGE) + set(LAPACK_LINKER_FLAGS ${BLAS_LINKER_FLAGS}) + if(NOT BLA_VENDOR) + if(NOT "$ENV{BLA_VENDOR}" STREQUAL "") + set(BLA_VENDOR "$ENV{BLA_VENDOR}") + else() + set(BLA_VENDOR "All") + endif() + endif() + + # LAPACK in the Intel MKL 10+ library? + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR MATCHES "Intel" OR BLA_VENDOR STREQUAL "All") + AND (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED)) + # System-specific settings + if(NOT WIN32) + set(LAPACK_mkl_LM "-lm") + set(LAPACK_mkl_LDL "-ldl") + endif() + + _lapack_find_dependency(Threads) + + if(_lapack_sizeof_integer EQUAL 8) + set(LAPACK_mkl_ILP_MODE "ilp64") + elseif(_lapack_sizeof_integer EQUAL 4) + set(LAPACK_mkl_ILP_MODE "lp64") + else() + if(BLA_VENDOR MATCHES "_64ilp") + set(LAPACK_mkl_ILP_MODE "ilp64") + else() + set(LAPACK_mkl_ILP_MODE "lp64") + endif() + endif() + + set(LAPACK_SEARCH_LIBS "") + + if(BLA_F95) + set(LAPACK_mkl_SEARCH_SYMBOL "cheev_f95") + set(_LAPACK_LIBRARIES LAPACK95_LIBRARIES) + set(_BLAS_LIBRARIES ${BLAS95_LIBRARIES}) + + # old + list(APPEND LAPACK_SEARCH_LIBS + "mkl_lapack95") + # new >= 10.3 + list(APPEND LAPACK_SEARCH_LIBS + "mkl_intel_c") + list(APPEND LAPACK_SEARCH_LIBS + "mkl_lapack95_${LAPACK_mkl_ILP_MODE}") + else() + set(LAPACK_mkl_SEARCH_SYMBOL "cheev") + set(_LAPACK_LIBRARIES LAPACK_LIBRARIES) + set(_BLAS_LIBRARIES ${BLAS_LIBRARIES}) + + # old and new >= 10.3 + list(APPEND LAPACK_SEARCH_LIBS + "mkl_lapack") + endif() + + # MKL uses a multitude of partially platform-specific subdirectories: + if(BLA_VENDOR STREQUAL "Intel10_32") + set(LAPACK_mkl_ARCH_NAME "ia32") + else() + set(LAPACK_mkl_ARCH_NAME "intel64") + endif() + if(WIN32) + set(LAPACK_mkl_OS_NAME "win") + elseif(APPLE) + set(LAPACK_mkl_OS_NAME "mac") + else() + set(LAPACK_mkl_OS_NAME "lin") + endif() + if(DEFINED ENV{MKLROOT}) + file(TO_CMAKE_PATH "$ENV{MKLROOT}" LAPACK_mkl_MKLROOT) + # If MKLROOT points to the subdirectory 'mkl', use the parent directory instead + # so we can better detect other relevant libraries in 'compiler' or 'tbb': + get_filename_component(LAPACK_mkl_MKLROOT_LAST_DIR "${LAPACK_mkl_MKLROOT}" NAME) + if(LAPACK_mkl_MKLROOT_LAST_DIR STREQUAL "mkl") + get_filename_component(LAPACK_mkl_MKLROOT "${LAPACK_mkl_MKLROOT}" DIRECTORY) + endif() + endif() + set(LAPACK_mkl_LIB_PATH_SUFFIXES + "compiler/lib" "compiler/lib/${LAPACK_mkl_ARCH_NAME}_${LAPACK_mkl_OS_NAME}" + "compiler/lib/${LAPACK_mkl_ARCH_NAME}" + "mkl/lib" "mkl/lib/${LAPACK_mkl_ARCH_NAME}_${LAPACK_mkl_OS_NAME}" + "mkl/lib/${LAPACK_mkl_ARCH_NAME}" + "lib" "lib/${LAPACK_mkl_ARCH_NAME}_${LAPACK_mkl_OS_NAME}" + "lib/${LAPACK_mkl_ARCH_NAME}" + ) + + # First try empty lapack libs (implicitly linked or automatic from BLAS) + if(NOT ${_LAPACK_LIBRARIES}) + check_lapack_libraries( + ${_LAPACK_LIBRARIES} + LAPACK + ${LAPACK_mkl_SEARCH_SYMBOL} + "" + "" + "${CMAKE_THREAD_LIBS_INIT};${LAPACK_mkl_LM};${LAPACK_mkl_LDL}" + "${LAPACK_mkl_MKLROOT}" + "${LAPACK_mkl_LIB_PATH_SUFFIXES}" + "${_BLAS_LIBRARIES}" + ) + if(LAPACK_WORKS AND NOT _BLAS_LIBRARIES) + # Give a more helpful "found" message + set(LAPACK_WORKS "implicitly linked") + set(_lapack_fphsa_req_var LAPACK_WORKS) + endif() + endif() + + # Then try the search libs + foreach(_search ${LAPACK_SEARCH_LIBS}) + string(REPLACE " " ";" _search ${_search}) + if(NOT ${_LAPACK_LIBRARIES}) + check_lapack_libraries( + ${_LAPACK_LIBRARIES} + LAPACK + ${LAPACK_mkl_SEARCH_SYMBOL} + "" + "${_search}" + "${CMAKE_THREAD_LIBS_INIT};${LAPACK_mkl_LM};${LAPACK_mkl_LDL}" + "${LAPACK_mkl_MKLROOT}" + "${LAPACK_mkl_LIB_PATH_SUFFIXES}" + "${_BLAS_LIBRARIES}" + ) + endif() + endforeach() + + unset(_search) + unset(LAPACK_mkl_ILP_MODE) + unset(LAPACK_mkl_SEARCH_SYMBOL) + unset(LAPACK_mkl_LM) + unset(LAPACK_mkl_LDL) + unset(LAPACK_mkl_MKLROOT) + unset(LAPACK_mkl_ARCH_NAME) + unset(LAPACK_mkl_OS_NAME) + unset(LAPACK_mkl_LIB_PATH_SUFFIXES) + endif() + + # gotoblas? (http://www.tacc.utexas.edu/tacc-projects/gotoblas2) + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR STREQUAL "Goto" OR BLA_VENDOR STREQUAL "All")) + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "goto2" + "" + "" + "" + "${BLAS_LIBRARIES}" + ) + endif() + + # FlexiBLAS? (http://www.mpi-magdeburg.mpg.de/mpcsc/software/FlexiBLAS/) + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR STREQUAL "FlexiBLAS" OR BLA_VENDOR STREQUAL "All")) + set(_lapack_flexiblas_lib "flexiblas") + + if(_lapack_sizeof_integer EQUAL 8) + string(APPEND _lapack_flexiblas_lib "64") + endif() + + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "${_lapack_flexiblas_lib}" + "" + "" + "" + "${BLAS_LIBRARIES}" + ) + + unset(_lapack_flexiblas_lib) + endif() + + # OpenBLAS? (http://www.openblas.net) + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR STREQUAL "OpenBLAS" OR BLA_VENDOR STREQUAL "All")) + set(_lapack_openblas_lib "openblas") + + if(_lapack_sizeof_integer EQUAL 8) + if(MINGW) + string(APPEND _lapack_openblas_lib "_64") + else() + string(APPEND _lapack_openblas_lib "64") + endif() + endif() + + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "${_lapack_openblas_lib}" + "" + "" + "" + "${BLAS_LIBRARIES}" + ) + + unset(_lapack_openblas_lib) + endif() + + # ArmPL? (https://developer.arm.com/tools-and-software/server-and-hpc/compile/arm-compiler-for-linux/arm-performance-libraries) + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR MATCHES "Arm" OR BLA_VENDOR STREQUAL "All")) + # Check for 64bit Integer support + if(_lapack_sizeof_integer EQUAL 8) + set(LAPACK_armpl_LIB "armpl_ilp64") + elseif(_lapack_sizeof_integer EQUAL 4) + set(LAPACK_armpl_LIB "armpl_lp64") + else() + if(BLA_VENDOR MATCHES "_ilp64") + set(LAPACK_armpl_LIB "armpl_ilp64") + else() + set(LAPACK_armpl_LIB "armpl_lp64") + endif() + endif() + + # Check for OpenMP support, VIA BLA_VENDOR of Arm_mp or Arm_ipl64_mp + if(BLA_VENDOR MATCHES "_mp") + string(APPEND LAPACK_armpl_LIB "_mp") + endif() + + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "${LAPACK_armpl_LIB}" + "" + "" + "" + "${BLAS_LIBRARIES}" + ) + endif() + + # FLAME's blis library? (https://github.com/flame/blis) + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR STREQUAL "FLAME" OR BLA_VENDOR STREQUAL "All")) + if(_lapack_sizeof_integer EQUAL 8) + if(BLA_VENDOR STREQUAL "FLAME") + message(FATAL_ERROR "libFLAME does not support Int64 type") + endif() + else() + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "flame" + "" + "" + "" + "${BLAS_LIBRARIES}" + ) + endif() + endif() + + # AOCL? (https://developer.amd.com/amd-aocl/) + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR MATCHES "AOCL" OR BLA_VENDOR STREQUAL "All")) + if(_lapack_sizeof_integer EQUAL 8) + set(_lapack_aocl_subdir "ILP64") + else() + set(_lapack_aocl_subdir "LP64") + endif() + + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "flame" + "-fopenmp" + "" + "${_lapack_aocl_subdir}" + "${BLAS_LIBRARIES}" + ) + unset(_lapack_aocl_subdir) + endif() + + # LAPACK in SCSL library? (SGI/Cray Scientific Library) + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR MATCHES "SCSL" OR BLA_VENDOR STREQUAL "All")) + set(_lapack_scsl_lib "scs") + + if(_lapack_sizeof_integer EQUAL 8) + string(APPEND _lapack_scsl_lib "_i8") + endif() + # Check for OpenMP support, VIA BLA_VENDOR of scs_mp + if(BLA_VENDOR MATCHES "_mp") + string(APPEND _lapack_scsl_lib "_mp") + endif() + + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "${_lapack_scsl_lib}" + "" + "" + "" + "${BLAS_LIBRARIES}" + ) + unset(_lapack_scsl_lib) + endif() + + # BLAS in acml library? + if(BLA_VENDOR MATCHES "ACML" OR BLA_VENDOR STREQUAL "All") + if(BLAS_LIBRARIES MATCHES ".+acml.+") + set(LAPACK_LIBRARIES ${BLAS_LIBRARIES}) + endif() + endif() + + # Apple LAPACK library? + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR STREQUAL "Apple" OR BLA_VENDOR STREQUAL "All")) + if(_lapack_sizeof_integer EQUAL 8) + if(BLA_VENDOR STREQUAL "Apple") + message(FATAL_ERROR "Accelerate Framework does not support Int64 type") + endif() + else() + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "Accelerate" + "" + "" + "" + "${BLAS_LIBRARIES}" + ) + endif() + endif() + + # Apple NAS (vecLib) library? + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR STREQUAL "NAS" OR BLA_VENDOR STREQUAL "All")) + if(_lapack_sizeof_integer EQUAL 8) + if(BLA_VENDOR STREQUAL "NAS") + message(FATAL_ERROR "Accelerate Framework does not support Int64 type") + endif() + else() + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "vecLib" + "" + "" + "" + "${BLAS_LIBRARIES}" + ) + endif() + endif() + + # Elbrus Math Library? + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR MATCHES "EML" OR BLA_VENDOR STREQUAL "All")) + if(BLAS_LIBRARIES MATCHES "eml.+") + set(LAPACK_LIBRARIES ${BLAS_LIBRARIES}) + endif() + endif() + + # Fujitsu SSL2 Library? + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR MATCHES "Fujitsu_SSL2" OR BLA_VENDOR STREQUAL "All")) + if(BLAS_LIBRARIES MATCHES "fjlapack.+") + set(LAPACK_LIBRARIES ${BLAS_LIBRARIES}) + set(LAPACK_LINKER_FLAGS ${BLAS_LINKER_FLAGS}) + endif() + endif() + + # LAPACK in IBM ESSL library? + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR MATCHES "IBMESSL" OR BLA_VENDOR STREQUAL "All")) + if(BLAS_LIBRARIES MATCHES "essl.+") + set(LAPACK_LIBRARIES ${BLAS_LIBRARIES}) + endif() + endif() + + # NVHPC Library? + + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR MATCHES "NVHPC" OR BLA_VENDOR STREQUAL "All")) + set(_lapack_nvhpc_lib "lapack") + + if(_lapack_sizeof_integer EQUAL 8) + string(APPEND _lapack_nvhpc_lib "_ilp64") + elseif(_lapack_sizeof_integer EQUAL 4) + string(APPEND _lapack_nvhpc_lib "_lp64") + endif() + set(_lapack_nvhpc_flags) + if(";${CMAKE_C_COMPILER_ID};${CMAKE_CXX_COMPILER_ID};${CMAKE_Fortran_COMPILER_ID};" MATCHES ";(NVHPC|PGI);") + set(_lapack_nvhpc_flags "-fortranlibs") + endif() + + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "${_lapack_nvhpc_lib}" + "${_lapack_nvhpc_flags}" + "" + "" + "${BLAS_LIBRARIES}" + ) + + # an additional check for NVHPC 2020 + # which does not have differentiation + # between lp64 and ilp64 modes + if(NOT LAPACK_LIBRARIES AND NOT _lapack_sizeof_integer EQUAL 8) + set(_lapack_nvhpc_lib "lapack") + + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "${_lapack_nvhpc_lib}" + "${_lapack_nvhpc_flags}" + "" + "" + "${BLAS_LIBRARIES}" + ) + endif() + + unset(_lapack_nvhpc_lib) + unset(_lapack_nvhpc_flags) + endif() + + # libblastrampoline? (https://github.com/JuliaLinearAlgebra/libblastrampoline/tree/main) + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR STREQUAL "libblastrampoline" OR BLA_VENDOR STREQUAL "All")) + if(BLAS_LIBRARIES MATCHES "blastrampoline.+") + set(LAPACK_LIBRARIES ${BLAS_LIBRARIES}) + endif() + endif() + + # Generic LAPACK library? + if(NOT LAPACK_LIBRARIES + AND (BLA_VENDOR STREQUAL "Generic" + OR BLA_VENDOR STREQUAL "ATLAS" + OR BLA_VENDOR STREQUAL "All")) + set(_lapack_generic_lib "lapack") + if(BLA_STATIC) + # We do not know for sure how the LAPACK reference implementation + # is built on this host. Guess typical dependencies. + set(_lapack_generic_deps "-lgfortran;-lm") + else() + set(_lapack_generic_deps "") + endif() + + if(_lapack_sizeof_integer EQUAL 8) + string(APPEND _lapack_generic_lib "64") + endif() + + check_lapack_libraries( + LAPACK_LIBRARIES + LAPACK + cheev + "" + "${_lapack_generic_lib}" + "${_lapack_generic_deps}" + "" + "" + "${BLAS_LIBRARIES}" + ) + + unset(_lapack_generic_deps) + unset(_lapack_generic_lib) + endif() +endif() + +if(BLA_F95) + set(LAPACK_LIBRARIES "${LAPACK95_LIBRARIES}") +endif() + +if(LAPACK_NOT_FOUND_MESSAGE) + set(LAPACK_NOT_FOUND_MESSAGE + REASON_FAILURE_MESSAGE ${LAPACK_NOT_FOUND_MESSAGE}) +endif() +find_package_handle_standard_args(LAPACK REQUIRED_VARS ${_lapack_fphsa_req_var} + ${LAPACK_NOT_FOUND_MESSAGE}) +unset(LAPACK_NOT_FOUND_MESSAGE) + +if(BLA_F95) + set(LAPACK95_FOUND ${LAPACK_FOUND}) +endif() + +# On compilers that implicitly link LAPACK (such as ftn, cc, and CC on Cray HPC machines) +# we used a placeholder for empty LAPACK_LIBRARIES to get through our logic above. +if(LAPACK_LIBRARIES STREQUAL "LAPACK_LIBRARIES-PLACEHOLDER-FOR-EMPTY-LIBRARIES") + set(LAPACK_LIBRARIES "") +endif() + +_add_lapack_target() +unset(_lapack_fphsa_req_var) +unset(_lapack_sizeof_integer) +unset(_LAPACK_LIBRARIES) diff --git a/cmake/find_scripts/FindLibLAS.cmake b/cmake/find_scripts/FindLibLAS.cmake new file mode 100644 index 00000000000..c3c5b07c242 --- /dev/null +++ b/cmake/find_scripts/FindLibLAS.cmake @@ -0,0 +1,40 @@ +find_path( + LibLAS_INCLUDE_DIR + NAMES liblas.h + PATH_SUFFIXES capi + PATH_SUFFIXES liblas/capi + DOC "path to liblas.h") + +find_library( + LibLAS_C_LIBRARY + NAMES liblas_c las_c las + # Help the user find it if we cannot. + DOC "path liblas_c library") + +if(LibLAS_INCLUDE_DIR) + unset(las_version_CONTENTS) + file(READ "${LibLAS_INCLUDE_DIR}/las_version.h" las_version_CONTENTS) + + string(REGEX MATCH "#define +LIBLAS_VERSION_MAJOR +([0-9]+)" _dummy + "${las_version_CONTENTS}") + set(LibLAS_VERSION_MAJOR "${CMAKE_MATCH_1}") + string(REGEX MATCH "#define +LIBLAS_VERSION_MINOR +([0-9])" _dummy + "${las_version_CONTENTS}") + set(LibLAS_VERSION_MINOR "${CMAKE_MATCH_1}") + string(REGEX MATCH "#define +LIBLAS_VERSION_REV +([0-9])" _dummy + "${las_version_CONTENTS}") + set(LIBLAS_VERSION_REV "${CMAKE_MATCH_1}") + + set(LibLAS_VERSION_STRING + "${LibLAS_VERSION_MAJOR}.${LibLAS_VERSION_MINOR}.${LIBLAS_VERSION_REV}") +endif() +# message(FATAL_ERROR "LibLAS_LIBRARY=${LibLAS_LIBRARY}") +if(LibLAS_INCLUDE_DIR AND LibLAS_C_LIBRARY) + set(LibLAS_FOUND TRUE) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args( + LibLAS + REQUIRED_VARS LibLAS_C_LIBRARY LibLAS_INCLUDE_DIR + VERSION_VAR LibLAS_VERSION_STRING) diff --git a/cmake/find_scripts/FindMySQL.cmake b/cmake/find_scripts/FindMySQL.cmake new file mode 100644 index 00000000000..59f36a07726 --- /dev/null +++ b/cmake/find_scripts/FindMySQL.cmake @@ -0,0 +1,16 @@ +execute_process( + COMMAND mysql_config --cflags + OUTPUT_VARIABLE MySQL_INCLUDE_DIRS + OUTPUT_STRIP_TRAILING_WHITESPACE) +execute_process( + COMMAND mysql_config --libs + OUTPUT_VARIABLE MySQL_LIBRARY + OUTPUT_STRIP_TRAILING_WHITESPACE) + +if(MySQL_INCLUDE_DIRS AND MySQL_LIBRARY) + string(REGEX REPLACE "(^| +)-I" " " _dummy ${MySQL_INCLUDE_DIRS}) + string(STRIP ${_dummy} _dummy) + string(REPLACE " " ";" MySQL_INCLUDE_DIRS ${_dummy}) + message(STATUS "Found MySQL: ${MySQL_LIBRARY}") + set(MySQL_FOUND TRUE) +endif() diff --git a/cmake/find_scripts/FindNetCDF.cmake b/cmake/find_scripts/FindNetCDF.cmake new file mode 100644 index 00000000000..8939fb9b5bb --- /dev/null +++ b/cmake/find_scripts/FindNetCDF.cmake @@ -0,0 +1,17 @@ +find_path( + NetCDF_INCLUDE_DIR + NAMES netcdf.h + DOC "path to netcdf.h") + +find_library( + NetCDF_LIBRARY + NAMES netcdf + DOC "path netcdf library") + +if(NetCDF_INCLUDE_DIR AND NetCDF_LIBRARY) + set(NetCDF_FOUND TRUE) +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(NetCDF REQUIRED_VARS NetCDF_LIBRARY + NetCDF_INCLUDE_DIR) diff --git a/cmake/find_scripts/FindPCRE.cmake b/cmake/find_scripts/FindPCRE.cmake new file mode 100644 index 00000000000..002f7af4a6d --- /dev/null +++ b/cmake/find_scripts/FindPCRE.cmake @@ -0,0 +1,27 @@ +find_path(PCRE_INCLUDE_DIR NAMES pcre.h) + +find_library(PCRE_LIBRARY_RELEASE NAMES pcre) +find_library(PCRE_LIBRARY_DEBUG NAMES pcred) +if(PCRE_LIBRARY_DEBUG) + set(PCRE_LIBRARY ${PCRE_LIBRARY_DEBUG}) +elseif(PCRE_LIBRARY_RELEASE) + set(PCRE_LIBRARY ${PCRE_LIBRARY_RELEASE}) +endif() + +set(PCRE_FOUND FALSE) +if(PCRE_INCLUDE_DIR AND PCRE_LIBRARY) + set(PCRE_FOUND TRUE) +endif() + +if(PCRE_FOUND) + set(PCRE_LIBRARIES ${PCRE_LIBRARY}) + set(PCRE_INCLUDE_DIRS ${PCRE_INCLUDE_DIR}) +endif() + +mark_as_advanced(PCRE_LIBRARY) +mark_as_advanced(PCRE_LIBRARY_DEBUG) +mark_as_advanced(PCRE_LIBRARY_RELEASE) +mark_as_advanced(PCRE_INCLUDE_DIR) +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(PCRE DEFAULT_MSG PCRE_LIBRARY + PCRE_INCLUDE_DIR) diff --git a/cmake/find_scripts/FindPROJ.cmake b/cmake/find_scripts/FindPROJ.cmake new file mode 100644 index 00000000000..58920eed7a9 --- /dev/null +++ b/cmake/find_scripts/FindPROJ.cmake @@ -0,0 +1,118 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file COPYING-CMAKE-SCRIPTS or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindPROJ +--------- + +CMake module to search for PROJ(PROJ.4 and PROJ) library + +On success, the macro sets the following variables: +``PROJ_FOUND`` + if the library found + +``PROJ_LIBRARIES`` + full path to the library + +``PROJ_INCLUDE_DIRS`` + where to find the library headers + +``PROJ_VERSION_STRING`` + version string of PROJ + +Copyright (c) 2009 Mateusz Loskot +Copyright (c) 2015 NextGIS +Copyright (c) 2018 Hiroshi Miura + +#]=======================================================================] + +find_path( + PROJ_INCLUDE_DIR proj.h + PATHS ${PROJ_ROOT}/include + DOC "Path to PROJ library include directory") + +set(PROJ_NAMES ${PROJ_NAMES} proj proj_i) +set(PROJ_NAMES_DEBUG ${PROJ_NAMES_DEBUG} projd proj_d) + +if(NOT PROJ_LIBRARY) + find_library(PROJ_LIBRARY_RELEASE NAMES ${PROJ_NAMES}) + find_library(PROJ_LIBRARY_DEBUG NAMES ${PROJ_NAMES_DEBUG}) + include(SelectLibraryConfigurations) + select_library_configurations(PROJ) + mark_as_advanced(PROJ_LIBRARY_RELEASE PROJ_LIBRARY_DEBUG) +endif() + +unset(PROJ_NAMES) +unset(PROJ_NAMES_DEBUG) + +if(PROJ_INCLUDE_DIR) + file(READ "${PROJ_INCLUDE_DIR}/proj.h" PROJ_H_CONTENTS) + string(REGEX REPLACE "^.*PROJ_VERSION_MAJOR +([0-9]+).*$" "\\1" + PROJ_VERSION_MAJOR "${PROJ_H_CONTENTS}") + string(REGEX REPLACE "^.*PROJ_VERSION_MINOR +([0-9]+).*$" "\\1" + PROJ_VERSION_MINOR "${PROJ_H_CONTENTS}") + string(REGEX REPLACE "^.*PROJ_VERSION_PATCH +([0-9]+).*$" "\\1" + PROJ_VERSION_PATCH "${PROJ_H_CONTENTS}") + unset(PROJ_H_CONTENTS) + set(PROJ_VERSION_STRING + "${PROJ_VERSION_MAJOR}.${PROJ_VERSION_MINOR}.${PROJ_VERSION_PATCH}") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args( + PROJ + REQUIRED_VARS PROJ_LIBRARY PROJ_INCLUDE_DIR + VERSION_VAR PROJ_VERSION_STRING) +mark_as_advanced(PROJ_INCLUDE_DIR PROJ_LIBRARY) + +if(PROJ_FOUND) + set(PROJ_LIBRARIES "${PROJ_LIBRARY}") + set(PROJ_INCLUDE_DIRS "${PROJ_INCLUDE_DIR}") + if(NOT TARGET PROJ::proj) + add_library(PROJ::proj UNKNOWN IMPORTED) + set_target_properties( + PROJ::proj PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${PROJ_INCLUDE_DIR}" + IMPORTED_LINK_INTERFACE_LANGUAGES "C") + if(EXISTS "${PROJ_LIBRARY}") + set_target_properties( + PROJ::proj PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION "${PROJ_LIBRARY}") + endif() + if(EXISTS "${PROJ_LIBRARY_RELEASE}") + set_property( + TARGET PROJ::proj + APPEND + PROPERTY IMPORTED_CONFIGURATIONS RELEASE) + set_target_properties( + PROJ::proj + PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C" + IMPORTED_LOCATION_RELEASE "${PROJ_LIBRARY_RELEASE}") + endif() + if(EXISTS "${PROJ_LIBRARY_DEBUG}") + set_property( + TARGET PROJ::proj + APPEND + PROPERTY IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties( + PROJ::proj PROPERTIES IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "C" + IMPORTED_LOCATION_DEBUG "${PROJ_LIBRARY_DEBUG}") + endif() + endif() +endif() + +# ~~~ +# find_path(PROJ_INCLUDE_DIR proj.h PATH_SUFFIXES proj) +# +# find_library(PROJ_LIBRARY_RELEASE NAMES proj_i proj) +# find_library(PROJ_LIBRARY_DEBUG NAMES projd) set(PROJ_FOUND FALSE) +# +# set(PROJ_LIBRARY) if(PROJ_LIBRARY_DEBUG) set( PROJ_LIBRARY +# ${PROJ_LIBRARY_DEBUG} CACHE FILEPATH "doc" ) elseif(PROJ_LIBRARY_RELEASE) set( +# PROJ_LIBRARY ${PROJ_LIBRARY_RELEASE} CACHE FILEPATH "doc" ) endif() +# +# mark_as_advanced(PROJ_LIBRARY_RELEASE) mark_as_advanced(PROJ_LIBRARY_DEBUG) +# mark_as_advanced(PROJ_LIBRARY) mark_as_advanced(PROJ_INCLUDE_DIR) +# +# include(FindPackageHandleStandardArgs) find_package_handle_standard_args( PROJ +# DEFAULT_MSG PROJ_LIBRARY PROJ_INCLUDE_DIR ) +# ~~~ diff --git a/cmake/find_scripts/FindPostgreSQL.cmake b/cmake/find_scripts/FindPostgreSQL.cmake new file mode 100644 index 00000000000..b2260d7b853 --- /dev/null +++ b/cmake/find_scripts/FindPostgreSQL.cmake @@ -0,0 +1,312 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindPostgreSQL +-------------- + +Find the PostgreSQL installation. + +IMPORTED Targets +^^^^^^^^^^^^^^^^ + +.. versionadded:: 3.14 + +This module defines :prop_tgt:`IMPORTED` target ``PostgreSQL::PostgreSQL`` +if PostgreSQL has been found. + +Result Variables +^^^^^^^^^^^^^^^^ + +This module will set the following variables in your project: + +``PostgreSQL_FOUND`` + True if PostgreSQL is found. +``PostgreSQL_LIBRARIES`` + the PostgreSQL libraries needed for linking +``PostgreSQL_INCLUDE_DIRS`` + the directories of the PostgreSQL headers +``PostgreSQL_LIBRARY_DIRS`` + the link directories for PostgreSQL libraries +``PostgreSQL_VERSION_STRING`` + the version of PostgreSQL found +``PostgreSQL_TYPE_INCLUDE_DIR`` + the directories of the PostgreSQL server headers + +Components +^^^^^^^^^^ + +This module contains additional ``Server`` component, that forcibly checks +for the presence of server headers. Note that ``PostgreSQL_TYPE_INCLUDE_DIR`` +is set regardless of the presence of the ``Server`` component in find_package call. + +#]=======================================================================] + +# ---------------------------------------------------------------------------- +# History: +# This module is derived from the module originally found in the VTK source tree. +# +# ---------------------------------------------------------------------------- +# Note: +# PostgreSQL_ADDITIONAL_VERSIONS is a variable that can be used to set the +# version number of the implementation of PostgreSQL. +# In Windows the default installation of PostgreSQL uses that as part of the path. +# E.g C:\Program Files\PostgreSQL\8.4. +# Currently, the following version numbers are known to this module: +# "11" "10" "9.6" "9.5" "9.4" "9.3" "9.2" "9.1" "9.0" "8.4" "8.3" "8.2" "8.1" "8.0" +# +# To use this variable just do something like this: +# set(PostgreSQL_ADDITIONAL_VERSIONS "9.2" "8.4.4") +# before calling find_package(PostgreSQL) in your CMakeLists.txt file. +# This will mean that the versions you set here will be found first in the order +# specified before the default ones are searched. +# +# ---------------------------------------------------------------------------- +# You may need to manually set: +# PostgreSQL_INCLUDE_DIR - the path to where the PostgreSQL include files are. +# PostgreSQL_LIBRARY_DIR - The path to where the PostgreSQL library files are. +# If FindPostgreSQL.cmake cannot find the include files or the library files. +# +# ---------------------------------------------------------------------------- +# The following variables are set if PostgreSQL is found: +# PostgreSQL_FOUND - Set to true when PostgreSQL is found. +# PostgreSQL_INCLUDE_DIRS - Include directories for PostgreSQL +# PostgreSQL_LIBRARY_DIRS - Link directories for PostgreSQL libraries +# PostgreSQL_LIBRARIES - The PostgreSQL libraries. +# +# The ``PostgreSQL::PostgreSQL`` imported target is also created. +# +# ---------------------------------------------------------------------------- +# If you have installed PostgreSQL in a non-standard location. +# (Please note that in the following comments, it is assumed that +# points to the root directory of the include directory of PostgreSQL.) +# Then you have three options. +# 1) After CMake runs, set PostgreSQL_INCLUDE_DIR to /include and +# PostgreSQL_LIBRARY_DIR to wherever the library pq (or libpq in windows) is +# 2) Use CMAKE_INCLUDE_PATH to set a path to /PostgreSQL<-version>. This will allow find_path() +# to locate PostgreSQL_INCLUDE_DIR by utilizing the PATH_SUFFIXES option. e.g. In your CMakeLists.txt file +# set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "/include") +# 3) Set an environment variable called ${PostgreSQL_ROOT} that points to the root of where you have +# installed PostgreSQL, e.g. . +# +# ---------------------------------------------------------------------------- + +cmake_policy(PUSH) +cmake_policy(SET CMP0057 NEW) # if IN_LIST + +set(PostgreSQL_INCLUDE_PATH_DESCRIPTION "top-level directory containing the PostgreSQL include directories. E.g /usr/local/include/PostgreSQL/8.4 or C:/Program Files/PostgreSQL/8.4/include") +set(PostgreSQL_INCLUDE_DIR_MESSAGE "Set the PostgreSQL_INCLUDE_DIR cmake cache entry to the ${PostgreSQL_INCLUDE_PATH_DESCRIPTION}") +set(PostgreSQL_LIBRARY_PATH_DESCRIPTION "top-level directory containing the PostgreSQL libraries.") +set(PostgreSQL_LIBRARY_DIR_MESSAGE "Set the PostgreSQL_LIBRARY_DIR cmake cache entry to the ${PostgreSQL_LIBRARY_PATH_DESCRIPTION}") +set(PostgreSQL_ROOT_DIR_MESSAGE "Set the PostgreSQL_ROOT system variable to where PostgreSQL is found on the machine E.g C:/Program Files/PostgreSQL/8.4") + + +set(PostgreSQL_KNOWN_VERSIONS ${PostgreSQL_ADDITIONAL_VERSIONS} + "16" "15" "14" "13" "12" "11" "10" "9.6" "9.5" "9.4" "9.3" "9.2" "9.1" "9.0" "8.4" "8.3" "8.2" "8.1" "8.0") + +# Define additional search paths for root directories. +set( PostgreSQL_ROOT_DIRECTORIES + ENV PostgreSQL_ROOT + ${PostgreSQL_ROOT} +) +foreach(suffix ${PostgreSQL_KNOWN_VERSIONS}) + if(WIN32) + list(APPEND PostgreSQL_LIBRARY_ADDITIONAL_SEARCH_SUFFIXES + "PostgreSQL/${suffix}/lib") + list(APPEND PostgreSQL_INCLUDE_ADDITIONAL_SEARCH_SUFFIXES + "PostgreSQL/${suffix}/include") + list(APPEND PostgreSQL_TYPE_ADDITIONAL_SEARCH_SUFFIXES + "PostgreSQL/${suffix}/include/server") + endif() + if(UNIX) + list(APPEND PostgreSQL_LIBRARY_ADDITIONAL_SEARCH_SUFFIXES + "postgresql${suffix}" + "pgsql-${suffix}/lib") + list(APPEND PostgreSQL_INCLUDE_ADDITIONAL_SEARCH_SUFFIXES + "postgresql${suffix}" + "postgresql/${suffix}" + "pgsql-${suffix}/include") + list(APPEND PostgreSQL_TYPE_ADDITIONAL_SEARCH_SUFFIXES + "postgresql${suffix}/server" + "postgresql/${suffix}/server" + "pgsql-${suffix}/include/server") + endif() +endforeach() + +# +# Look for an installation. +# +find_path(PostgreSQL_INCLUDE_DIR + NAMES libpq-fe.h + PATHS + # Look in other places. + ${PostgreSQL_ROOT_DIRECTORIES} + PATH_SUFFIXES + pgsql + postgresql + include + ${PostgreSQL_INCLUDE_ADDITIONAL_SEARCH_SUFFIXES} + # Help the user find it if we cannot. + DOC "The ${PostgreSQL_INCLUDE_DIR_MESSAGE}" +) + +find_path(PostgreSQL_TYPE_INCLUDE_DIR + NAMES catalog/pg_type.h + PATHS + # Look in other places. + ${PostgreSQL_ROOT_DIRECTORIES} + PATH_SUFFIXES + postgresql + pgsql/server + postgresql/server + include/server + ${PostgreSQL_TYPE_ADDITIONAL_SEARCH_SUFFIXES} + # Help the user find it if we cannot. + DOC "The ${PostgreSQL_INCLUDE_DIR_MESSAGE}" +) + +# The PostgreSQL library. +set (PostgreSQL_LIBRARY_TO_FIND pq) +# Setting some more prefixes for the library +set (PostgreSQL_LIB_PREFIX "") +if ( WIN32 ) + set (PostgreSQL_LIB_PREFIX ${PostgreSQL_LIB_PREFIX} "lib") + set (PostgreSQL_LIBRARY_TO_FIND ${PostgreSQL_LIB_PREFIX}${PostgreSQL_LIBRARY_TO_FIND}) +endif() + +function(__postgresql_find_library _name) + find_library(${_name} + NAMES ${ARGN} + PATHS + ${PostgreSQL_ROOT_DIRECTORIES} + PATH_SUFFIXES + lib + ${PostgreSQL_LIBRARY_ADDITIONAL_SEARCH_SUFFIXES} + # Help the user find it if we cannot. + DOC "The ${PostgreSQL_LIBRARY_DIR_MESSAGE}" + ) +endfunction() + +# For compatibility with versions prior to this multi-config search, honor +# any PostgreSQL_LIBRARY that is already specified and skip the search. +if(PostgreSQL_LIBRARY) + set(PostgreSQL_LIBRARIES "${PostgreSQL_LIBRARY}") + get_filename_component(PostgreSQL_LIBRARY_DIR "${PostgreSQL_LIBRARY}" PATH) +else() + __postgresql_find_library(PostgreSQL_LIBRARY_RELEASE ${PostgreSQL_LIBRARY_TO_FIND}) + __postgresql_find_library(PostgreSQL_LIBRARY_DEBUG ${PostgreSQL_LIBRARY_TO_FIND}d) + include(SelectLibraryConfigurations) + select_library_configurations(PostgreSQL) + mark_as_advanced(PostgreSQL_LIBRARY_RELEASE PostgreSQL_LIBRARY_DEBUG) + if(PostgreSQL_LIBRARY_RELEASE) + get_filename_component(PostgreSQL_LIBRARY_DIR "${PostgreSQL_LIBRARY_RELEASE}" PATH) + elseif(PostgreSQL_LIBRARY_DEBUG) + get_filename_component(PostgreSQL_LIBRARY_DIR "${PostgreSQL_LIBRARY_DEBUG}" PATH) + else() + set(PostgreSQL_LIBRARY_DIR "") + endif() +endif() + +if (PostgreSQL_INCLUDE_DIR) + # Some platforms include multiple pg_config.hs for multi-lib configurations + # This is a temporary workaround. A better solution would be to compile + # a dummy c file and extract the value of the symbol. + file(GLOB _PG_CONFIG_HEADERS "${PostgreSQL_INCLUDE_DIR}/pg_config*.h") + foreach(_PG_CONFIG_HEADER ${_PG_CONFIG_HEADERS}) + if(EXISTS "${_PG_CONFIG_HEADER}") + file(STRINGS "${_PG_CONFIG_HEADER}" pgsql_version_str + REGEX "^#define[\t ]+PG_VERSION_NUM[\t ]+.*") + if(pgsql_version_str) + string(REGEX REPLACE "^#define[\t ]+PG_VERSION_NUM[\t ]+([0-9]*).*" + "\\1" _PostgreSQL_VERSION_NUM "${pgsql_version_str}") + break() + endif() + endif() + endforeach() + if (_PostgreSQL_VERSION_NUM) + # 9.x and older encoding + if (_PostgreSQL_VERSION_NUM LESS 100000) + math(EXPR _PostgreSQL_major_version "${_PostgreSQL_VERSION_NUM} / 10000") + math(EXPR _PostgreSQL_minor_version "${_PostgreSQL_VERSION_NUM} % 10000 / 100") + math(EXPR _PostgreSQL_patch_version "${_PostgreSQL_VERSION_NUM} % 100") + set(PostgreSQL_VERSION_STRING "${_PostgreSQL_major_version}.${_PostgreSQL_minor_version}.${_PostgreSQL_patch_version}") + unset(_PostgreSQL_major_version) + unset(_PostgreSQL_minor_version) + unset(_PostgreSQL_patch_version) + else () + math(EXPR _PostgreSQL_major_version "${_PostgreSQL_VERSION_NUM} / 10000") + math(EXPR _PostgreSQL_minor_version "${_PostgreSQL_VERSION_NUM} % 10000") + set(PostgreSQL_VERSION_STRING "${_PostgreSQL_major_version}.${_PostgreSQL_minor_version}") + unset(_PostgreSQL_major_version) + unset(_PostgreSQL_minor_version) + endif () + else () + foreach(_PG_CONFIG_HEADER ${_PG_CONFIG_HEADERS}) + if(EXISTS "${_PG_CONFIG_HEADER}") + file(STRINGS "${_PG_CONFIG_HEADER}" pgsql_version_str + REGEX "^#define[\t ]+PG_VERSION[\t ]+\".*\"") + if(pgsql_version_str) + string(REGEX REPLACE "^#define[\t ]+PG_VERSION[\t ]+\"([^\"]*)\".*" + "\\1" PostgreSQL_VERSION_STRING "${pgsql_version_str}") + break() + endif() + endif() + endforeach() + endif () + unset(_PostgreSQL_VERSION_NUM) + unset(pgsql_version_str) +endif() + +if("Server" IN_LIST PostgreSQL_FIND_COMPONENTS) + set(PostgreSQL_Server_FOUND TRUE) + if(NOT PostgreSQL_TYPE_INCLUDE_DIR) + set(PostgreSQL_Server_FOUND FALSE) + endif() +endif() + +# Did we find anything? +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(PostgreSQL + REQUIRED_VARS PostgreSQL_LIBRARY PostgreSQL_INCLUDE_DIR + HANDLE_COMPONENTS + VERSION_VAR PostgreSQL_VERSION_STRING) +set(PostgreSQL_FOUND ${POSTGRESQL_FOUND}) + +function(__postgresql_import_library _target _var _config) + if(_config) + set(_config_suffix "_${_config}") + else() + set(_config_suffix "") + endif() + + set(_lib "${${_var}${_config_suffix}}") + if(EXISTS "${_lib}") + if(_config) + set_property(TARGET ${_target} APPEND PROPERTY + IMPORTED_CONFIGURATIONS ${_config}) + endif() + set_target_properties(${_target} PROPERTIES + IMPORTED_LOCATION${_config_suffix} "${_lib}") + endif() +endfunction() + +# Now try to get the include and library path. +if(PostgreSQL_FOUND) + set(PostgreSQL_INCLUDE_DIRS ${PostgreSQL_INCLUDE_DIR}) + if(PostgreSQL_TYPE_INCLUDE_DIR) + list(APPEND PostgreSQL_INCLUDE_DIRS ${PostgreSQL_TYPE_INCLUDE_DIR}) + endif() + set(PostgreSQL_LIBRARY_DIRS ${PostgreSQL_LIBRARY_DIR}) + if (NOT TARGET PostgreSQL::PostgreSQL) + add_library(PostgreSQL::PostgreSQL UNKNOWN IMPORTED) + set_target_properties(PostgreSQL::PostgreSQL PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${PostgreSQL_INCLUDE_DIRS}") + __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "") + __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "RELEASE") + __postgresql_import_library(PostgreSQL::PostgreSQL PostgreSQL_LIBRARY "DEBUG") + endif () +endif() + +mark_as_advanced(PostgreSQL_INCLUDE_DIR PostgreSQL_TYPE_INCLUDE_DIR) + +cmake_policy(POP) diff --git a/cmake/find_scripts/FindReadline.cmake b/cmake/find_scripts/FindReadline.cmake new file mode 100644 index 00000000000..14981ddf9c2 --- /dev/null +++ b/cmake/find_scripts/FindReadline.cmake @@ -0,0 +1,40 @@ +find_package(PkgConfig) +if(PKG_CONFIG_FOUND) + pkg_check_modules(Readline QUIET "readline") + pkg_check_modules(History QUIET "history") + set(Readline_LIBRARIES ${Readline_LINK_LIBRARIES}) + set(History_LIBRARIES ${History_LINK_LIBRARIES}) +else() + find_path(Readline_ROOT_DIR NAMES include/readline/readline.h) + find_path( + Readline_INCLUDE_DIRS + NAMES readline/readline.h + HINTS ${Readline_ROOT_DIR}/include) + find_library( + Readline_LIBRARIES + NAMES readline + HINTS ${Readline_ROOT_DIR}/lib) + if(Readline_INCLUDE_DIRS AND Readline_LIBRARIES) + set(Readline_FOUND TRUE) + endif() + + find_path( + History_INCLUDE_DIRS + NAMES readline/readline.h + HINTS ${Readline_ROOT_DIR}/include) + find_library( + History_LIBRARIES + NAMES readline + HINTS ${Readline_ROOT_DIR}/lib) + if(History_INCLUDE_DIRS AND History_LIBRARIES) + set(History_FOUND TRUE) + endif() +endif() + +if(Readline_FOUND) + message(STATUS "Found Readline: ${Readline_LIBRARIES}") +endif() + +if(History_FOUND) + message(STATUS "Found History: ${History_LIBRARIES}") +endif() diff --git a/cmake/find_scripts/FindSQLite.cmake b/cmake/find_scripts/FindSQLite.cmake new file mode 100644 index 00000000000..19da96bf203 --- /dev/null +++ b/cmake/find_scripts/FindSQLite.cmake @@ -0,0 +1,9 @@ +find_path(SQLITE_INCLUDE_DIR sqlite3.h) +find_library(SQLITE_LIBRARY NAMES sqlite3) + +mark_as_advanced(SQLITE_LIBRARY) +mark_as_advanced(SQLITE_INCLUDE_DIR) + +include(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake) +find_package_handle_standard_args(SQLite REQUIRED_VARS SQLITE_LIBRARY + SQLITE_INCLUDE_DIR) diff --git a/cmake/find_scripts/Findzstd.cmake b/cmake/find_scripts/Findzstd.cmake new file mode 100644 index 00000000000..2b2d4428a66 --- /dev/null +++ b/cmake/find_scripts/Findzstd.cmake @@ -0,0 +1,22 @@ +find_package(PkgConfig) +if(PKG_CONFIG_FOUND) + pkg_check_modules(zstd QUIET "libzstd") + set(zstd_LIBRARIES ${zstd_LINK_LIBRARIES}) +else() + find_path(zstd_ROOT_DIR NAMES include/zstd.h) + find_path( + zstd_INCLUDE_DIRS + NAMES zstd.h + HINTS ${zstd_ROOT_DIR}/include) + find_library( + zstd_LIBRARIES + NAMES zstd + HINTS ${zstd_ROOT_DIR}/lib) + if(zstd_INCLUDE_DIRS AND zstd_LIBRARIES) + set(zstd_FOUND TRUE) + endif() +endif() + +if(zstd_FOUND) + message(STATUS "Found zstd: ${zstd_LIBRARIES}") +endif() diff --git a/cmake/generate_man_pages.cmake b/cmake/generate_man_pages.cmake new file mode 100644 index 00000000000..85553ef8629 --- /dev/null +++ b/cmake/generate_man_pages.cmake @@ -0,0 +1,19 @@ +# work in progress... + + +file(GLOB doc_HTMLFILES "${OUTDIR}/${GRASS_INSTALL_DOCDIR}/*.html") + +foreach(html_file ${doc_HTMLFILES}) + get_filename_component(PGM_NAME ${html_file} NAME) + add_custom_command( + TARGET create_man_pages + PRE_BUILD + COMMAND ${HTML2MAN} ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${PGM_NAME}.html + ${OUTDIR}/${GRASS_INSTALL_MANDIR}/${PGM_NAME}.1 + ) +endforeach() + +#[[ +COMMAND ${HTML2MAN} ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${PGM_NAME}.html + ${OUTDIR}/${GRASS_INSTALL_MANDIR}/${PGM_NAME}.1 +]] diff --git a/cmake/locale_strings.cmake b/cmake/locale_strings.cmake new file mode 100644 index 00000000000..d24b4af2727 --- /dev/null +++ b/cmake/locale_strings.cmake @@ -0,0 +1,78 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: create translation strings for grass scripts + environment. TODO use custom_command POST_BUILD directly +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later + +PARAMS: BINARY_DIR + ETCDIR + GISBASE_DIR + GISRC + GUIDIR + G_NAME + LIBDIR + OUTPUT_FILE + PYDIR + SCRIPTDIR + SOURCE_DIR +#]] + +file(TO_NATIVE_PATH "${SOURCE_DIR}" MODULE_TOPDIR) +file(TO_NATIVE_PATH "${GISBASE_DIR}" GISBASE_NATIVE) +file(TO_NATIVE_PATH "${BINARY_DIR}" BIN_DIR) +file(TO_NATIVE_PATH "${LIBDIR}" LIB_DIR) +file(TO_NATIVE_PATH "${SCRIPTDIR}" SCRIPTS_DIR) +file(TO_NATIVE_PATH "${GISRC}" GISRC) +file(TO_NATIVE_PATH "${PYDIR}" ETC_PYTHON_DIR) +file(TO_NATIVE_PATH "${GUIDIR}/wxpython" GUI_WXPYTHON_DIR) + +if(WIN32) + set(sep "\;") + set(env_path "") +else() + set(sep ":") + set(env_path ":$ENV{PATH}") +endif() + +set(ENV{GISBASE} "${GISBASE_NATIVE}") +set(ENV{GISRC} ${GISRC}) +set(ENV{PATH} "${BIN_DIR}${sep}${SCRIPTS_DIR}${env_path}") +set(ENV{PYTHONPATH} + "${ETC_PYTHON_DIR}${sep}${GUI_WXPYTHON_DIR}${sep}$ENV{PYTHONPATH}") +if(NOT MSVC) + set(ENV{LD_LIBRARY_PATH} "${LIB_DIR}${sep}$ENV{LD_LIBRARY_PATH}") +endif() +set(ENV{LC_ALL} C) +set(ENV{LANG} C) +set(ENV{LANGUAGE} C) +set(ENV{MODULE_TOPDIR} ${MODULE_TOPDIR}) + +set(SCRIPT_EXT "") +if(WIN32) + set(SCRIPT_EXT ".py") +endif() + +if(WIN32) + set(PGM_NAME ${G_NAME}) + configure_file(${SOURCE_DIR}/cmake/windows_launch.bat.in + ${SCRIPTDIR}/${G_NAME}.bat @ONLY) +endif(WIN32) + +execute_process( + COMMAND ${BINARY_DIR}/g.parser -t ${SCRIPTDIR}/${G_NAME}${SCRIPT_EXT} + OUTPUT_VARIABLE run_g_parser_OV + ERROR_VARIABLE run_g_parser_EV + RESULT_VARIABLE run_g_parser_RV) + +string(REGEX REPLACE "\n" ";" varname "${run_g_parser_OV}") +set(output_to_write) +foreach(line ${varname}) + string(REPLACE "\"" "\\\"" line "${line}") + set(line "_(\"${line}\")") + list(APPEND output_to_write "${line}") +endforeach() + +string(REGEX REPLACE ";" "\n" output_to_write "${output_to_write}") +file(WRITE "${OUTPUT_FILE}" "${output_to_write}\n") diff --git a/cmake/modules/CheckDependentLibraries.cmake b/cmake/modules/CheckDependentLibraries.cmake new file mode 100644 index 00000000000..617f9baed0c --- /dev/null +++ b/cmake/modules/CheckDependentLibraries.cmake @@ -0,0 +1,460 @@ +#[=======================================================================[.rst: +CheckDependentLibraries.cmake +----------------------------- + +Detect GRASS dependencies and set variable HAVE_* + +#]=======================================================================] + +# Required dependencies + +find_package(FLEX REQUIRED) + +find_package(BISON REQUIRED) + +if(UNIX) + find_library(MATH_LIBRARY m) + add_library(LIBM INTERFACE IMPORTED GLOBAL) + set_property(TARGET LIBM PROPERTY INTERFACE_LINK_LIBRARIES ${MATH_LIBRARY}) + mark_as_advanced(M_LIBRARY) + set(LIBM LIBM) +endif() + +find_package(PROJ REQUIRED) +if(PROJ_FOUND) + add_library(PROJ INTERFACE IMPORTED GLOBAL) + set_property(TARGET PROJ PROPERTY INTERFACE_LINK_LIBRARIES + ${PROJ_LIBRARY${find_library_suffix}}) + set_property(TARGET PROJ PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${PROJ_INCLUDE_DIR}) +endif() + +find_package(GDAL REQUIRED) +if(GDAL_FOUND) + add_library(GDAL INTERFACE IMPORTED GLOBAL) + set_property(TARGET GDAL PROPERTY INTERFACE_LINK_LIBRARIES ${GDAL_LIBRARY}) + set_property(TARGET GDAL PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${GDAL_INCLUDE_DIR}) +endif() + +find_package(ZLIB REQUIRED) +if(ZLIB_FOUND) + add_library(ZLIB INTERFACE IMPORTED GLOBAL) + set_property(TARGET ZLIB PROPERTY INTERFACE_LINK_LIBRARIES + ${ZLIB_LIBRARY${find_library_suffix}}) + set_property(TARGET ZLIB PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${ZLIB_INCLUDE_DIR}) +endif() + +# Optional dependencies + +if(MSVC) + find_package(PCRE REQUIRED) + if(PCRE_FOUND) + add_library(PCRE INTERFACE IMPORTED GLOBAL) + set_property(TARGET PCRE PROPERTY INTERFACE_LINK_LIBRARIES + ${PCRE_LIBRARY${find_library_suffix}}) + set_property(TARGET PCRE PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${PCRE_INCLUDE_DIR}) + endif() +endif() + +find_package(Iconv QUIET) +if(ICONV_FOUND) + add_library(ICONV INTERFACE IMPORTED GLOBAL) + set_property(TARGET ICONV PROPERTY INTERFACE_LINK_LIBRARIES + ${ICONV_LIBRARIES}) + set_property(TARGET ICONV PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${ICONV_INCLUDE_DIR}) + # if(ICONV_SECOND_ARGUMENT_IS_CONST) set() update this value in + # include/config.cmake.in +endif() + +set(THREADS_PREFER_PTHREAD_FLAG ON) +find_package(Threads) +if(Threads_FOUND) + add_library(PTHREAD INTERFACE IMPORTED GLOBAL) + if(THREADS_HAVE_PTHREAD_ARG) + set_property(TARGET PTHREAD PROPERTY INTERFACE_COMPILE_OPTIONS "-pthread") + endif() + if(CMAKE_THREAD_LIBS_INIT) + set_property(TARGET PTHREAD PROPERTY INTERFACE_LINK_LIBRARIES + "${CMAKE_THREAD_LIBS_INIT}") + endif() +endif() + +# Graphics options + +if(WITH_X11) + find_package(X11 REQUIRED) + if(X11_FOUND) + add_library(X11 INTERFACE IMPORTED GLOBAL) + set_property(TARGET X11 PROPERTY INTERFACE_LINK_LIBRARIES ${X11_LIBRARIES}) + set_property(TARGET X11 PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${X11_INCLUDE_DIR}) + endif() +endif() + +if(WITH_OPENGL) + find_package(OpenGL REQUIRED) + if(OPENGL_FOUND) + add_library(OPENGL INTERFACE IMPORTED GLOBAL) + if(APPLE) + find_library(AGL_FRAMEWORK AGL DOC "AGL lib for OSX") + set(APP "-framework AGL -framework ApplicationServices") + endif() + set_property(TARGET OPENGL PROPERTY INTERFACE_LINK_LIBRARIES + ${OPENGL_LIBRARIES} ${AGL_FRAMEWORK}) + set_property(TARGET OPENGL PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${OPENGL_INCLUDE_DIR} ${AGL_FRAMEWORK}) + endif() +endif() + +if(WITH_CAIRO) + find_package(Cairo REQUIRED) + if(CAIRO_FOUND) + add_library(CAIRO INTERFACE IMPORTED GLOBAL) + set_property(TARGET CAIRO PROPERTY INTERFACE_LINK_LIBRARIES + ${CAIRO_LIBRARIES}) + set_property(TARGET CAIRO PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${CAIRO_INCLUDE_DIRS}) + endif() +endif() + +if(WITH_LIBPNG) + find_package(PNG REQUIRED) + if(PNG_FOUND) + add_library(LIBPNG INTERFACE IMPORTED GLOBAL) + set_property(TARGET LIBPNG PROPERTY INTERFACE_LINK_LIBRARIES + ${PNG_LIBRARY${find_library_suffix}}) + set_property(TARGET LIBPNG PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${PNG_INCLUDE_DIR}) + endif() +endif() + +# Data storage options + +if(WITH_SQLITE) + find_package(SQLite REQUIRED) + if(SQLITE_FOUND) + add_library(SQLITE INTERFACE IMPORTED GLOBAL) + set_property(TARGET SQLITE PROPERTY INTERFACE_LINK_LIBRARIES + ${SQLITE_LIBRARY}) + set_property(TARGET SQLITE PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${SQLITE_INCLUDE_DIRS}) + endif() +endif() + +if(WITH_POSTGRES) + find_package(PostgreSQL REQUIRED) + if(PostgreSQL_FOUND) + add_library(POSTGRES INTERFACE IMPORTED GLOBAL) + set_property(TARGET POSTGRES PROPERTY INTERFACE_LINK_LIBRARIES + ${PostgreSQL_LIBRARY}) + set_property(TARGET POSTGRES PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${PostgreSQL_INCLUDE_DIR}) + endif() +endif() + +if(WITH_MYSQL) + find_package(MySQL REQUIRED) + if(MySQL_FOUND) + add_library(MYSQL INTERFACE IMPORTED GLOBAL) + set_property(TARGET MYSQL PROPERTY INTERFACE_LINK_LIBRARIES + ${MySQL_LIBRARY}) + set_property(TARGET MYSQL PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${MySQL_INCLUDE_DIRS}) + endif() +endif() + +if(WITH_ODBC AND WIN32) + find_package(ODBC QUIET) + if(ODBC_FOUND) + add_library(ODBC INTERFACE IMPORTED GLOBAL) + #[[ + set_property(TARGET ODBC PROPERTY INTERFACE_LINK_LIBRARIES ${ODBC_LIBRARIES}) + set_property(TARGET PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${ODBC_INCLUDE_DIRS}) + #]] + endif() +endif() + +if(WITH_ZSTD) + find_package(zstd REQUIRED) + if(zstd_FOUND) + add_library(ZSTD INTERFACE IMPORTED GLOBAL) + set_property(TARGET ZSTD PROPERTY INTERFACE_LINK_LIBRARIES + ${zstd_LIBRARIES}) + set_property(TARGET ZSTD PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${zstd_INCLUDE_DIRS}) + endif() +endif() + +if(WITH_BZLIB) + find_package(BZip2 REQUIRED) + if(BZIP2_FOUND) + add_library(BZIP2 INTERFACE IMPORTED GLOBAL) + set_property(TARGET BZIP2 PROPERTY INTERFACE_LINK_LIBRARIES + ${BZIP2_LIBRARY${find_library_suffix}}) + set_property(TARGET BZIP2 PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${BZIP2_INCLUDE_DIR}) + endif() +endif() + +# Command-line options +if(WITH_READLINE) + find_package(Readline REQUIRED) + if(Readline_FOUND) + add_library(READLINE INTERFACE IMPORTED GLOBAL) + set_property(TARGET READLINE PROPERTY INTERFACE_LINK_LIBRARIES + ${Readline_LIBRARIES}) + set_property(TARGET READLINE PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${Readline_INCLUDE_DIRS}) + endif() + if(History_FOUND) + add_library(HISTORY INTERFACE IMPORTED GLOBAL) + set_property(TARGET HISTORY PROPERTY INTERFACE_LINK_LIBRARIES + ${History_LIBRARIES}) + set_property(TARGET HISTORY PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${History_INCLUDE_DIRS}) + endif() +endif() + +# Language options +if(WITH_FREETYPE) + find_package(Freetype REQUIRED) + if(FREETYPE_FOUND) + add_library(FREETYPE INTERFACE IMPORTED GLOBAL) + set_property( + TARGET FREETYPE PROPERTY INTERFACE_LINK_LIBRARIES + ${FREETYPE_LIBRARY${find_library_suffix}}) + set_property(TARGET FREETYPE PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${FREETYPE_INCLUDE_DIRS}) + endif() +endif() + +if(WITH_NLS) + find_package(Gettext REQUIRED) + if(GETTEXT_FOUND) + set(MSGFMT ${GETTEXT_MSGFMT_EXECUTABLE}) + set(MSGMERGE ${GETTEXT_MSGMERGE_EXECUTABLE}) + endif() +endif() + +# Computing options +if(WITH_FFTW) + find_package(FFTW REQUIRED) + if(FFTW_FOUND) + add_library(FFTW INTERFACE IMPORTED GLOBAL) + set_property(TARGET FFTW PROPERTY INTERFACE_LINK_LIBRARIES + ${FFTW_LIBRARIES}) + set_property(TARGET FFTW PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${FFTW_INCLUDE_DIR}) + endif() +endif() + +if(WIN32) + set(BLA_PREFER_PKGCONFIG ON) + set(BLA_PKGCONFIG_BLAS "openblas") + set(BLA_PKGCONFIG_LAPACK "openblas") +else() + set(BLA_PKGCONFIG_BLAS "blas-netlib") + set(BLA_PKGCONFIG_LAPACK "lapacke") +endif() + +if(WITH_CBLAS) + # find_package(CBLAS CONFIG REQUIRED) + pkg_check_modules(CBLAS QUIET ${BLA_PKGCONFIG_BLAS}) + if (CBLAS_FOUND) + add_library(CBLAS INTERFACE IMPORTED GLOBAL) + set_property(TARGET CBLAS PROPERTY INTERFACE_LINK_LIBRARIES + ${CBLAS_LIBRARIES}) + set_property(TARGET CBLAS PROPERTY INTERFACE_LINK_DIRECTORIES + ${CBLAS_LIBRARY_DIRS}) + set_property(TARGET CBLAS PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${CBLAS_INCLUDEDIR}) + endif() + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(CBLAS REQUIRED_VARS CBLAS_LIBRARIES + CBLAS_INCLUDEDIR) +endif() + +if(WITH_LAPACKE) + # find_package(LAPACKE CONFIG REQUIRED) + pkg_check_modules(LAPACKE QUIET ${BLA_PKGCONFIG_LAPACK}) + if(LAPACKE_FOUND) + add_library(LAPACKE INTERFACE IMPORTED GLOBAL) + set_property(TARGET LAPACKE PROPERTY INTERFACE_LINK_LIBRARIES + ${LAPACKE_LIBRARIES}) + set_property(TARGET LAPACKE PROPERTY INTERFACE_LINK_DIRECTORIES + ${LAPACKE_LIBRARY_DIRS}) + set_property(TARGET LAPACKE PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${LAPACKE_INCLUDEDIR}) + endif() + find_package_handle_standard_args(LAPACKE REQUIRED_VARS LAPACKE_LIBRARIES + LAPACKE_INCLUDEDIR) +endif() + +if(WITH_OPENMP) + if(MSVC AND CMAKE_VERSION VERSION_GREATER_EQUAL "3.30") + # for min/max reduction + # get rid of warning D9025: overriding '/openmp' with '/openmp:llvm' + set(OpenMP_RUNTIME_MSVC "llvm") + endif() + find_package(OpenMP REQUIRED) + if(OpenMP_FOUND AND MSVC AND CMAKE_VERSION VERSION_LESS "3.30") + # CMake < 3.30 doesn't support OpenMP_RUNTIME_MSVC + # for min/max reduction + add_compile_options(-openmp:llvm) + endif() +endif() + +# Data format options +if(WITH_TIFF) + find_package(TIFF REQUIRED) + if(TIFF_FOUND) + add_library(TIFF INTERFACE IMPORTED GLOBAL) + set_property(TARGET TIFF PROPERTY INTERFACE_LINK_LIBRARIES + ${TIFF_LIBRARY${find_library_suffix}}) + set_property(TARGET TIFF PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${TIFF_INCLUDE_DIR}) + endif() +endif() + +if(WITH_NETCDF) + find_package(NetCDF REQUIRED) + if(NetCDF_FOUND) + add_library(NETCDF INTERFACE IMPORTED GLOBAL) + set_property(TARGET NETCDF PROPERTY INTERFACE_LINK_LIBRARIES + ${NetCDF_LIBRARY}) + set_property(TARGET NETCDF PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${NetCDF_INCLUDE_DIR}) + endif() +endif() + +if(WITH_GEOS) + find_package(GEOS REQUIRED) + if(GEOS_FOUND) + add_library(GEOS INTERFACE IMPORTED GLOBAL) + set_property(TARGET GEOS PROPERTY INTERFACE_LINK_LIBRARIES + ${GEOS_C_LIBRARY${find_library_suffix}}) + set_property(TARGET GEOS PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${GEOS_INCLUDE_DIR}) + endif() +endif() + +if(WITH_PDAL) + find_package(PDAL REQUIRED) + if(PDAL_FOUND) + add_library(PDAL INTERFACE IMPORTED GLOBAL) + set_property(TARGET PDAL PROPERTY INTERFACE_LINK_LIBRARIES + ${PDAL_LIBRARIES}) + set_property(TARGET PDAL PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${PDAL_INCLUDE_DIRS}) + endif() +endif() + +if(WITH_LIBLAS) + find_package(LibLAS REQUIRED) + if(LibLAS_FOUND) + add_library(LIBLAS INTERFACE IMPORTED GLOBAL) + set_property(TARGET LIBLAS PROPERTY INTERFACE_LINK_LIBRARIES + ${LibLAS_C_LIBRARY}) + set_property(TARGET LIBLAS PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${LibLAS_INCLUDE_DIR}) + endif() +endif() + +find_package(Python3 REQUIRED) +if(Python3_FOUND) + set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE}) + set(PYTHON_SITEARCH ${Python3_SITEARCH}) + #[[ + find_package(PythonLibs REQUIRED) + find_package(Numpy) + #]] +endif() + +check_target(PROJ HAVE_PROJ_H) +check_target(GDAL HAVE_GDAL) +check_target(GDAL HAVE_OGR) +check_target(ZLIB HAVE_ZLIB_H) +check_target(ICONV HAVE_ICONV_H) +check_target(LIBPNG HAVE_PNG_H) +check_target(LIBJPEG HAVE_JPEGLIB_H) +check_target(SQLITE HAVE_SQLITE) +check_target(POSTGRES HAVE_POSTGRES) +check_target(MYSQL HAVE_MYSQL_H) +check_target(ODBC HAVE_SQL_H) +check_target(ZSTD HAVE_ZSTD_H) +check_target(BZIP2 HAVE_BZLIB_H) +check_target(READLINE HAVE_READLINE_READLINE_H) +check_target(HISTORY HAVE_READLINE_HISTORY_H) +check_target(FREETYPE HAVE_FT2BUILD_H) +# set(CMAKE_REQUIRED_INCLUDES "${FFTW_INCLUDE_DIR}") no target ATLAS in +# thirdpary/CMakeLists.txt +check_target(ATLAS HAVE_LIBATLAS) +check_target(CBLAS HAVE_LIBBLAS) +check_target(CBLAS HAVE_CBLAS_H) +check_target(LAPACKE HAVE_LIBLAPACK) +check_target(LAPACKE HAVE_CLAPACK_H) +check_target(TIFF HAVE_TIFFIO_H) +check_target(NETCDF HAVE_NETCDF) +check_target(GEOS HAVE_GEOS) + +if(MSVC) + check_target(PCRE HAVE_PCRE_H) +endif() + +check_target(POSTGRES HAVE_LIBPQ_FE_H) + +set(HAVE_PBUFFERS 0) +set(HAVE_PIXMAPS 0) +if(WITH_OPENGL) + try_compile( + HAVE_PBUFFERS ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_SOURCE_DIR}/cmake/tests/have_pbuffer.c + CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:PATH=${OPENGL_INCLUDE_DIR}" "-w" + "-DLINK_LIBRARIES:STRING=${OPENGL_LIBRARIES}" + OUTPUT_VARIABLE COMPILE_HAVE_PBUFFERS) + if(NOT COMPILE_HAVE_PBUFFERS) + message( + FATAL_ERROR + "Performing Test HAVE_PBUFFERS - Failed\n COMPILE_OUTPUT:${COMPILE_HAVE_PBUFFERS}\n" + ) + else() + message(STATUS "Performing Test HAVE_PBUFFERS - Success") + set(HAVE_PBUFFERS 1) + endif() + + try_compile( + HAVE_PIXMAPS ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_SOURCE_DIR}/cmake/tests/have_pixmaps.c + CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:PATH=${OPENGL_INCLUDE_DIR}" "-w" + "-DLINK_LIBRARIES:STRING=${OPENGL_LIBRARIES}" + OUTPUT_VARIABLE COMPILE_HAVE_PIXMAPS) + + if(NOT COMPILE_HAVE_PIXMAPS) + message( + FATAL_ERROR + "Performing Test HAVE_PIXMAPS - Failed\n COMPILE_OUTPUT:${COMPILE_HAVE_PIXMAPS}\n" + ) + else() + message(STATUS "Performing Test HAVE_PIXMAPS - Success") + set(HAVE_PIXMAPS 1) + endif() + +endif(WITH_OPENGL) + +set(OPENGL_X11 0) +set(OPENGL_AQUA 0) +set(OPENGL_WINDOWS 0) +if(WITH_OPENGL) + if(APPLE) + set(OPENGL_AQUA 1) + set(OPENGL_AGL 1) + elseif(WIN32) + set(OPENGL_WINDOWS 1) + else() + set(OPENGL_X11 1) + endif() +endif() diff --git a/cmake/modules/Configure.cmake b/cmake/modules/Configure.cmake new file mode 100644 index 00000000000..23f99367057 --- /dev/null +++ b/cmake/modules/Configure.cmake @@ -0,0 +1,211 @@ +include(CheckIncludeFile) +include(CheckSymbolExists) +include(CheckCSourceCompiles) + +check_include_file(limits.h HAVE_LIMITS_H) +check_include_file(termio.h HAVE_TERMIO_H) +check_include_file(termios.h HAVE_TERMIOS_H) +if(NOT MSVC) + check_include_file(unistd.h HAVE_UNISTD_H) +else() + # unistd.h in stocked in thirdparty/msvc/ + set(HAVE_UNISTD_H 1) +endif() +check_include_file(values.h HAVE_VALUES_H) +check_include_file(sys/ioctl.h HAVE_SYS_IOCTL_H) +check_include_file(sys/mtio.h HAVE_SYS_MTIO_H) +check_include_file(sys/resource.h HAVE_SYS_RESOURCE_H) +check_include_file(sys/time.h HAVE_SYS_TIME_H) +check_include_file(time.h HAVE_TIME_H) +check_include_file(sys/timeb.h HAVE_SYS_TIMEB_H) +check_include_file(sys/types.h HAVE_SYS_TYPES_H) +check_include_file(sys/utsname.h HAVE_SYS_UTSNAME_H) +check_include_file(g2c.h HAVE_G2C_H) +check_include_file(f2c.h HAVE_F2C_H) + +if(MSVC) + set(HAVE_PTHREAD_H 0) + set(HAVE_REGEX_H 0) + set(HAVE_LIBINTL_H 0) + set(HAVE_LANGINFO_H 0) + set(HAVE_DBM_H 0) +else() + check_include_file(pthread.h HAVE_PTHREAD_H) + check_include_file(regex.h HAVE_REGEX_H) + check_include_file(libintl.h HAVE_LIBINTL_H) + check_include_file(langinfo.h HAVE_LANGINFO_H) + check_include_file(dbm.h HAVE_DBM_H) +endif() +# +# # set(CMAKE_REQUIRED_INCLUDES "${FFTW_INCLUDE_DIR}") check_target(ICONV +# HAVE_ICONV_H) check_target(BZIP2 HAVE_BZLIB_H) check_target(ZLIB HAVE_ZLIB_H) +# check_target(LIBJPEG HAVE_JPEGLIB_H) check_target(LIBPNG HAVE_PNG_H) +# check_target(TIFF HAVE_TIFFIO_H) check_target(GEOS HAVE_GEOS) +# check_target(GDAL HAVE_GDAL) check_target(GDAL HAVE_OGR) check_target(SQLITE +# HAVE_SQLITE) +# +# check_target(PROJ HAVE_PROJ_H) +# +# check_target(BLAS HAVE_LIBBLAS) check_target(BLAS HAVE_CBLAS_H) +# +# check_target(LAPACK HAVE_LIBLAPACK) check_target(LAPACK HAVE_CLAPACK_H) +# +# check_target(FREETYPE HAVE_FT2BUILD_H) check_target(POSTGRES HAVE_POSTGRES) +# check_target(ODBC HAVE_SQL_H) +# +# if(MSVC) check_target(PCRE HAVE_PCRE_H) endif() +# +# check_target(POSTGRES HAVE_LIBPQ_FE_H) + +# Whether or not we are using G_socks for display communications +set(USE_G_SOCKS 0) + +if(WITH_LARGEFILES) + set(HAVE_LARGEFILES 1) +else() + set(HAVE_LARGEFILES 0) +endif() + +if(MSVC) + set(GID_TYPE int) + set(UID_TYPE int) + set(UID_TYPE int) + set(RETSIGTYPE "void") +else() + set(RETSIGTYPE "int") +endif() + +# #######################TODO######################## +# no target ATLAS in thirdpary/CMakeLists.txt check_target(ATLAS HAVE_LIBATLAS) + +set(USE_NLS 0) +if(WITH_NLS) + set(USE_NLS 1) +endif() +set(HAVE_READLINE_READLINE_H 0) + +if(MSVC) + set(PID_TYPE int) +endif() + +set(_OE_SOCKETS 0) +set(USE_DELTA_FOR_TZ 0) +set(_REENTRANT 0) +# #######################TODO######################## + +set(X_DISPLAY_MISSING 1) +if(TARGET X11) + set(X_DISPLAY_MISSING 0) +endif() + +# used in config.cmake.in +set(STATIC_BUILD 0) +if(NOT BUILD_SHARED_LIBS) + set(STATIC_BUILD 1) +endif() + +# used in config.cmake.in +set(GDEBUG 0) +if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug") + set(GDEBUG 1) +endif() + +set(CMAKE_REQUIRED_FLAGS ${CMAKE_C_FLAGS}) + +check_c_source_compiles( + " +int main(int argc, char *argv[]) +{ +long long int x; +return 0; +} +" + HAVE_LONG_LONG_INT) + +check_c_source_compiles( + " +#include +#include +#include +int main() { +struct tm *tp; +; return 0; } +" + TIME_WITH_SYS_TIME) + +check_symbol_exists(gethostname "unistd.h" HAVE_GETHOSTNAME) +check_symbol_exists(gettimeofday "sys/time.h" HAVE_GETTIMEOFDAY) +check_symbol_exists(time "time.h" HAVE_TIME) +check_symbol_exists(putenv "stdlib.h" HAVE_PUTENV) +check_symbol_exists(setenv "stdlib.h" HAVE_SETENV) +check_symbol_exists(socket "sys/socket.h" HAVE_SOCKET) +check_symbol_exists(ftime "sys/timeb.h" HAVE_FTIME) +check_symbol_exists(lseek "unistd.h" HAVE_LSEEK) +check_symbol_exists(uname "sys/utsname.h" HAVE_UNAME) +check_symbol_exists(seteuid "unistd.h" HAVE_SETEUID) +check_symbol_exists(setpriority "sys/resource.h" HAVE_SETPRIORITY) +check_symbol_exists(setreuid "unistd.h" HAVE_SETREUID) +check_symbol_exists(setruid "unistd.h" HAVE_SETRUID) +check_symbol_exists(setpgrp "unistd.h" SETPGRP_VOID) +check_symbol_exists(drand48 "stdlib.h" HAVE_DRAND48) +check_symbol_exists(nanosleep "time.h" HAVE_NANOSLEEP) +check_symbol_exists(fseeko "stdio.h" HAVE_FSEEKO) + +function(check_symbol_definitions) + cmake_parse_arguments(PARSE_ARGV 0 ARG "" "SYMBOL" "INCLUDES;DEFINITIONS") + + string(TOUPPER "HAVE_${ARG_SYMBOL}" var_name) + + # First try with a simple check + check_symbol_exists("${ARG_SYMBOL}" "${ARG_INCLUDES}" "${var_name}") + + if($CACHE{${var_name}}) + return() + endif() + + # Otherwise, start trying alternatives + foreach(def IN LISTS ARG_DEFINITIONS) + unset(${var_name} CACHE) + set(CMAKE_REQUIRED_DEFINITIONS "-D${def}") + check_symbol_exists("${ARG_SYMBOL}" "${ARG_INCLUDES}" "${var_name}") + if($CACHE{${var_name}}) + return() + endif() + endforeach() +endfunction() + +check_symbol_definitions( + SYMBOL + asprintf + INCLUDES + stdio.h + DEFINITIONS + _GNU_SOURCE + _BSD_SOURCE) + +# set(HAVE_PBUFFERS 0) set(HAVE_PIXMAPS 0) if(WITH_OPENGL) try_compile( +# HAVE_PBUFFERS ${CMAKE_CURRENT_BINARY_DIR} +# ${CMAKE_SOURCE_DIR}/cmake/tests/have_pbuffer.c CMAKE_FLAGS +# "-DINCLUDE_DIRECTORIES:PATH=${OPENGL_INCLUDE_DIR}" "-w" +# "-DLINK_LIBRARIES:STRING=${OPENGL_LIBRARIES}" OUTPUT_VARIABLE +# COMPILE_HAVE_PBUFFERS) if(NOT COMPILE_HAVE_PBUFFERS) message( FATAL_ERROR +# "Performing Test HAVE_PBUFFERS - Failed\n +# COMPILE_OUTPUT:${COMPILE_HAVE_PBUFFERS}\n" ) else() message(STATUS "Performing +# Test HAVE_PBUFFERS - Success") set(HAVE_PBUFFERS 1) endif() +# +# try_compile( HAVE_PIXMAPS ${CMAKE_CURRENT_BINARY_DIR} +# ${CMAKE_SOURCE_DIR}/cmake/tests/have_pixmaps.c CMAKE_FLAGS +# "-DINCLUDE_DIRECTORIES:PATH=${OPENGL_INCLUDE_DIR}" "-w" +# "-DLINK_LIBRARIES:STRING=${OPENGL_LIBRARIES}" OUTPUT_VARIABLE +# COMPILE_HAVE_PIXMAPS) +# +# if(NOT COMPILE_HAVE_PIXMAPS) message( FATAL_ERROR "Performing Test +# HAVE_PIXMAPS - Failed\n COMPILE_OUTPUT:${COMPILE_HAVE_PIXMAPS}\n" ) else() +# message(STATUS "Performing Test HAVE_PIXMAPS - Success") set(HAVE_PIXMAPS 1) +# endif() +# +# endif(WITH_OPENGL) +# +# set(OPENGL_X11 0) set(OPENGL_AQUA 0) set(OPENGL_WINDOWS 0) if(WITH_OPENGL) +# if(APPLE) set(OPENGL_AQUA 1) set(OPENGL_AGL 1) elseif(WIN32) +# set(OPENGL_WINDOWS 1) else() set(OPENGL_X11 1) endif() endif() diff --git a/cmake/modules/DevelUtils.cmake b/cmake/modules/DevelUtils.cmake new file mode 100644 index 00000000000..f2ed58ac16c --- /dev/null +++ b/cmake/modules/DevelUtils.cmake @@ -0,0 +1,36 @@ +# From https://stackoverflow.com/a/34292622 + +# Get all propreties that cmake supports +if(NOT CMAKE_PROPERTY_LIST) + execute_process(COMMAND cmake --help-property-list OUTPUT_VARIABLE CMAKE_PROPERTY_LIST) + + # Convert command output into a CMake list + string(REGEX REPLACE ";" "\\\\;" CMAKE_PROPERTY_LIST "${CMAKE_PROPERTY_LIST}") + string(REGEX REPLACE "\n" ";" CMAKE_PROPERTY_LIST "${CMAKE_PROPERTY_LIST}") + list(REMOVE_DUPLICATES CMAKE_PROPERTY_LIST) +endif() + +function(print_properties) + message("CMAKE_PROPERTY_LIST = ${CMAKE_PROPERTY_LIST}") +endfunction() + +function(print_target_properties target) + if(NOT TARGET ${target}) + message(STATUS "There is no target named '${target}'") + return() + endif() + + foreach(property ${CMAKE_PROPERTY_LIST}) + string(REPLACE "" "${CMAKE_BUILD_TYPE}" property ${property}) + + if(property STREQUAL "LOCATION" OR property MATCHES "^LOCATION_" OR property MATCHES "_LOCATION$") + continue() + endif() + + get_property(was_set TARGET ${target} PROPERTY ${property} SET) + if(was_set) + get_target_property(value ${target} ${property}) + message("${target} ${property} = ${value}") + endif() + endforeach() +endfunction() diff --git a/cmake/modules/GRASSInstallDirs.cmake b/cmake/modules/GRASSInstallDirs.cmake new file mode 100644 index 00000000000..bd8f1eb142e --- /dev/null +++ b/cmake/modules/GRASSInstallDirs.cmake @@ -0,0 +1,116 @@ +include(GNUInstallDirs) + +if(WITH_FHS) + message("FHS file structure") + set(GISBASE_DIR "${CMAKE_INSTALL_LIBEXECDIR}/${PROJECT_NAME_LOWER}") + set(GRASS_INSTALL_BINDIR "${GISBASE_DIR}/bin") + set(GRASS_INSTALL_LIBDIR "${CMAKE_INSTALL_LIBDIR}") + set(GRASS_INSTALL_SCRIPTDIR "${GISBASE_DIR}/bin") + set(GRASS_INSTALL_SHAREDIR + "${CMAKE_INSTALL_DATAROOTDIR}/${PROJECT_NAME_LOWER}") + set(GRASS_INSTALL_ETCDIR "${GRASS_INSTALL_SHAREDIR}/etc") + set(GRASS_INSTALL_ETCBINDIR "${GISBASE_DIR}/etc") + set(GRASS_INSTALL_PYDIR "${PYTHON_SITEARCH}") + set(GRASS_INSTALL_GUIDIR "${GRASS_INSTALL_PYDIR}/${PROJECT_NAME_LOWER}/gui") + set(GRASS_INSTALL_GUISCRIPTDIR "${GRASS_INSTALL_SCRIPTDIR}") + set(GRASS_INSTALL_DRIVERDIR "${GISBASE_DIR}/driver") + set(GRASS_INSTALL_FONTSDIR "${GRASS_INSTALL_SHAREDIR}/fonts") + set(GRASS_INSTALL_UTILSDIR "${GISBASE_DIR}/utils") + set(GRASS_INSTALL_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}") + set(GRASS_INSTALL_DOCDIR + "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME_LOWER}-doc") + set(GRASS_INSTALL_DEVDOCDIR + "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME_LOWER}-dev-doc") + set(GRASS_INSTALL_MANDIR "${CMAKE_INSTALL_MANDIR}") + set(GRASS_INSTALL_MKDOCSDIR + "${CMAKE_INSTALL_DATAROOTDIR}/doc/${PROJECT_NAME_LOWER}-mkdocs") + set(GRASS_INSTALL_DEMODIR "${GRASS_INSTALL_SHAREDIR}/demolocation") + set(GRASS_INSTALL_MISCDIR "${GRASS_INSTALL_SHAREDIR}") + set(GRASS_INSTALL_MAKEFILEDIR "${GISBASE_DIR}/Make") + set(GRASS_INSTALL_LOCALEDIR "${CMAKE_INSTALL_LOCALEDIR}") +else() + message("Legacy file structure") + set(GISBASE_DIR "${CMAKE_INSTALL_LIBDIR}/grass${GRASS_VERSION_MAJOR}${GRASS_VERSION_MINOR}") + set(GRASS_INSTALL_BINDIR "${GISBASE_DIR}/bin") + set(GRASS_INSTALL_LIBDIR "${GISBASE_DIR}/lib") + set(GRASS_INSTALL_SCRIPTDIR "${GISBASE_DIR}/scripts") + set(GRASS_INSTALL_SHAREDIR "${GISBASE_DIR}/share") + set(GRASS_INSTALL_ETCDIR "${GISBASE_DIR}/etc") + set(GRASS_INSTALL_ETCBINDIR "${GISBASE_DIR}/etc") + set(GRASS_INSTALL_PYDIR "${GISBASE_DIR}/etc/python") + set(GRASS_INSTALL_GUIDIR "${GISBASE_DIR}/gui") + set(GRASS_INSTALL_GUISCRIPTDIR "${GRASS_INSTALL_GUIDIR}/script") + set(GRASS_INSTALL_DRIVERDIR "${GISBASE_DIR}/driver") + set(GRASS_INSTALL_FONTSDIR "${GISBASE_DIR}/fonts") + set(GRASS_INSTALL_UTILSDIR "${GISBASE_DIR}/utils") + set(GRASS_INSTALL_INCLUDEDIR "${GISBASE_DIR}/include") + set(GRASS_INSTALL_DOCDIR "${GISBASE_DIR}/docs/html") + set(GRASS_INSTALL_DEVDOCDIR "${GISBASE_DIR}/html") + set(GRASS_INSTALL_MANDIR "${GISBASE_DIR}/docs/man") + set(GRASS_INSTALL_MKDOCSDIR "${GISBASE_DIR}/docs/mkdocs") + set(GRASS_INSTALL_DEMODIR "${GISBASE_DIR}/demolocation") + set(GRASS_INSTALL_MISCDIR "${GISBASE_DIR}") + set(GRASS_INSTALL_MAKEFILEDIR "${GISBASE_DIR}/Make") + set(GRASS_INSTALL_LOCALEDIR "${GISBASE_DIR}/locale") +endif() + +message(STATUS "GISBASE_DIR ${GISBASE_DIR}") +message(STATUS "GRASS_INSTALL_BINDIR ${GRASS_INSTALL_BINDIR}") +message(STATUS "GRASS_INSTALL_LIBDIR ${GRASS_INSTALL_LIBDIR}") +message(STATUS "GRASS_INSTALL_SCRIPTDIR ${GRASS_INSTALL_SCRIPTDIR}") +message(STATUS "GRASS_INSTALL_SHAREDIR ${GRASS_INSTALL_SHAREDIR}") +message(STATUS "GRASS_INSTALL_ETCDIR ${GRASS_INSTALL_ETCDIR}") +message(STATUS "GRASS_INSTALL_ETCBINDIR ${GRASS_INSTALL_ETCBINDIR}") +message(STATUS "GRASS_INSTALL_PYDIR ${GRASS_INSTALL_PYDIR}") +message(STATUS "GRASS_INSTALL_GUIDIR ${GRASS_INSTALL_GUIDIR}") +message(STATUS "GRASS_INSTALL_GUISCRIPTDIR ${GRASS_INSTALL_GUISCRIPTDIR}") +message(STATUS "GRASS_INSTALL_DRIVERDIR ${GRASS_INSTALL_DRIVERDIR}") +message(STATUS "GRASS_INSTALL_FONTSDIR ${GRASS_INSTALL_FONTSDIR}") +message(STATUS "GRASS_INSTALL_UTILSDIR ${GRASS_INSTALL_UTILSDIR}") +message(STATUS "GRASS_INSTALL_INCLUDEDIR ${GRASS_INSTALL_INCLUDEDIR}") +message(STATUS "GRASS_INSTALL_DOCDIR ${GRASS_INSTALL_DOCDIR}") +message(STATUS "GRASS_INSTALL_DEVDOCDIR ${GRASS_INSTALL_DEVDOCDIR}") +message(STATUS "GRASS_INSTALL_MANDIR ${GRASS_INSTALL_MANDIR}") +message(STATUS "GRASS_INSTALL_MKDOCSDIR ${GRASS_INSTALL_MKDOCSDIR}") +message(STATUS "GRASS_INSTALL_DEMODIR ${GRASS_INSTALL_DEMODIR}") +message(STATUS "GRASS_INSTALL_MISCDIR ${GRASS_INSTALL_MISCDIR}") +message(STATUS "GRASS_INSTALL_MAKEFILEDIR ${GRASS_INSTALL_MAKEFILEDIR}") +message(STATUS "GRASS_INSTALL_LOCALEDIR ${GRASS_INSTALL_LOCALEDIR}") + +set(OUTDIR "${CMAKE_BINARY_DIR}/output") +set(GISBASE ${CMAKE_INSTALL_PREFIX}/${GISBASE_DIR}) +set(RUNTIME_GISBASE "${OUTDIR}/${GISBASE_DIR}") + +file(TO_NATIVE_PATH "${CMAKE_SOURCE_DIR}" MODULE_TOPDIR) +file(TO_NATIVE_PATH "${RUNTIME_GISBASE}" RUN_GISBASE_NATIVE) +file(TO_NATIVE_PATH "${OUTDIR}/${GRASS_INSTALL_BINDIR}" BIN_DIR) +file(TO_NATIVE_PATH "${OUTDIR}/${GRASS_INSTALL_LIBDIR}" LIB_DIR) +file(TO_NATIVE_PATH "${OUTDIR}/${GRASS_INSTALL_SCRIPTDIR}" SCRIPTS_DIR) +file(TO_NATIVE_PATH "${OUTDIR}/${GRASS_INSTALL_DOCDIR}" DOC_DIR) +file( + TO_NATIVE_PATH + "${OUTDIR}/${GRASS_INSTALL_DEMODIR}/.grassrc${GRASS_VERSION_MAJOR}${GRASS_VERSION_MINOR}" + GISRC) +file(TO_NATIVE_PATH "${OUTDIR}/${GRASS_INSTALL_PYDIR}" ETC_PYTHON_DIR) +file(TO_NATIVE_PATH "${OUTDIR}/${GRASS_INSTALL_GUIDIR}/wxpython" + GUI_WXPYTHON_DIR) +message("GISBASE ${GISBASE}") +message("GISBASE_NATIVE ${RUN_GISBASE_NATIVE}") + +message("Creating directories in ${GISBASE}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_BINDIR}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_SCRIPTDIR}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_SHAREDIR}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_DEMODIR}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_DRIVERDIR}/db") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_UTILSDIR}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_LIBDIR}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_PYDIR}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_ETCBINDIR}/lister") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_PYDIR}/grass/lib") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_GUIDIR}/wxpython/xml") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_GUIDIR}/images") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_DOCDIR}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_MANDIR}") +file(MAKE_DIRECTORY "${OUTDIR}/${GRASS_INSTALL_MKDOCSDIR}/source") diff --git a/cmake/modules/build_gui_in_subdir.cmake b/cmake/modules/build_gui_in_subdir.cmake new file mode 100644 index 00000000000..524ba99ecf9 --- /dev/null +++ b/cmake/modules/build_gui_in_subdir.cmake @@ -0,0 +1,135 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: build_gui_in_subdir is the cmake function that builds g.gui.* modules +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +function(build_gui_in_subdir dir_name) + set(G_NAME ${dir_name}) + set(G_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${G_NAME}) + set(G_TARGET_NAME g.gui.${G_NAME}) + + set(HTML_FILE_NAME ${G_TARGET_NAME}) + + file(GLOB PYTHON_FILES "${G_SRC_DIR}/*.py") + if(NOT PYTHON_FILES) + message(FATAL_ERROR "[${G_TARGET_NAME}]: No PYTHON_FILES found.") + endif() + + set(SRC_SCRIPT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/${G_NAME}/${G_TARGET_NAME}.py) + + if(NOT EXISTS ${SRC_SCRIPT_FILE}) + message(FATAL_ERROR "${SRC_SCRIPT_FILE} does not exists") + endif() + + set(SCRIPT_EXT "") + if(WIN32) + set(SCRIPT_EXT ".py") + set(PGM_NAME ${G_TARGET_NAME}) + configure_file(${CMAKE_SOURCE_DIR}/cmake/windows_launch.bat.in + ${OUTDIR}/${GRASS_INSTALL_SCRIPTDIR}/${G_TARGET_NAME}.bat @ONLY) + endif() + set(GUI_STAMP_FILE ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${G_NAME}.stamp) + + add_custom_command( + OUTPUT ${GUI_STAMP_FILE} + COMMAND ${CMAKE_COMMAND} -E make_directory + "${OUTDIR}/${GRASS_INSTALL_GUIDIR}/wxpython/${G_NAME}" + COMMAND ${CMAKE_COMMAND} -E copy_if_different ${PYTHON_FILES} + "${OUTDIR}/${GRASS_INSTALL_GUIDIR}/wxpython/${G_NAME}" + COMMAND ${CMAKE_COMMAND} -E touch ${GUI_STAMP_FILE}) + + set(OUT_SCRIPT_FILE + "${OUTDIR}/${GRASS_INSTALL_SCRIPTDIR}/${G_TARGET_NAME}${SCRIPT_EXT}") + + if(UNIX) + add_custom_command( + OUTPUT ${OUT_SCRIPT_FILE} + COMMAND ${CMAKE_COMMAND} -E copy ${SRC_SCRIPT_FILE} ${OUT_SCRIPT_FILE} + COMMAND /bin/chmod 755 ${OUT_SCRIPT_FILE} + DEPENDS g.parser ${SRC_SCRIPT_FILE}) + else() + add_custom_command( + OUTPUT ${OUT_SCRIPT_FILE} + COMMAND ${CMAKE_COMMAND} -E copy ${SRC_SCRIPT_FILE} ${OUT_SCRIPT_FILE} + DEPENDS g.parser ${SRC_SCRIPT_FILE}) + endif() + + if(WITH_DOCS) + + file(GLOB IMG_FILES ${G_SRC_DIR}/*.png ${G_SRC_DIR}/*.jpg) + if(IMG_FILES) + set(copy_images_command ${CMAKE_COMMAND} -E copy ${IMG_FILES} + "${OUTDIR}/${GRASS_INSTALL_DOCDIR}") + install(FILES ${IMG_FILES} DESTINATION ${GRASS_INSTALL_DOCDIR}) + endif() + + set(HTML_FILE ${G_SRC_DIR}/${G_TARGET_NAME}.html) + if(EXISTS ${HTML_FILE}) + install(FILES ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${G_TARGET_NAME}.html + DESTINATION ${GRASS_INSTALL_DOCDIR}) + else() + set(HTML_FILE) + file(GLOB html_files ${G_SRC_DIR}/*.html) + if(html_files) + message( + FATAL_ERROR + "${html_file} does not exists. ${G_SRC_DIR} \n ${RUNTIME_GISBASE}/scripts| ${G_TARGET_NAME}" + ) + endif() + endif() + + set(TMP_HTML_FILE + ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${G_TARGET_NAME}.tmp.html) + set(OUT_HTML_FILE ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${G_TARGET_NAME}.html) + set(GUI_HTML_FILE ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/wxGUI.${G_NAME}.html) + + + add_custom_command( + OUTPUT ${OUT_HTML_FILE} + COMMAND ${CMAKE_COMMAND} -E copy ${G_SRC_DIR}/${G_TARGET_NAME}.html + ${CMAKE_CURRENT_BINARY_DIR}/${G_TARGET_NAME}.html + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${OUTDIR}/${GRASS_INSTALL_SCRIPTDIR}/${G_TARGET_NAME}${SCRIPT_EXT} + --html-description < ${NULL_DEVICE} | ${SEARCH_COMMAND} + ${HTML_SEARCH_STR} > ${TMP_HTML_FILE} + COMMAND ${grass_env_command} ${PYTHON_EXECUTABLE} ${MKHTML_PY} + ${G_TARGET_NAME} ${GRASS_VERSION_DATE} > ${OUT_HTML_FILE} + COMMENT "Creating ${OUT_HTML_FILE}" + COMMAND ${copy_images_command} + COMMAND ${CMAKE_COMMAND} -E remove ${TMP_HTML_FILE} + ${CMAKE_CURRENT_BINARY_DIR}/${G_TARGET_NAME}.html + COMMAND ${grass_env_command} ${PYTHON_EXECUTABLE} ${MKHTML_PY} + ${G_TARGET_NAME} ${GRASS_VERSION_DATE} > ${GUI_HTML_FILE} + COMMENT "Creating ${GUI_HTML_FILE}" + DEPENDS ${OUT_SCRIPT_FILE} GUI_WXPYTHON LIB_PYTHON) + + + install(FILES ${OUT_HTML_FILE} ${GUI_HTML_FILE} + DESTINATION ${GRASS_INSTALL_DOCDIR}) + + endif() # WITH_DOCS + + add_custom_target( + ${G_TARGET_NAME} DEPENDS ${GUI_STAMP_FILE} ${OUT_SCRIPT_FILE} + ${OUT_HTML_FILE}) + + set(modules_list + "${G_TARGET_NAME};${modules_list}" + CACHE INTERNAL "list of modules") + + set_target_properties(${G_TARGET_NAME} PROPERTIES FOLDER gui) + + if(WIN32) + install(PROGRAMS ${OUTDIR}/${GRASS_INSTALL_SCRIPTDIR}/${G_TARGET_NAME}.bat + DESTINATION ${GRASS_INSTALL_SCRIPTDIR}) + endif() + + install( + PROGRAMS ${OUTDIR}/${GRASS_INSTALL_SCRIPTDIR}/${G_TARGET_NAME}${SCRIPT_EXT} + DESTINATION ${GRASS_INSTALL_SCRIPTDIR}) + +endfunction() diff --git a/cmake/modules/build_library_in_subdir.cmake b/cmake/modules/build_library_in_subdir.cmake new file mode 100644 index 00000000000..4ac3869efe0 --- /dev/null +++ b/cmake/modules/build_library_in_subdir.cmake @@ -0,0 +1,19 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: This is the macro to make grass libraries through build_module function. +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +macro(build_library_in_subdir dir_name) + set(extra_args ${ARGN}) + if("NAME" IN_LIST extra_args) + build_module(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${dir_name} ${ARGN}) + else() + get_filename_component(g_name ${dir_name} NAME) + # message("dir_name=${dir_name} |g_name= ${g_name}") + build_module(NAME grass_${g_name} SRC_DIR + ${CMAKE_CURRENT_SOURCE_DIR}/${dir_name} ${ARGN}) + endif() +endmacro() diff --git a/cmake/modules/build_module.cmake b/cmake/modules/build_module.cmake new file mode 100644 index 00000000000..90ab758a615 --- /dev/null +++ b/cmake/modules/build_module.cmake @@ -0,0 +1,294 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: This is the main function that builds all grass libraries (prefixed with grass_) + and grass exeuctables. This cmake function is tailored to meet requirement of grass + gnu make rules +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +include(GenerateExportHeader) +function(build_module) + cmake_parse_arguments( + G + "EXE;NO_DOCS" + "NAME;SRC_DIR;SRC_REGEX;RUNTIME_OUTPUT_DIR;PACKAGE;HTML_FILE_NAME" + "SOURCES;INCLUDES;DEPENDS;OPTIONAL_DEPENDS;PRIMARY_DEPENDS;DEFS;HEADERS;TEST_SOURCES" + ${ARGN}) + + if(NOT G_NAME) + message(FATAL_ERROR "G_NAME empty") + endif() + + foreach(PRIMARY_DEPEND ${G_PRIMARY_DEPENDS}) + if(NOT TARGET ${PRIMARY_DEPEND}) + message( + STATUS "${G_NAME} disabled because ${PRIMARY_DEPEND} is not available") + return() + else() + list(APPEND G_DEPENDS ${PRIMARY_DEPEND}) + endif() + endforeach() + + if(NOT G_SRC_REGEX) + set(G_SRC_REGEX "*.c") + endif() + + if(NOT G_SRC_DIR) + set(G_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}) + endif() + set(html_file "${G_SRC_DIR}/${G_NAME}.html") + + foreach(G_HEADER ${G_HEADERS}) + if(EXISTS "${G_SRC_DIR}/${G_HEADER}") + file(COPY ${G_SRC_DIR}/${G_HEADER} + DESTINATION "${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass") + else() + file( + GLOB header_list_from_glob + LIST_DIRECTORIES false + "${G_SRC_DIR}/${G_HEADER}") + if(NOT header_list_from_glob) + message( + FATAL_ERROR + "MUST copy '${G_SRC_DIR}/${G_HEADER}' to ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass" + ) + endif() + foreach(header_I ${header_list_from_glob}) + file(COPY ${header_I} + DESTINATION "${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass") + endforeach() + endif() + endforeach() + + if(NOT G_SOURCES) + file(GLOB ${G_NAME}_SRCS "${G_SRC_DIR}/${G_SRC_REGEX}") + else() + set(${G_NAME}_SRCS ${G_SOURCES}) + endif() + + set(RUN_HTML_DESCR TRUE) + # Auto set if to run RUN_HTML_DESCR + if(G_EXE) + set(RUN_HTML_DESCR TRUE) + if(G_RUNTIME_OUTPUT_DIR) + set(RUN_HTML_DESCR FALSE) + endif() + # g.parser and some others does not have --html-description. + if(${G_NAME} IN_LIST NO_HTML_DESCR_TARGETS) + set(RUN_HTML_DESCR FALSE) + endif() + else() + set(RUN_HTML_DESCR FALSE) + endif() + + set(install_dest "") + if(NOT G_RUNTIME_OUTPUT_DIR) + if(G_EXE) + set(G_RUNTIME_OUTPUT_DIR "${OUTDIR}/${GRASS_INSTALL_BINDIR}") + set(install_dest "${GRASS_INSTALL_BINDIR}") + else() + set(G_RUNTIME_OUTPUT_DIR "${OUTDIR}/${GRASS_INSTALL_LIBDIR}") + set(install_dest "${GRASS_INSTALL_LIBDIR}") + endif() + else() + set(install_dest "${G_RUNTIME_OUTPUT_DIR}") + set(G_RUNTIME_OUTPUT_DIR "${OUTDIR}/${install_dest}") + endif() + + if(MSVC) + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${CMAKE_BUILD_TYPE} ${G_RUNTIME_OUTPUT_DIR}) + elseif(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${G_RUNTIME_OUTPUT_DIR}) + endif() + + if(G_EXE) + add_executable(${G_NAME} ${${G_NAME}_SRCS}) + if("${G_NAME}" MATCHES "^v.*") + set_target_properties(${G_NAME} PROPERTIES FOLDER vector) + elseif("${G_NAME}" MATCHES "^r.*") + set_target_properties(${G_NAME} PROPERTIES FOLDER raster) + else() + set_target_properties(${G_NAME} PROPERTIES FOLDER bin) + endif() + set(default_html_file_name ${G_NAME}) + set(PGM_NAME ${G_NAME}) + if(WIN32) + set(PGM_NAME ${G_NAME}.exe) + endif() + + set(modules_list + "${G_NAME};${modules_list}" + CACHE INTERNAL "list of modules") + + else() + add_library(${G_NAME} ${${G_NAME}_SRCS}) + set_target_properties( + ${G_NAME} + PROPERTIES FOLDER lib + VERSION ${GRASS_VERSION_NUMBER} + SOVERSION ${GRASS_VERSION_MAJOR}) + + # TODO: check when and where the export header files are needed + set(export_file_name + "${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/export/${G_NAME}_export.h") + # Default is to use library target name without grass_ prefix + string(REPLACE "grass_" "" default_html_file_name ${G_NAME}) + set(PGM_NAME ${default_html_file_name}) + + generate_export_header(${G_NAME} STATIC_DEFINE "STATIC_BUILD" + EXPORT_FILE_NAME ${export_file_name}) + endif() + + if(G_HTML_FILE_NAME) + set(HTML_FILE_NAME ${G_HTML_FILE_NAME}) + else() + set(HTML_FILE_NAME ${default_html_file_name}) + endif() + + get_property(MODULE_LIST GLOBAL PROPERTY MODULE_LIST) + set_property(GLOBAL PROPERTY MODULE_LIST "${MODULE_LIST};${G_NAME}") + + add_dependencies(${G_NAME} copy_header) + + foreach(G_OPTIONAL_DEPEND ${G_OPTIONAL_DEPENDS}) + if(TARGET ${G_OPTIONAL_DEPEND}) + add_dependencies(${G_NAME} ${G_OPTIONAL_DEPEND}) + endif() + endforeach() + foreach(G_DEPEND ${G_DEPENDS}) + if(NOT TARGET ${G_DEPEND}) + message(FATAL_ERROR "${G_DEPEND} not a target") + break() + endif() + + add_dependencies(${G_NAME} ${G_DEPEND}) + + set(${G_NAME}_INCLUDE_DIRS) + list(APPEND ${G_NAME}_INCLUDE_DIRS "${G_SRC_DIR}") + foreach(G_INCLUDE ${G_INCLUDES}) + list(APPEND ${G_NAME}_INCLUDE_DIRS "${G_INCLUDE}") + endforeach() + + if(${G_NAME}_INCLUDE_DIRS) + list(REMOVE_DUPLICATES ${G_NAME}_INCLUDE_DIRS) + endif() + + target_include_directories(${G_NAME} PUBLIC ${${G_NAME}_INCLUDE_DIRS}) + endforeach() + + foreach(G_DEF ${G_DEFS}) + target_compile_definitions(${G_NAME} PUBLIC "${G_DEF}") + endforeach() + + set(package_define) + if(NOT G_PACKAGE) + if(G_EXE) + set(package_define "grassmods") + else() + set(package_define "grasslibs") + endif() + else() + if(NOT G_PACKAGE STREQUAL "NONE") + set(package_define ${G_PACKAGE}) + endif() + endif() + + target_compile_definitions(${G_NAME} + PRIVATE "-DPACKAGE=\"${package_define}\"") + + foreach(dep ${G_DEPENDS} ${G_OPTIONAL_DEPENDS}) + if(TARGET ${dep}) + get_target_property(interface_def ${dep} INTERFACE_COMPILE_DEFINITIONS) + if(interface_def) + target_compile_definitions(${G_NAME} PRIVATE "${interface_def}") + endif() + target_link_libraries(${G_NAME} PRIVATE ${dep}) + elseif(OpenMP_C_FOUND) + target_link_libraries(${G_NAME} PRIVATE OpenMP::OpenMP_C) + endif() + endforeach() + + # To use this property later in build_docs + set(PGM_EXT "") + if(WIN32) + if(G_EXE) + set(PGM_EXT ".exe") + endif() + endif() + + set(G_HTML_FILE_NAME "${HTML_FILE_NAME}.html") + set(html_file_search ${G_SRC_DIR}/${G_HTML_FILE_NAME}) + if(NOT G_NO_DOCS AND NOT EXISTS ${html_file_search}) + set(G_NO_DOCS YES) + endif() + + if(WITH_DOCS AND NOT G_NO_DOCS) + set(HTML_FILE) + if(EXISTS ${html_file_search}) + set(HTML_FILE ${html_file_search}) + install(FILES ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${G_HTML_FILE_NAME} + DESTINATION ${GRASS_INSTALL_DOCDIR}) + endif() + + if(NOT HTML_FILE) + return() + endif() + + get_filename_component(HTML_FILE_NAME ${HTML_FILE} NAME) + get_filename_component(PGM_SOURCE_DIR ${HTML_FILE} PATH) + + string(REPLACE ".html" "" PGM_NAME "${HTML_FILE_NAME}") + string(REPLACE ".html" ".tmp.html" TMP_HTML_NAME ${HTML_FILE_NAME}) + set(TMP_HTML_FILE ${CMAKE_CURRENT_BINARY_DIR}/${TMP_HTML_NAME}) + set(OUT_HTML_FILE ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${HTML_FILE_NAME}) + + set(PGM_EXT "") + if(WIN32) + set(PGM_EXT ".exe") + endif() + + if(RUN_HTML_DESCR) + set(html_descr_command + ${G_NAME}${PGM_EXT} --html-description < ${NULL_DEVICE} | ${SEARCH_COMMAND} + ${HTML_SEARCH_STR}) + else() + set(html_descr_command ${CMAKE_COMMAND} -E echo) + endif() + + file( + GLOB IMG_FILES + LIST_DIRECTORIES FALSE + ${G_SRC_DIR}/*.png ${G_SRC_DIR}/*.jpg) + if(IMG_FILES) + set(copy_images_command ${CMAKE_COMMAND} -E copy ${IMG_FILES} + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}) + install(FILES ${IMG_FILES} DESTINATION ${GRASS_INSTALL_DOCDIR}) + endif() + + add_custom_command( + TARGET ${G_NAME} + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${G_SRC_DIR}/${G_HTML_FILE_NAME} + ${CMAKE_CURRENT_BINARY_DIR}/${G_HTML_FILE_NAME} + COMMAND ${grass_env_command} ${html_descr_command} > ${TMP_HTML_FILE} + COMMAND ${grass_env_command} ${PYTHON_EXECUTABLE} ${MKHTML_PY} ${PGM_NAME} + > ${OUT_HTML_FILE} + COMMAND ${copy_images_command} + COMMAND ${CMAKE_COMMAND} -E remove ${TMP_HTML_FILE} + ${CMAKE_CURRENT_BINARY_DIR}/${G_HTML_FILE_NAME} + COMMENT "Creating ${OUT_HTML_FILE}") + install(FILES ${OUT_HTML_FILE} DESTINATION ${GRASS_INSTALL_DOCDIR}) + endif() # WITH_DOCS + + foreach(test_SOURCE ${G_TEST_SOURCES}) + add_test(NAME ${G_NAME}-test + COMMAND ${grass_env_command} ${PYTHON_EXECUTABLE} + ${G_SRC_DIR}/testsuite/${test_SOURCE}) + message("[build_module] ADDING TEST ${G_NAME}-test") + endforeach() + + install(TARGETS ${G_NAME} DESTINATION ${install_dest}) + +endfunction() diff --git a/cmake/modules/build_program.cmake b/cmake/modules/build_program.cmake new file mode 100644 index 00000000000..f4301fc135c --- /dev/null +++ b/cmake/modules/build_program.cmake @@ -0,0 +1,11 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: Shortcut macro to call build_module with EXE argument set +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +macro(build_program) + build_module(${ARGN} EXE) +endmacro() diff --git a/cmake/modules/build_program_in_subdir.cmake b/cmake/modules/build_program_in_subdir.cmake new file mode 100644 index 00000000000..f2c78f258b9 --- /dev/null +++ b/cmake/modules/build_program_in_subdir.cmake @@ -0,0 +1,20 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: CMake macro to build a grass executable (program) under sub directory + which is passed as argument to macro +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +macro(build_program_in_subdir dir_name) + set(extra_args ${ARGN}) + if("NAME" IN_LIST extra_args) + # message("dir_name=${dir_name} ${extra_args}") + build_program(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${dir_name} ${ARGN}) + else() + get_filename_component(pgm_name ${dir_name} NAME) + build_program(NAME ${pgm_name} SRC_DIR + ${CMAKE_CURRENT_SOURCE_DIR}/${dir_name} ${ARGN}) + endif() +endmacro() diff --git a/cmake/modules/build_script_in_subdir.cmake b/cmake/modules/build_script_in_subdir.cmake new file mode 100644 index 00000000000..579ffa38cc1 --- /dev/null +++ b/cmake/modules/build_script_in_subdir.cmake @@ -0,0 +1,148 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: A CMake function that builds grass python script modules +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +function(build_script_in_subdir dir_name) + + cmake_parse_arguments( + G + "PLAIN_PY;NO_DOCS" + "DEST_DIR" + "" + ${ARGN}) + + if(NOT G_DEST_DIR) + set(G_DEST_DIR ${GRASS_INSTALL_SCRIPTDIR}) + endif() + + set(G_NAME ${dir_name}) + + if(G_PLAIN_PY) + set(G_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}) + else() + set(G_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${G_NAME}) + endif() + + file(GLOB PYTHON_FILES "${G_SRC_DIR}/*.py") + if(NOT PYTHON_FILES) + message(FATAL_ERROR "[${G_NAME}]: No PYTHON_FILES found.") + endif() + + set(SRC_SCRIPT_FILE ${G_SRC_DIR}/${G_NAME}.py) + + if(NOT EXISTS ${SRC_SCRIPT_FILE}) + message(FATAL_ERROR "${SRC_SCRIPT_FILE} does not exists") + return() + endif() + + set(SCRIPT_EXT "") + if(WIN32) + set(SCRIPT_EXT ".py") + endif() + + set(HTML_FILE ${G_SRC_DIR}/${G_NAME}.html) + + configure_file( + ${G_SRC_DIR}/${G_NAME}.py + ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${G_NAME}${SCRIPT_EXT} COPYONLY) + file( + COPY ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${G_NAME}${SCRIPT_EXT} + DESTINATION ${OUTDIR}/${G_DEST_DIR} + FILE_PERMISSIONS + OWNER_READ + OWNER_WRITE + OWNER_EXECUTE + GROUP_READ + GROUP_EXECUTE + WORLD_READ + WORLD_EXECUTE) + + set(TRANSLATE_C_FILE + ${CMAKE_SOURCE_DIR}/locale/scriptstrings/${G_NAME}_to_translate.c) + + add_custom_command( + OUTPUT ${TRANSLATE_C_FILE} + COMMAND + ${CMAKE_COMMAND} -DG_NAME=${G_NAME} -DSOURCE_DIR=${CMAKE_SOURCE_DIR} + -DOUTPUT_FILE=${TRANSLATE_C_FILE} -DGISBASE_DIR="${RUNTIME_GISBASE}" + -DBINARY_DIR="${OUTDIR}/${GRASS_INSTALL_BINDIR}" + -DLIBDIR="${OUTDIR}/${GRASS_INSTALL_LIBDIR}" + -DSCRIPTDIR="${OUTDIR}/${G_DEST_DIR}" + -DETCDIR="${OUTDIR}/${GRASS_INSTALL_ETCDIR}" + -DPYDIR="${OUTDIR}/${GRASS_INSTALL_PYDIR}" -DGISRC="${GISRC}" + -DGUIDIR="${OUTDIR}/${GRASS_INSTALL_GUIDIR}" -P + ${CMAKE_SOURCE_DIR}/cmake/locale_strings.cmake + DEPENDS g.parser) + + set(HTML_FILE_NAME ${G_NAME}) + set(OUT_HTML_FILE "") + + if(WITH_DOCS AND NOT G_NO_DOCS) + + file(GLOB IMG_FILES ${G_SRC_DIR}/*.png ${G_SRC_DIR}/*.jpg) + if(IMG_FILES) + set(copy_images_command ${CMAKE_COMMAND} -E copy ${IMG_FILES} + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}) + install(FILES ${IMG_FILES} DESTINATION ${GRASS_INSTALL_DOCDIR}) + endif() + + set(HTML_FILE ${G_SRC_DIR}/${G_NAME}.html) + if(EXISTS ${HTML_FILE}) + install(FILES ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${G_NAME}.html + DESTINATION ${GRASS_INSTALL_DOCDIR}) + else() + set(HTML_FILE) + file(GLOB html_files ${G_SRC_DIR}/*.html) + if(html_files) + message( + FATAL_ERROR + "${html_file} does not exists. ${G_SRC_DIR} \n ${OUTDIR}/${G_DEST_DIR}| ${G_NAME}" + ) + endif() + endif() + + set(TMP_HTML_FILE ${CMAKE_CURRENT_BINARY_DIR}/${G_NAME}.tmp.html) + set(OUT_HTML_FILE ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${G_NAME}.html) + + add_custom_command( + OUTPUT ${OUT_HTML_FILE} + COMMAND ${CMAKE_COMMAND} -E copy ${G_SRC_DIR}/${G_NAME}.html + ${CMAKE_CURRENT_BINARY_DIR}/${G_NAME}.html + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${OUTDIR}/${G_DEST_DIR}/${G_NAME}${SCRIPT_EXT} + --html-description < ${NULL_DEVICE} | ${SEARCH_COMMAND} + ${HTML_SEARCH_STR} > ${TMP_HTML_FILE} + COMMAND ${grass_env_command} ${PYTHON_EXECUTABLE} ${MKHTML_PY} ${G_NAME} > + ${OUT_HTML_FILE} + COMMAND ${copy_images_command} + COMMAND ${CMAKE_COMMAND} -E remove ${TMP_HTML_FILE} + ${CMAKE_CURRENT_BINARY_DIR}/${G_NAME}.html + COMMENT "Creating ${OUT_HTML_FILE}" + DEPENDS ${TRANSLATE_C_FILE} LIB_PYTHON) + + install(FILES ${OUT_HTML_FILE} DESTINATION ${GRASS_INSTALL_DOCDIR}) + + endif() # WITH_DOCS + + add_custom_target(${G_NAME} DEPENDS ${TRANSLATE_C_FILE} ${OUT_HTML_FILE}) + + set(modules_list + "${G_NAME};${modules_list}" + CACHE INTERNAL "list of modules") + + set_target_properties(${G_NAME} PROPERTIES FOLDER scripts) + + if(WIN32) + install(PROGRAMS ${OUTDIR}/${G_DEST_DIR}/${G_NAME}.bat + DESTINATION ${G_DEST_DIR}) + endif() + + install(PROGRAMS ${OUTDIR}/${G_DEST_DIR}/${G_NAME}${SCRIPT_EXT} + DESTINATION ${G_DEST_DIR}) + +endfunction() diff --git a/cmake/modules/check_target.cmake b/cmake/modules/check_target.cmake new file mode 100644 index 00000000000..1d03d29382f --- /dev/null +++ b/cmake/modules/check_target.cmake @@ -0,0 +1,8 @@ +macro(check_target target_name have_define_var) + set(${have_define_var} 0) + if(TARGET ${target_name}) + # message(STATUS "${target_name} package found. Setting ${have_define_var} + # to 1") + set(${have_define_var} 1) + endif() +endmacro() diff --git a/cmake/modules/copy_python_files_in_subdir.cmake b/cmake/modules/copy_python_files_in_subdir.cmake new file mode 100644 index 00000000000..be477f6066c --- /dev/null +++ b/cmake/modules/copy_python_files_in_subdir.cmake @@ -0,0 +1,48 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: Simply copy python file in given subdirectory + Destination will be relative to GISBASE directory set in root + CMakeLists.txt +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +function(copy_python_files_in_subdir dir_name dst_prefix) + cmake_parse_arguments(G "PRE_BUILD;PRE_LINK;POST_BUILD" "TARGET" "" ${ARGN}) + + file(GLOB PY_FILES "${CMAKE_CURRENT_SOURCE_DIR}/${dir_name}/*.py") + + if(DEFINED G_TARGET) + if(${G_PRE_BUILD}) + set(BUILD PRE_BUILD) + elseif(${G_PRE_LINK}) + set(BUILD PRE_LINK) + else() + set(BUILD POST_BUILD) + endif() + add_custom_command( + TARGET ${G_TARGET} + ${BUILD} + COMMAND ${CMAKE_COMMAND} -E make_directory + "${OUTDIR}/${dst_prefix}/${dir_name}" + COMMAND ${CMAKE_COMMAND} -E copy ${PY_FILES} + "${OUTDIR}/${dst_prefix}/${dir_name}") + set(py_files_out) + foreach(pyfile ${PY_FILES}) + get_filename_component(py_file_name ${pyfile} NAME) + list(APPEND py_files_out + "${OUTDIR}/${dst_prefix}/${dir_name}/${py_file_name}") + endforeach() + install(PROGRAMS ${py_files_out} DESTINATION ${dst_prefix}/${dir_name}) + else() + string(REPLACE "/" "_" targ_name ${dir_name}) + add_custom_target( + python_${targ_name} + COMMAND ${CMAKE_COMMAND} -E make_directory + "${OUTDIR}/${dst_prefix}/${dir_name}" + COMMAND ${CMAKE_COMMAND} -E copy ${PY_FILES} + "${OUTDIR}/${dst_prefix}/${dir_name}") + set_target_properties(python_${targ_name} PROPERTIES FOLDER lib/python) + endif() +endfunction() diff --git a/cmake/modules/generate_html.cmake b/cmake/modules/generate_html.cmake new file mode 100644 index 00000000000..b951164666a --- /dev/null +++ b/cmake/modules/generate_html.cmake @@ -0,0 +1,41 @@ +macro(generate_html) + cmake_parse_arguments(PGM "IMG_NOT" "NAME;SOURCEDIR;TARGET" "" ${ARGN}) + + if(NOT PGM_NAME) + message(FATAL_ERROR "NAME in not set") + endif() + + if(NOT PGM_TARGET) + message(FATAL_ERROR "TARGET in not set") + endif() + + if(NOT PGM_SOURCEDIR) + set(PGM_SOURCEDIR ${CMAKE_CURRENT_SOURCE_DIR}) + endif() + + set(PGM_SOURCE ${PGM_SOURCEDIR}/${PGM_NAME}.html) + + file( + GLOB IMG_FILES + LIST_DIRECTORIES FALSE + ${PGM_SOURCEDIR}/*.png ${PGM_SOURCEDIR}/*.jpg) + if(IMG_FILES AND NOT PGM_IMG_NOT) + set(copy_images_command ${CMAKE_COMMAND} -E copy_if_different ${IMG_FILES} + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}) + install(FILES ${IMG_FILES} DESTINATION ${GRASS_INSTALL_DOCDIR}) + endif() + + add_custom_command( + TARGET ${PGM_TARGET} + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${PGM_SOURCE} + ${CMAKE_CURRENT_BINARY_DIR}/${PGM_NAME}.html + COMMAND ${grass_env_command} ${PYTHON_EXECUTABLE} ${MKHTML_PY} ${PGM_NAME} > + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${PGM_NAME}.html + COMMAND ${copy_images_command} + COMMAND ${CMAKE_COMMAND} -E remove + ${CMAKE_CURRENT_BINARY_DIR}/${PGM_NAME}.html + COMMENT "Creating ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${PGM_NAME}.[html|1]") + install(FILES ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${PGM_NAME}.html + DESTINATION ${GRASS_INSTALL_DOCDIR}) +endmacro() diff --git a/cmake/modules/get_host_arch.cmake b/cmake/modules/get_host_arch.cmake new file mode 100644 index 00000000000..5ec4ad634d9 --- /dev/null +++ b/cmake/modules/get_host_arch.cmake @@ -0,0 +1,44 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: Get host system architecuture +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +function(get_host_arch var_arch) + set(host_arch_value "x86_64") # default value + + if(WIN32) + if(MSVC) + execute_process( + COMMAND ${CMAKE_C_COMPILER} + ERROR_VARIABLE ev + OUTPUT_VARIABLE ov + OUTPUT_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE) + + if("${ev}" MATCHES "x86") + set(${host_arch_value} "x86") + else() + set(${host_arch_value} "x86_64") + endif() + + elseif(MINGW) + + else() + message(FATAL_ERROR "compiler/platform is not supported") + endif() # if(MSVC) + + elseif(UNIX) + execute_process( + COMMAND uname -m + ERROR_VARIABLE ev + OUTPUT_VARIABLE ov + OUTPUT_STRIP_TRAILING_WHITESPACE) + set(${host_arch_value} "${ov}") + endif() + + set(${var_arch} + ${host_arch_value} + PARENT_SCOPE) +endfunction() diff --git a/cmake/modules/get_versions.cmake b/cmake/modules/get_versions.cmake new file mode 100644 index 00000000000..3fdc8aefe25 --- /dev/null +++ b/cmake/modules/get_versions.cmake @@ -0,0 +1,44 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: Read major, minor patch, date from given version file +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +function(get_versions file_path var_major var_minor var_release var_date) + set(version_major 0) + set(version_minor 0) + set(version_release 0) + set(version_date 00000000) + file(STRINGS "${file_path}" grass_version_strings) + list(LENGTH grass_version_strings grass_version_file_length) + + if(grass_version_file_length LESS 3) + message(FATAL_ERROR "include/VERSION is not a valid file") + endif() + + list(GET grass_version_strings 0 version_major) + list(GET grass_version_strings 1 version_minor) + + if(grass_version_file_length GREATER 2) + list(GET grass_version_strings 2 version_release) + endif() + + if(grass_version_file_length GREATER 3) + list(GET grass_version_strings 3 version_date) + endif() + + set(${var_major} + ${version_major} + PARENT_SCOPE) + set(${var_minor} + ${version_minor} + PARENT_SCOPE) + set(${var_release} + ${version_release} + PARENT_SCOPE) + set(${var_date} + ${version_date} + PARENT_SCOPE) +endfunction() diff --git a/cmake/modules/linker.cmake b/cmake/modules/linker.cmake new file mode 100644 index 00000000000..a94f0e11f77 --- /dev/null +++ b/cmake/modules/linker.cmake @@ -0,0 +1,52 @@ +macro(set_alternate_linker linker) + if(NOT "${USE_ALTERNATE_LINKER}" STREQUAL + "${USE_ALTERNATE_LINKER_OLD_CACHED}") + unset(LINKER_EXECUTABLE CACHE) + endif() + find_program(LINKER_EXECUTABLE ld.${USE_ALTERNATE_LINKER} + ${USE_ALTERNATE_LINKER}) + if(LINKER_EXECUTABLE) + if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + if("${CMAKE_CXX_COMPILER_VERSION}" VERSION_GREATER_EQUAL 12.0.0) + add_link_options("--ld-path=${LINKER_EXECUTABLE}") + else() + add_link_options("-fuse-ld=${LINKER_EXECUTABLE}") + endif() + elseif( + "${linker}" STREQUAL "mold" + AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" + AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 12.1.0) + # GCC before 12.1.0: -fuse-ld does not accept mold as a valid argument, so + # you need to use -B option instead. + get_filename_component(_dir ${LINKER_EXECUTABLE} DIRECTORY) + get_filename_component(_dir ${_dir} DIRECTORY) + if(EXISTS "${_dir}/libexec/mold/ld") + add_link_options(-B "${_dir}/libexec/mold") + else() + message(FATAL_ERROR "Cannot find ${_dir}/libexec/mold/ld") + endif() + else() + add_link_options("-fuse-ld=${USE_ALTERNATE_LINKER}") + endif() + message(STATUS "Using alternative linker: ${LINKER_EXECUTABLE}") + else() + message( + FATAL_ERROR "Cannot find alternative linker ${USE_ALTERNATE_LINKER}") + endif() +endmacro() + +if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR "${CMAKE_CXX_COMPILER_ID}" + STREQUAL "GNU") + set(USE_ALTERNATE_LINKER + "" + CACHE + STRING + "Use alternate linker. Leave empty for system default; potential alternatives are 'gold', 'lld', 'bfd', 'mold'" + ) + if(NOT "${USE_ALTERNATE_LINKER}" STREQUAL "") + set_alternate_linker(${USE_ALTERNATE_LINKER}) + endif() + set(USE_ALTERNATE_LINKER_OLD_CACHED + ${USE_ALTERNATE_LINKER} + CACHE INTERNAL "Previous value of USE_ALTERNATE_LINKER") +endif() diff --git a/cmake/modules/repo_status.cmake b/cmake/modules/repo_status.cmake new file mode 100644 index 00000000000..86b2d6a534c --- /dev/null +++ b/cmake/modules/repo_status.cmake @@ -0,0 +1,80 @@ +#[[ +AUTHOR(S): Rashad Kanavath +PURPOSE: Read git status of grass repository if building from git clone +COPYRIGHT: (C) 2020 by the GRASS Development Team + +SPDX-License-Identifier: GPL-2.0-or-later +#]] + +function(repo_status repo_dir) + set(time_format "%Y-%m-%dT%H:%M:%S+00:00") + set(GRASS_VERSION_GIT + "exported" + PARENT_SCOPE) + set(GRASS_HEADERS_GIT_HASH + ${GRASS_VERSION_NUMBER} + PARENT_SCOPE) + string(TIMESTAMP GRASS_HEADERS_GIT_DATE ${time_format} UTC) + set(GRASS_HEADERS_GIT_DATE + ${GRASS_HEADERS_GIT_DATE} + PARENT_SCOPE) + + if(NOT EXISTS "${repo_dir}/.git") + return() + endif() + find_package(Git) + if(NOT GIT_FOUND) + return() + endif() + + execute_process( + COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + OUTPUT_VARIABLE git_rev_OV + ERROR_VARIABLE git_rev_EV + RESULT_VARIABLE git_rev_RV) + + if(git_rev_RV) + message(FATAL_ERROR "Error running git ${git_rev_EV}") + else() + string(STRIP ${git_rev_OV} GRASS_VERSION_GIT) + set(GRASS_VERSION_GIT + "${GRASS_VERSION_GIT}" + PARENT_SCOPE) + endif() + + execute_process( + COMMAND ${GIT_EXECUTABLE} log -1 --pretty=format:%h -- + "${CMAKE_SOURCE_DIR}/include" + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + OUTPUT_VARIABLE git_hash_OV + ERROR_VARIABLE git_hash_EV + RESULT_VARIABLE git_hash_RV) + + if(git_hash_RV) + message(FATAL_ERROR "Error running git ${git_hash_EV}") + else() + string(STRIP ${git_hash_OV} GRASS_HEADERS_GIT_HASH) + set(GRASS_HEADERS_GIT_HASH + "${GRASS_HEADERS_GIT_HASH}" + PARENT_SCOPE) + endif() + + execute_process( + COMMAND ${GIT_EXECUTABLE} log -1 --pretty=format:%ct -- + "${CMAKE_SOURCE_DIR}/include" + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + OUTPUT_VARIABLE git_date_OV + ERROR_VARIABLE git_date_EV + RESULT_VARIABLE git_date_RV) + + if(git_date_RV) + message(FATAL_ERROR "Error running git ${git_date_EV}") + else() + set(ENV{SOURCE_DATE_EPOCH} ${git_date_OV}) + string(TIMESTAMP GRASS_HEADERS_GIT_DATE ${time_format} UTC) + set(GRASS_HEADERS_GIT_DATE + "${GRASS_HEADERS_GIT_DATE}" + PARENT_SCOPE) + endif() +endfunction() diff --git a/cmake/modules/set_compiler_flags.cmake b/cmake/modules/set_compiler_flags.cmake new file mode 100644 index 00000000000..986b405dd2d --- /dev/null +++ b/cmake/modules/set_compiler_flags.cmake @@ -0,0 +1,14 @@ +macro(set_compiler_flags) + if(MSVC) + set(GRASS_C_FLAGS + "/D_CRT_SECURE_NO_WARNINGS /DNOMINMAX /DGRASS_CMAKE_BUILD=1") + set(GRASS_CXX_FLAGS "${GRASS_C_FLAGS}") + else() + set(GRASS_C_FLAGS "-DGRASS_CMAKE_BUILD=1") + set(GRASS_CXX_FLAGS "${GRASS_C_FLAGS}") + endif() + + set(CMAKE_CXX_FLAGS "${GRASS_CXX_FLAGS} ${CMAKE_CXX_FLAGS}") + set(CMAKE_C_FLAGS "${GRASS_C_FLAGS} ${CMAKE_C_FLAGS}") + +endmacro() diff --git a/cmake/tests/have_pbuffer.c b/cmake/tests/have_pbuffer.c new file mode 100644 index 00000000000..595d07f92a0 --- /dev/null +++ b/cmake/tests/have_pbuffer.c @@ -0,0 +1,20 @@ +#include +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char glXCreatePbuffer(); + +int main() +{ + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined(__stub_glXCreatePbuffer) || defined(__stub___glXCreatePbuffer) + choke me +#else + glXCreatePbuffer(); +#endif + ; + return 0; +} diff --git a/cmake/tests/have_pixmaps.c b/cmake/tests/have_pixmaps.c new file mode 100644 index 00000000000..ad46df8c350 --- /dev/null +++ b/cmake/tests/have_pixmaps.c @@ -0,0 +1,23 @@ +/* System header to define __stub macros and hopefully few prototypes, + which can conflict with char glXCreateGLXPixmap(); below. */ +#include +/* Override any gcc2 internal prototype to avoid an error. */ +/* We use char because int might match the return type of a gcc2 + builtin and then its argument prototype would still apply. */ +char glXCreateGLXPixmap(); + +int main() +{ + +/* The GNU C library defines this for functions which it implements + to always fail with ENOSYS. Some functions are actually named + something starting with __ and the normal name is an alias. */ +#if defined(__stub_glXCreateGLXPixmap) || defined(__stub___glXCreateGLXPixmap) + choke me +#else + glXCreateGLXPixmap(); +#endif + + ; + return 0; +} diff --git a/cmake/windows_launch.bat.in b/cmake/windows_launch.bat.in new file mode 100644 index 00000000000..aa03bb369bf --- /dev/null +++ b/cmake/windows_launch.bat.in @@ -0,0 +1,2 @@ +@echo off +"%GRASS_PYTHON%" "%GISBASE%\scripts\@PGM_NAME@.py" %* \ No newline at end of file diff --git a/db/CMakeLists.txt b/db/CMakeLists.txt new file mode 100644 index 00000000000..e706d844d29 --- /dev/null +++ b/db/CMakeLists.txt @@ -0,0 +1,73 @@ +set(database_modules_list + db.columns + db.connect + db.copy + db.createdb + db.databases + db.describe + db.drivers + db.dropdb + db.execute + db.login + db.select + db.tables) + +add_custom_target( + ALL_DATABASE_MODULES ALL + DEPENDS ${db_modules_list} + COMMENT "All database modules are built.") + +if(WITH_DOCS) + generate_html(TARGET ALL_DATABASE_MODULES NAME databaseintro) +endif() + +set(db_drivers grass_gis) +add_subdirectory(drivers) + +build_program_in_subdir(db.columns DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.columns ${db_drivers}) + +build_program_in_subdir(db.createdb DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.createdb ${db_drivers}) + +build_program_in_subdir(db.describe DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver grass_parson) +add_dependencies(db.describe ${db_drivers}) + +build_program_in_subdir(db.connect DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.connect ${db_drivers}) + +build_program_in_subdir(db.copy DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.copy ${db_drivers}) + +build_program_in_subdir(db.execute DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.execute ${db_drivers}) + +build_program_in_subdir(db.drivers DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.drivers ${db_drivers}) + +build_program_in_subdir(db.databases DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.databases ${db_drivers}) + +build_program_in_subdir(db.dropdb DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.dropdb ${db_drivers}) + +build_program_in_subdir(db.login DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.login ${db_drivers}) + +build_program_in_subdir(db.select DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.select ${db_drivers}) + +build_program_in_subdir(db.tables DEPENDS grass_gis grass_dbmibase + grass_dbmiclient grass_dbmidriver) +add_dependencies(db.tables ${db_drivers}) diff --git a/db/drivers/CMakeLists.txt b/db/drivers/CMakeLists.txt new file mode 100644 index 00000000000..e6a5c709ff3 --- /dev/null +++ b/db/drivers/CMakeLists.txt @@ -0,0 +1,170 @@ +set(dbf_SRCS + dbf/column.c + dbf/create_table.c + dbf/cursor.c + dbf/db.c + dbf/dbfexe.c + dbf/describe.c + dbf/driver.c + dbf/error.c + dbf/execute.c + dbf/fetch.c + dbf/listtab.c + dbf/main.c + dbf/select.c + dbf/str.c + dbf/table.c) + +set(mysql_SRCS + mysql/create_table.c + mysql/cursor.c + mysql/dbe.c + mysql/describe.c + mysql/driver.c + mysql/error.c + mysql/execute.c + mysql/fetch.c + mysql/index.c + mysql/listtab.c + mysql/main.c + mysql/parse.c + mysql/replace.c + mysql/select.c) + +set(db_drivers) +set(grass_dbstubs_DEFS) +if(MSVC) + set(grass_dbstubs_DEFS "-DDB_DRIVER_C=1") +endif() +build_program_in_subdir( + dbf + SOURCES + ${dbf_SRCS} + DEPENDS + grass_gis + grass_dbstubs + grass_dbmibase + grass_dbmidriver + grass_shape + grass_sqlp + DEFS + "${grass_dbstubs_DEFS}" + HTML_FILE_NAME + grass-dbf + RUNTIME_OUTPUT_DIR + "${GRASS_INSTALL_DRIVERDIR}/db") + +list(APPEND db_drivers dbf) + +build_program_in_subdir( + ogr + DEPENDS + grass_gis + grass_dbstubs + grass_dbmibase + grass_dbmidriver + grass_sqlp + GDAL + DEFS + "${grass_dbstubs_DEFS}" + HTML_FILE_NAME + grass-ogr + RUNTIME_OUTPUT_DIR + "${GRASS_INSTALL_DRIVERDIR}/db") + +list(APPEND db_drivers ogr) + +build_program_in_subdir( + odbc + DEPENDS + grass_gis + grass_dbstubs + grass_dbmidriver + grass_sqlp + DEFS + "${grass_dbstubs_DEFS}" + PRIMARY_DEPENDS + ODBC + HTML_FILE_NAME + grass-odbc + RUNTIME_OUTPUT_DIR + "${GRASS_INSTALL_DRIVERDIR}/db") +if(TARGET ODBC) + list(APPEND db_drivers odbc) +endif() + +build_program_in_subdir( + sqlite + DEPENDS + grass_gis + grass_dbstubs + grass_dbmibase + grass_dbmidriver + grass_sqlp + DEFS + "${grass_dbstubs_DEFS}" + PRIMARY_DEPENDS + SQLITE + HTML_FILE_NAME + grass-sqlite + RUNTIME_OUTPUT_DIR + "${GRASS_INSTALL_DRIVERDIR}/db") + +if(TARGET SQLITE) + list(APPEND db_drivers sqlite) +endif() + +build_program_in_subdir( + postgres + NAME + pg + DEPENDS + grass_gis + grass_dbstubs + grass_dbmibase + grass_dbmidriver + grass_sqlp + DEFS + "${grass_dbstubs_DEFS}" + PRIMARY_DEPENDS + POSTGRES + HTML_FILE_NAME + grass-pg + RUNTIME_OUTPUT_DIR + "${GRASS_INSTALL_DRIVERDIR}/db") + +if(TARGET POSTGRES) + list(APPEND db_drivers pg) +endif() + +build_program_in_subdir( + mysql + SOURCES + ${mysql_SRCS} + DEPENDS + grass_gis + grass_dbstubs + grass_dbmibase + grass_dbmidriver + grass_sqlp + DEFS + "${grass_dbstubs_DEFS}" + PRIMARY_DEPENDS + MYSQL + HTML_FILE_NAME + grass-mysql + RUNTIME_OUTPUT_DIR + "${GRASS_INSTALL_DRIVERDIR}/db") + +if(TARGET MYSQL) + list(APPEND db_drivers mysql) + + if(WITH_DOCS) + generate_html(TARGET mysql NAME grass-mesql SOURCEDIR + ${CMAKE_CURRENT_SOURCE_DIR}/mysql) + endif() +endif() + +set(db_drivers + ${db_drivers} + PARENT_SCOPE) diff --git a/db/drivers/odbc/odbc.h b/db/drivers/odbc/odbc.h index 4cd376ee64e..1e14184c2b2 100644 --- a/db/drivers/odbc/odbc.h +++ b/db/drivers/odbc/odbc.h @@ -1,7 +1,7 @@ #ifndef _ODBC_H_ #define _ODBC_H_ -#ifdef __MINGW32__ +#ifdef _WIN32 #include #endif diff --git a/display/CMakeLists.txt b/display/CMakeLists.txt new file mode 100644 index 00000000000..72ee05404ce --- /dev/null +++ b/display/CMakeLists.txt @@ -0,0 +1,154 @@ +set(display_modules_list + d.barscale + d.colorlist + d.colortable + d.erase + d.font + d.fontlist + d.geodesic + d.graph + d.grid + d.his + d.histogram + d.info + d.labels + d.legend + d.legend.vect + d.linegraph + d.mon + d.northarrow + d.path + d.profile + d.rast + d.rast.arrow + d.rast.num + d.redraw + d.rgb + d.rhumbline + d.text + d.title + d.vect + d.vect.chart + d.vect.thematic + d.where) + +if(MSVC) + list(REMOVE_ITEM display_modules_list d.font d.mon) +endif() + +add_custom_target( + ALL_DISPLAY_MODULES ALL + DEPENDS ${display_modules_list} + COMMENT "All display modules are built.") + +if(WITH_DOCS) + generate_html(TARGET ALL_DISPLAY_MODULES NAME displaydrivers) +endif() + +build_program_in_subdir(d.barscale DEPENDS grass_symb grass_display grass_gis) +file(GLOB d_barscale_png + ${CMAKE_CURRENT_SOURCE_DIR}/d.barscale/thumbnails/*.png) +add_custom_command( + TARGET d.barscale + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/barscales + COMMAND ${CMAKE_COMMAND} -E copy ${d_barscale_png} + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/barscales + BYPRODUCTS ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/barscales) +install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/barscales + DESTINATION ${GRASS_INSTALL_DOCDIR}) + +build_program_in_subdir(d.colorlist DEPENDS grass_gis grass_display + grass_raster) +build_program_in_subdir(d.colortable DEPENDS grass_gis grass_display + grass_raster ${LIBM}) +build_program_in_subdir(d.erase DEPENDS grass_gis grass_display) +if(NOT MSVC) + build_program_in_subdir(d.font DEPENDS grass_gis grass_display grass_raster) + # libgen.h does not exists on windows msvc + build_program_in_subdir(d.mon DEPENDS grass_gis grass_display) + copy_python_files_in_subdir(d.mon ${GRASS_INSTALL_ETCBINDIR} TARGET d.mon + POST_BUILD) +endif() +build_program_in_subdir(d.fontlist DEPENDS grass_gis grass_display grass_raster) +build_program_in_subdir(d.geodesic DEPENDS grass_gis grass_display) +build_program_in_subdir(d.graph DEPENDS grass_gis grass_symb grass_display) +if(WITH_DOCS) + file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/d.graph/grass_logo.txt + DESTINATION ${OUTDIR}/${GRASS_INSTALL_DOCDIR}) + install(FILES ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/grass_logo.txt + DESTINATION ${GRASS_INSTALL_DOCDIR}) +endif() +build_program_in_subdir(d.grid DEPENDS grass_gis grass_symb grass_gproj + grass_display GDAL ${LIBM}) +build_program_in_subdir(d.his DEPENDS grass_gis grass_display grass_raster) +build_program_in_subdir(d.histogram DEPENDS grass_gis grass_display + grass_raster ${LIBM}) +build_program_in_subdir(d.info DEPENDS grass_gis grass_display) +build_program_in_subdir(d.labels DEPENDS grass_gis grass_display ${LIBM}) +build_program_in_subdir(d.legend DEPENDS grass_gis grass_display grass_raster + grass_raster3d ${LIBM}) +build_program_in_subdir(d.legend.vect DEPENDS grass_gis grass_display + grass_symb ${LIBM}) +build_program_in_subdir(d.linegraph DEPENDS grass_gis grass_display grass_symb + grass_raster) +build_program_in_subdir(d.northarrow DEPENDS grass_gis grass_display grass_symb ${LIBM}) +if(WITH_DOCS) + file(MAKE_DIRECTORY ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/northarrows) + file(GLOB d_northarrow_png + ${CMAKE_CURRENT_SOURCE_DIR}/d.northarrow/thumbnails/*.png) + file(COPY ${d_northarrow_png} + DESTINATION ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/northarrows) + install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/northarrows + DESTINATION ${GRASS_INSTALL_DOCDIR}) +endif() +build_program_in_subdir(d.path DEPENDS grass_gis grass_display grass_vector GDAL) +build_program_in_subdir(d.profile DEPENDS grass_gis grass_display grass_raster ${LIBM}) +build_program_in_subdir(d.rast DEPENDS grass_gis grass_display grass_raster) +build_program_in_subdir(d.rast.arrow DEPENDS grass_gis grass_raster + grass_display ${LIBM}) +build_program_in_subdir(d.rast.num DEPENDS grass_gis grass_display grass_raster) +build_program_in_subdir(d.redraw DEPENDS grass_gis grass_display) +build_program_in_subdir(d.rgb DEPENDS grass_gis grass_display grass_raster) +build_program_in_subdir(d.rhumbline DEPENDS grass_gis grass_display) +build_program_in_subdir(d.text DEPENDS grass_gis grass_display ${LIBM}) +build_program_in_subdir(d.title DEPENDS grass_gis grass_display grass_raster) +build_program_in_subdir( + d.vect + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_display + grass_gis + grass_raster + grass_symb + grass_vector + GDAL + ${LIBM}) +build_program_in_subdir( + d.vect.chart + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_display + grass_gis + grass_symb + grass_vector + GDAL + ${LIBM}) +build_program_in_subdir( + d.vect.thematic + DEPENDS + grass_arraystats + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_display + grass_gis + grass_symb + grass_vector + GDAL) +build_program_in_subdir(d.where DEPENDS grass_gis grass_display grass_gproj GDAL) diff --git a/display/d.vect/legend.c b/display/d.vect/legend.c index 6a0b56b3a06..d522332babc 100644 --- a/display/d.vect/legend.c +++ b/display/d.vect/legend.c @@ -14,8 +14,11 @@ void write_into_legfile(struct Map_info *Map, int type, const char *leglab, char map[GNAME_MAX]; char *ptr; strcpy(map, name_map); +#ifdef _MSC_VER + strtok_s(map, "@", &ptr); +#else strtok_r(map, "@", &ptr); - +#endif if (size_column) size = "-1"; diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt new file mode 100644 index 00000000000..1717479ebad --- /dev/null +++ b/doc/CMakeLists.txt @@ -0,0 +1,15 @@ +file(GLOB doc_HTMLFILES "*.html") +add_custom_target(ADD_DOC_DOCS ALL COMMENT "Generate doc/html docs." DEPENDS LIB_PYTHON) + +foreach(html_file ${doc_HTMLFILES}) + get_filename_component(filename ${html_file} NAME_WLE) + generate_html(TARGET ADD_DOC_DOCS NAME ${filename} IMG_NOT) +endforeach() + +file( + GLOB IMG_FILES + LIST_DIRECTORIES FALSE + *.png *.jpg) +if(IMG_FILES) + install(FILES ${IMG_FILES} DESTINATION ${GRASS_INSTALL_DOCDIR}) +endif() diff --git a/general/CMakeLists.txt b/general/CMakeLists.txt new file mode 100644 index 00000000000..78ae72538e7 --- /dev/null +++ b/general/CMakeLists.txt @@ -0,0 +1,83 @@ +build_program_in_subdir(g.access DEPENDS grass_gis) +build_program_in_subdir(g.copy DEPENDS grass_gis grass_manage) +build_program_in_subdir(g.dirseps DEPENDS grass_gis) +build_program_in_subdir(g.filename DEPENDS grass_gis) +build_program_in_subdir(g.findetc DEPENDS grass_gis) +build_program_in_subdir(g.findfile DEPENDS grass_gis grass_manage) +build_program_in_subdir(g.gisenv DEPENDS grass_gis) +build_program_in_subdir(g.mapset DEPENDS grass_gis) +build_program_in_subdir(g.mapsets DEPENDS grass_gis grass_parson) +build_program_in_subdir(g.message DEPENDS grass_gis) +build_program_in_subdir(g.mkfontcap DEPENDS grass_gis FREETYPE) +add_dependencies(g.mkfontcap fonts) +add_custom_command( + TARGET g.mkfontcap + POST_BUILD + COMMAND ${grass_env_command} ${OUTDIR}/${GRASS_INSTALL_BINDIR}/g.mkfontcap -s + > ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/fontcap) +install(FILES ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/fontcap + DESTINATION ${GRASS_INSTALL_ETCDIR}) +build_program_in_subdir(g.parser DEPENDS grass_gis FREETYPE) +build_program_in_subdir(g.pnmcomp DEPENDS grass_gis) +if(WITH_LIBPNG) + build_program_in_subdir(g.ppmtopng DEPENDS grass_gis LIBPNG) +endif() +build_program_in_subdir(g.proj DEPENDS grass_gis grass_gproj GDAL PROJ) +# LIBES = $(GPROJLIB) $(VECTORLIB) $(DIG2LIB) $(RASTER3DLIB) $(RASTERLIB) +# $(GISLIB) $(MATHLIB) $(PROJLIB) +build_program_in_subdir( + g.region + DEPENDS + grass_gis + grass_gproj + grass_vector + grass_raster + grass_raster3d + grass_gmath + grass_parson + PROJ + GDAL + ${LIBM}) + +build_program_in_subdir(g.rename DEPENDS grass_gis grass_manage grass_raster) +build_program_in_subdir(g.tempfile DEPENDS grass_gis) + +build_program_in_subdir( + g.version + DEPENDS + grass_gis + PROJ + GDAL + SQLITE + OPTIONAL_DEPENDS + GEOS + DEFS + "-DGRASS_VERSION_NUMBER=\"${GRASS_VERSION_NUMBER}\"" + "-DGRASS_VERSION_GIT=\"${GRASS_VERSION_GIT}\"" + "-DGRASS_VERSION_UPDATE_PKG=${GRASS_VERSION_UPDATE_PKG}" + "-DARCH=\"${BUILD_ARCH}\"") + +# TODO: add CAIRO_HAS_XRENDER and CAIRO_HAS_XRENDER_SURFACE to if clause +if(WITH_CAIRO AND USE_X11) + if(NOT MSVC) + build_program_in_subdir(g.cairocomp DEPENDS grass_gis CAIRO + grass_cairodriver) + endif() +endif() + +add_subdirectory(manage/lister) + +build_program_in_subdir( + g.list + DEPENDS + grass_gis + grass_manage + grass_raster + grass_raster3d + grass_vector + GDAL) +add_dependencies(g.list cell vector) + +build_program_in_subdir(g.remove DEPENDS grass_gis grass_manage grass_raster) + +build_program_in_subdir(g.gui DEPENDS grass_raster grass_gis) diff --git a/general/manage/lister/CMakeLists.txt b/general/manage/lister/CMakeLists.txt new file mode 100644 index 00000000000..a7e9359bcd7 --- /dev/null +++ b/general/manage/lister/CMakeLists.txt @@ -0,0 +1,28 @@ +build_program( + NAME + cell + SOURCES + "cell.c" + DEPENDS + grass_vector + grass_dbmibase + grass_gis + grass_raster + RUNTIME_OUTPUT_DIR + "${GRASS_INSTALL_ETCDIR}/lister" + NO_DOCS) + +build_program( + NAME + vector + SOURCES + "vector.c" + DEPENDS + grass_vector + grass_dbmibase + grass_gis + grass_raster + GDAL + RUNTIME_OUTPUT_DIR + "${GRASS_INSTALL_ETCDIR}/lister" + NO_DOCS) diff --git a/gui/CMakeLists.txt b/gui/CMakeLists.txt new file mode 100644 index 00000000000..41d03ee9499 --- /dev/null +++ b/gui/CMakeLists.txt @@ -0,0 +1,8 @@ +add_subdirectory(icons) +add_subdirectory(images) + +add_subdirectory(scripts) + +add_subdirectory(wxpython) + +install(FILES xml/grass-interface.dtd DESTINATION ${GRASS_INSTALL_GUIDIR}/xml) diff --git a/gui/icons/CMakeLists.txt b/gui/icons/CMakeLists.txt new file mode 100644 index 00000000000..f7100212488 --- /dev/null +++ b/gui/icons/CMakeLists.txt @@ -0,0 +1,86 @@ +file(GLOB GUI_ICONS "*.ico" "*.png") +file(GLOB GRASS_ICONS "grass/*.png") +file(GLOB FLAGS_ICONS "flags/*.png") + +add_custom_target( + make_gui_icons_dirs + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/grass + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/flags + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/icons + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/images/symbols) + +set(output_icons) +foreach(ICON ${GUI_ICONS}) + get_filename_component(FILE_NAME ${ICON} NAME) + add_custom_command( + OUTPUT ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/${FILE_NAME} + COMMAND ${CMAKE_COMMAND} -E copy ${ICON} + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons) + list(APPEND output_icons ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/${FILE_NAME}) +endforeach() + +foreach(ICON ${GRASS_ICONS}) + get_filename_component(FILE_NAME ${ICON} NAME) + add_custom_command( + OUTPUT ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/grass/${FILE_NAME} + COMMAND ${CMAKE_COMMAND} -E copy ${ICON} + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/grass) + list(APPEND output_icons + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/grass/${FILE_NAME}) + + add_custom_command( + OUTPUT ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/icons/${FILE_NAME} + COMMAND ${CMAKE_COMMAND} -E copy ${ICON} + ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/icons) + list(APPEND output_icons ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/icons/${FILE_NAME}) +endforeach() + +foreach(ICON ${FLAGS_ICONS}) + get_filename_component(FILE_NAME ${ICON} NAME) + add_custom_command( + OUTPUT ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/flags/${FILE_NAME} + COMMAND ${CMAKE_COMMAND} -E copy ${ICON} + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/flags) + list(APPEND output_icons + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/icons/flags/${FILE_NAME}) +endforeach() + +add_custom_target(gui_icons DEPENDS make_gui_icons_dirs ${output_icons}) + +install(FILES ${GUI_ICONS} DESTINATION ${GRASS_INSTALL_GUIDIR}/icons) +install(FILES ${GRASS_ICONS} DESTINATION ${GRASS_INSTALL_GUIDIR}/icons/grass) +install(FILES ${FLAGS_ICONS} DESTINATION ${GRASS_INSTALL_GUIDIR}/icons/flags) +install(FILES ${GRASS_ICONS} DESTINATION ${GRASS_INSTALL_DOCDIR}/icons) +install(FILES grass.desktop DESTINATION ${GRASS_INSTALL_SHAREDIR}/applications) +foreach( + icon_type + 8 + 16 + 22 + 24 + 32 + 36 + 40 + 42 + 48 + 64 + 72 + 80 + 96 + 128 + 192) + set(icon_size "${icon_type}x${icon_type}") + install( + FILES grass-${icon_size}.png + DESTINATION ${GRASS_INSTALL_SHAREDIR}/icons/hicolor/${icon_size}/apps + RENAME grass.svg) +endforeach() + +install(FILES grass.svg + DESTINATION ${GRASS_INSTALL_SHAREDIR}/icons/hicolor/scalable/apps) + +install(FILES grass.appdata.xml DESTINATION ${GRASS_INSTALL_SHAREDIR}/metainfo) diff --git a/gui/images/CMakeLists.txt b/gui/images/CMakeLists.txt new file mode 100644 index 00000000000..0417626c163 --- /dev/null +++ b/gui/images/CMakeLists.txt @@ -0,0 +1,40 @@ +file(GLOB GUI_IMAGES "*.png") + +set(output_images) +foreach(IMG ${GUI_IMAGES}) + get_filename_component(FILE_NAME ${IMG} NAME) + add_custom_command( + OUTPUT ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/images/${FILE_NAME} + COMMAND ${CMAKE_COMMAND} -E copy ${IMG} + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/images) + list(APPEND output_images + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/images/${FILE_NAME}) +endforeach() + +if(CMAKE_VERSION VERSION_LESS 3.17) + set(RM remove) +else() + set(RM rm) +endif() + +add_custom_target( + gui_images + COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/symbols + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/images/symbols + COMMAND ${CMAKE_COMMAND} -E ${RM} + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/images/symbols/README + DEPENDS gui_icons ${output_images}) + +install(FILES ${GUI_IMAGES} DESTINATION ${GRASS_INSTALL_GUIDIR}/images) +install(DIRECTORY symbols/basic + DESTINATION ${GRASS_INSTALL_GUIDIR}/images/symbols) +install(DIRECTORY symbols/demo + DESTINATION ${GRASS_INSTALL_GUIDIR}/images/symbols) +install(DIRECTORY symbols/extra + DESTINATION ${GRASS_INSTALL_GUIDIR}/images/symbols) +install(DIRECTORY symbols/geology + DESTINATION ${GRASS_INSTALL_GUIDIR}/images/symbols) +install(DIRECTORY symbols/legend + DESTINATION ${GRASS_INSTALL_GUIDIR}/images/symbols) +install(DIRECTORY symbols/n_arrows + DESTINATION ${GRASS_INSTALL_GUIDIR}/images/symbols) diff --git a/gui/scripts/CMakeLists.txt b/gui/scripts/CMakeLists.txt new file mode 100644 index 00000000000..7cadce3af5c --- /dev/null +++ b/gui/scripts/CMakeLists.txt @@ -0,0 +1,10 @@ +#[[ +TODO: maybe add /scripts/windows_launch.bat, see Makefile +]] + +set(gui_scripts d.rast3d d.wms) + +foreach(script_file ${gui_scripts}) + build_script_in_subdir(${script_file} PLAIN_PY NO_DOCS DEST_DIR + ${GRASS_INSTALL_GUISCRIPTDIR}) +endforeach() diff --git a/gui/wxpython/CMakeLists.txt b/gui/wxpython/CMakeLists.txt new file mode 100644 index 00000000000..e730c551ab4 --- /dev/null +++ b/gui/wxpython/CMakeLists.txt @@ -0,0 +1,141 @@ +set(WXPYTHON_DIR ${GRASS_INSTALL_GUIDIR}/wxpython) +set(gui_lib_DIRS + core + gui_core + history + icons + iscatt + lmgr + location_wizard + main_window + mapdisp + mapwin + modules + nviz + startup + tools + vnet + web_services + wxplot) + +set(gui_lib_targets) +foreach(gui_lib_DIR ${gui_lib_DIRS}) + copy_python_files_in_subdir(${gui_lib_DIR} ${WXPYTHON_DIR}) + list(APPEND gui_lib_targets python_${gui_lib_DIR}) +endforeach() +add_custom_target( + GUI_WXPYTHON + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/wxgui.py + ${OUTDIR}/${WXPYTHON_DIR} + DEPENDS ${gui_lib_targets} LIB_PYTHON) + +set(gui_DIRS + animation + datacatalog + dbmgr + gcp + gmodeler + iclass + image2target + mapswipe + photo2image + psmap + rlisetup + timeline + tplot + rdigit + vdigit) +set(g_gui_targets) +foreach(gui_DIR ${gui_DIRS}) + build_gui_in_subdir(${gui_DIR}) + list(APPEND g_gui_targets "g.gui.${gui_DIR}") +endforeach() + +if(WITH_DOCS) + add_subdirectory(docs) +endif() + +install(FILES README DESTINATION ${GRASS_INSTALL_GUIDIR}/wxpython) + +# copy all python files gui/ lib/python compile all python files so below target +# depends on MODULD_LIST + +add_custom_target( + copy_wxpython_xml + COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/xml + ${OUTDIR}/${WXPYTHON_DIR}/xml + COMMAND + ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_SOURCE_DIR}/../xml/grass-interface.dtd + ${OUTDIR}/${GRASS_INSTALL_GUIDIR}/xml) + +add_dependencies(copy_wxpython_xml GUI_WXPYTHON) + +add_custom_target( + compile_python_files + COMMAND ${PYTHON_EXECUTABLE} -m compileall + ${OUTDIR}/${GRASS_INSTALL_SCRIPTDIR} + COMMAND ${PYTHON_EXECUTABLE} -m compileall ${OUTDIR}/${WXPYTHON_DIR}) + +add_dependencies(compile_python_files ALL_MODULES) + +add_custom_command( + OUTPUT "${OUTDIR}/${WXPYTHON_DIR}/xml/module_items.xml" + COMMAND ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/tools/build_modules_xml.py > + "${OUTDIR}/${WXPYTHON_DIR}/xml/module_items.xml" + COMMENT "Generating interface description for all modules..." +) + +add_custom_target( + build_modules_items_xml + DEPENDS "${OUTDIR}/${WXPYTHON_DIR}/xml/module_items.xml") + +add_dependencies(build_modules_items_xml copy_wxpython_xml compile_python_files ${g_gui_targets}) + +add_custom_target( + build_xml_menudata + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/core/toolboxes.py > + ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/menudata.xml + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/core/toolboxes.py "validate" + ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/menudata.xml + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/menudata.xml + ${OUTDIR}/${WXPYTHON_DIR}/xml + DEPENDS build_modules_items_xml) + +add_custom_target( + build_module_tree_menudata + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/core/toolboxes.py "module_tree" > + ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/module_tree_menudata.xml + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/core/toolboxes.py "validate" + ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/module_tree_menudata.xml + COMMAND + ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/module_tree_menudata.xml + ${OUTDIR}/${WXPYTHON_DIR}/xml + DEPENDS build_xml_menudata) + +add_custom_target( + build_menustrings ALL + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/core/menutree.py "manager" >> + ${CMAKE_CURRENT_SOURCE_DIR}/menustrings.py + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/core/menutree.py "module_tree" >> + ${CMAKE_CURRENT_SOURCE_DIR}/menustrings.py + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/core/menutree.py "psmap" >> + ${CMAKE_CURRENT_SOURCE_DIR}/menustrings.py + DEPENDS build_module_tree_menudata gui_images) diff --git a/gui/wxpython/docs/CMakeLists.txt b/gui/wxpython/docs/CMakeLists.txt new file mode 100644 index 00000000000..a257457fd0b --- /dev/null +++ b/gui/wxpython/docs/CMakeLists.txt @@ -0,0 +1,32 @@ +set(wxpython_html_files + wxGUI.components + wxGUI + wxGUI.iscatt + wxGUI.modules + wxGUI.nviz + wxGUI.toolboxes + wxGUI.vnet) + +add_custom_target(wxpython_docs DEPENDS grass_gis) +add_dependencies(GUI_WXPYTHON wxpython_docs) + +foreach(html_file ${wxpython_html_files}) + add_custom_command( + TARGET wxpython_docs + PRE_BUILD DEPENDS LIB_PYTHON + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ${grass_env_command} ${PYTHON_EXECUTABLE} ${MKHTML_PY} ${html_file} + > ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${html_file}.html + BYPRODUCTS ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${html_file}.html) + install(FILES ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/${html_file}.html + DESTINATION ${GRASS_INSTALL_DOCDIR}) +endforeach() + +file( + GLOB img_files + LIST_DIRECTORIES FALSE + *.png *.jpg) + +if(img_files) + install(FILES ${img_files} DESTINATION ${GRASS_INSTALL_DOCDIR}) +endif() diff --git a/imagery/CMakeLists.txt b/imagery/CMakeLists.txt new file mode 100644 index 00000000000..121bafeaf4a --- /dev/null +++ b/imagery/CMakeLists.txt @@ -0,0 +1,234 @@ +set(imagery_modules_list + i.albedo + i.aster.toar + i.atcorr + i.biomass + i.cca + i.cluster + i.eb.eta + i.eb.evapfr + i.eb.hsebal01 + i.eb.netrad + i.eb.soilheatflux + i.emissivity + i.evapo.mh + i.evapo.pm + i.evapo.pt + i.evapo.time + i.fft + i.find + i.gensig + i.gensigset + i.group + i.his.rgb + i.ifft + i.landsat.acca + i.landsat.toar + i.maxlik + i.modis.qc + i.pca + i.rectify + i.rgb.his + i.segment + i.signatures + i.smap + i.target + i.topo.corr + i.vi + i.zc) + +# TODO: add i.svm.predict and i.svm.train + +add_custom_target( + ALL_IMAGERY_MODULES ALL + DEPENDS ${imagery_modules_list} + COMMENT "All imagery modules are built.") + +if(WITH_DOCS) + generate_html(TARGET ALL_IMAGERY_MODULES NAME imageryintro) + + file(COPY ${CMAKE_SOURCE_DIR}/lib/imagery/band_references_scheme.png + DESTINATION ${OUTDIR}/${GRASS_INSTALL_DOCDIR}) + install(FILES ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/band_references_scheme.png + DESTINATION ${GRASS_INSTALL_DOCDIR}) +endif() + +build_program_in_subdir(i.albedo DEPENDS grass_imagery grass_raster + grass_vector grass_gis) +build_program_in_subdir(i.aster.toar DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) + +build_program_in_subdir( + i.atcorr + DEPENDS + grass_imagery + grass_raster + grass_vector + grass_gis + grass_btree2 + ${LIBM} + SRC_REGEX + "*.cpp") + +build_program_in_subdir(i.biomass DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) +build_program_in_subdir( + i.cca + DEPENDS + grass_imagery + grass_raster + grass_vector + grass_gis + grass_gmath + ${LIBM}) +build_program_in_subdir( + i.cluster + DEPENDS + grass_imagery + grass_raster + grass_vector + grass_gis + grass_cluster) + +build_program_in_subdir(i.eb.evapfr DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) +build_program_in_subdir(i.eb.eta DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) +build_program_in_subdir(i.eb.hsebal01 DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) +build_program_in_subdir(i.eb.netrad DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) +build_program_in_subdir(i.eb.soilheatflux DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) + +build_program_in_subdir(i.evapo.mh DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) +build_program_in_subdir(i.evapo.pm DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) +build_program_in_subdir(i.evapo.pt DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) +build_program_in_subdir(i.evapo.time DEPENDS grass_imagery grass_raster + grass_vector grass_gis) +build_program_in_subdir(i.emissivity DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) +build_program_in_subdir( + i.find + DEPENDS + grass_imagery + grass_raster + grass_vector + grass_gis + PACKAGE + "grassmods" + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_ETCDIR} + NO_DOC) + +build_program_in_subdir(i.gensig DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) + +build_program_in_subdir( + i.gensigset + DEPENDS + grass_imagery + grass_raster + grass_vector + grass_gis + grass_gmath + ${LIBM}) + +build_program_in_subdir(i.group DEPENDS grass_imagery grass_raster grass_vector + grass_gis) + +build_program_in_subdir(i.his.rgb DEPENDS grass_imagery grass_raster + grass_vector grass_gis) + +build_program_in_subdir(i.landsat.toar DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) + +build_program_in_subdir(i.maxlik DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) + +build_program_in_subdir(i.modis.qc DEPENDS grass_imagery grass_raster + grass_vector grass_gis) + +build_program_in_subdir(i.rectify DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) + +build_program_in_subdir(i.rgb.his DEPENDS grass_imagery grass_raster + grass_vector grass_gis) + +build_program_in_subdir( + i.segment + DEPENDS + grass_imagery + grass_raster + grass_vector + grass_gis + grass_segment + ${LIBM}) + +build_program_in_subdir(i.signatures DEPENDS grass_imagery grass_gis) + +build_program_in_subdir( + i.smap + DEPENDS + grass_imagery + grass_raster + grass_vector + grass_gis + grass_gmath + ${LIBM}) + +build_program_in_subdir(i.target DEPENDS grass_imagery grass_raster + grass_vector grass_gis) + +build_program_in_subdir(i.topo.corr DEPENDS grass_imagery grass_raster + grass_vector grass_gis ${LIBM}) + +build_program_in_subdir( + i.pca + DEPENDS + grass_imagery + grass_raster + grass_vector + grass_gis + grass_gmath + ${LIBM}) + +build_program_in_subdir(i.vi DEPENDS grass_imagery grass_raster grass_vector + grass_gis ${LIBM}) + +build_program_in_subdir( + i.zc + DEPENDS + grass_imagery + grass_raster + grass_vector + grass_gis + grass_gmath) + +build_program_in_subdir( + i.fft + DEPENDS + grass_imagery + grass_raster + grass_gmath + grass_gis + PRIMARY_DEPENDS + FFTW) + +build_program_in_subdir( + i.ifft + DEPENDS + grass_gis + grass_raster + grass_gmath + grass_btree2 + PRIMARY_DEPENDS + FFTW) + +build_program_in_subdir(i.landsat.acca DEPENDS grass_raster grass_gis ${LIBM}) + +# TODO: add generate docs for i.ortho.photo +add_subdirectory(i.ortho.photo) diff --git a/imagery/i.ortho.photo/CMakeLists.txt b/imagery/i.ortho.photo/CMakeLists.txt new file mode 100644 index 00000000000..9abcd4a6496 --- /dev/null +++ b/imagery/i.ortho.photo/CMakeLists.txt @@ -0,0 +1,42 @@ +build_library_in_subdir( + lib + NAME + grass_iortho + DEPENDS + grass_gis + grass_imagery + grass_gmath) + +build_program_in_subdir(i.ortho.camera DEPENDS grass_iortho grass_imagery + grass_gis grass_gmath) + +build_program_in_subdir(i.ortho.elev DEPENDS grass_iortho grass_imagery + grass_gis grass_gmath) + +build_program_in_subdir( + i.ortho.init + DEPENDS + grass_iortho + grass_imagery + grass_gis + grass_gmath + grass_raster) + +build_program_in_subdir(i.ortho.photo DEPENDS grass_iortho grass_imagery + grass_gis) + +build_program_in_subdir( + i.ortho.rectify + DEPENDS + grass_iortho + grass_imagery + grass_gis + grass_gmath + grass_raster + ${LIBM}) + +build_program_in_subdir(i.ortho.target DEPENDS grass_iortho grass_imagery + grass_gis) + +build_program_in_subdir(i.ortho.transform DEPENDS grass_iortho grass_imagery + grass_gis grass_gmath ${LIBM}) diff --git a/include/CMakeLists.txt b/include/CMakeLists.txt new file mode 100644 index 00000000000..577fd7bf1eb --- /dev/null +++ b/include/CMakeLists.txt @@ -0,0 +1,47 @@ +file(GLOB_RECURSE SRCHS "*.h") +set(include_depends) +foreach(srch ${SRCHS}) + get_filename_component(srch_DIR ${srch} DIRECTORY) + get_filename_component(srch_NAME ${srch} NAME) + string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" dsth_DIR "${srch_DIR}") + set(output_dir ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/${dsth_DIR}) + add_custom_command( + OUTPUT ${output_dir}/${srch_NAME} + COMMAND ${CMAKE_COMMAND} -E make_directory ${output_dir} + COMMAND ${CMAKE_COMMAND} -E copy ${srch} ${output_dir} + COMMENT "Copy ${srch} to ${output_dir}/${srch_NAME}") + list(APPEND include_depends ${output_dir}/${srch_NAME}) +endforeach() + +add_custom_target(copy_header DEPENDS ${include_depends} LIB_PYTHON) + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/grass/version.h.in + "${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/version.h") + +message(STATUS "Creating ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/config.h") + +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake.in + "${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/config.h") + +# TODO: this presently skips empty lines, but should be included +file(WRITE ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/copying.h "") +file(STRINGS ${CMAKE_SOURCE_DIR}/COPYING copying_lines) +foreach(copying_line ${copying_lines}) + file(APPEND ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/copying.h + "\"${copying_line} \\n\"\n") +endforeach() + +# TODO: this presently skips empty lines, but should be included +file(WRITE ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/citing.h "") +file(STRINGS ${CMAKE_SOURCE_DIR}/CITING citing_lines) +foreach(citing_line ${citing_lines}) + file(APPEND ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/citing.h + "\"${citing_line}\\n\"\n") +endforeach() + +# TODO file(READ ${CMAKE_SOURCE_DIR}/config.status config_status_header) +file(WRITE ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/confparms.h + "\"/* */\\n\"") + +install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/ + DESTINATION ${GRASS_INSTALL_INCLUDEDIR}) diff --git a/include/Make/Install.make b/include/Make/Install.make index b9a5e45e0fc..799a695e80d 100644 --- a/include/Make/Install.make +++ b/include/Make/Install.make @@ -122,7 +122,7 @@ $(DESTDIR)$(INST_DIR) $(DESTDIR)$(UNIX_BIN): $(MAKE_DIR_CMD) $@ $(STARTUP): $(ARCH_DISTDIR)/$(GRASS_NAME).tmp - sed -e 's#'@GISBASE@'#'$(INST_DIR)'#g' \ + sed -e 's#'@GISBASE_INSTALL_PATH@'#'$(INST_DIR)'#g' \ -e 's#'@LD_LIBRARY_PATH_VAR@'#'$(LD_LIBRARY_PATH_VAR)'#g' \ -e 's#'@CONFIG_PROJSHARE@'#'$(PROJSHARE)'#g' \ $< > $@ diff --git a/include/config.h.cmake.in b/include/config.h.cmake.in new file mode 100644 index 00000000000..19c9b36e3c6 --- /dev/null +++ b/include/config.h.cmake.in @@ -0,0 +1,447 @@ +/* + #Generated by cmake from include/config.h.cmake.in + * config.h.cmake.in + */ + +#ifndef _config_h +#define _config_h + +#cmakedefine GDEBUG ${GDEBUG} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_AD2_H ${HAVE_AD2_H} + +/* Define to 1 if you have the `asprintf' function. */ +#cmakedefine HAVE_ASPRINTF ${HAVE_ASPRINTF} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_BZLIB_H ${HAVE_BZLIB_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_CAIRO_H ${HAVE_CAIRO_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_CBLAS_H ${HAVE_CBLAS_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_CLAPACK_H ${HAVE_CLAPACK_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_CL_CL_H ${HAVE_CL_CL_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_DFFTW_H ${HAVE_DFFTW_H} + +/* Define to 1 if you have the `drand48' function. */ +#cmakedefine HAVE_DRAND48 ${HAVE_DRAND48} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_F2C_H ${HAVE_F2C_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_FFTW3_H ${HAVE_FFTW3_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_FFTW_H ${HAVE_FFTW_H} + +/* Define if fseeko (and presumably ftello) exists and is declared. */ +#cmakedefine HAVE_FSEEKO ${HAVE_FSEEKO} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_FT2BUILD_H ${HAVE_FT2BUILD_H} + +/* Define to 1 if you have the `ftime' function. */ +#cmakedefine HAVE_FTIME ${HAVE_FTIME} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_G2C_H ${HAVE_G2C_H} + +/* Define to 1 if GDAL is to be used. */ +#cmakedefine HAVE_GDAL ${HAVE_GDAL} + +/* Define to 1 if GEOS is to be used. */ +#cmakedefine HAVE_GEOS ${HAVE_GEOS} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_GEOS_C_H ${HAVE_GEOS_C_H} + +/* Define to 1 if you have the `gethostname' function. */ +#cmakedefine HAVE_GETHOSTNAME ${HAVE_GETHOSTNAME} + +/* Define to 1 if you have the `gettimeofday' function. */ +#cmakedefine HAVE_GETTIMEOFDAY ${HAVE_GETTIMEOFDAY} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_GL_GLU_H ${HAVE_GL_GLU_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_GL_GL_H ${HAVE_GL_GL_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_ICONV_H ${HAVE_ICONV_H} + +/* Define to 1 if "int64_t" is available. */ +#cmakedefine HAVE_INT64_T ${HAVE_INT64_T} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_INTTYPES_H ${HAVE_INTTYPES_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_LANGINFO_H ${HAVE_LANGINFO_H} + +/* Define to 1 if ATLAS exists. */ +#cmakedefine HAVE_LIBATLAS ${HAVE_LIBATLAS} + +/* Define to 1 if BLAS exists. */ +#cmakedefine HAVE_LIBBLAS ${HAVE_LIBBLAS} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_LIBINTL_H ${HAVE_LIBINTL_H} + +/* Define to 1 if LAPACK exists. */ +#cmakedefine HAVE_LIBLAPACK ${HAVE_LIBLAPACK} + +/* Define to 1 if liblas exists. */ +#cmakedefine HAVE_LIBLAS {HAVE_LIBLAS} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_LIBLAS_CAPI_LIBLAS_H ${HAVE_LIBLAS_CAPI_LIBLAS_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_LIBPQ_FE_H ${HAVE_LIBPQ_FE_H} + +/* Define to 1 if using LIBSVM. */ +#cmakedefine HAVE_LIBSVM ${HAVE_LIBSVM} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_LIBSVM_SVM_H ${HAVE_LIBSVM_SVM_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_LIMITS_H ${HAVE_LIMITS_H} + +/* Define to 1 if "long long int" is available. */ +#cmakedefine HAVE_LONG_LONG_INT ${HAVE_LONG_LONG_INT} + +/* Define to 1 if you have the `lseek' function. */ +#cmakedefine HAVE_LSEEK ${HAVE_LSEEK} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_MYSQL_H ${HAVE_MYSQL_H} + +/* Define to 1 if you have the `nanosleep' function. */ +#cmakedefine HAVE_NANOSLEEP ${HAVE_NANOSLEEP} + +/* Define to 1 if NetCDF exists. */ +#cmakedefine HAVE_NETCDF ${HAVE_NETCDF} + +/* Define to 1 if you have the `nice' function. */ +#cmakedefine HAVE_NICE ${HAVE_NICE} + +/* Define to 1 if OGR is to be used. */ +#cmakedefine HAVE_OGR {HAVE_OGR} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_OMP_H ${HAVE_OMP_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_OPENCL_OPENCL_H ${HAVE_OPENCL_OPENCL_H} + +/* Define to 1 if glXCreatePbuffer exists. */ +#cmakedefine HAVE_PBUFFERS ${HAVE_PBUFFERS} + +/* Define to 1 if PDAL exists. */ +#cmakedefine HAVE_PDAL ${HAVE_PDAL} + +/* Define to 1 if PDAL NoFilenameWriter is present. */ +#cmakedefine HAVE_PDAL_NOFILENAMEWRITER ${HAVE_PDAL_NOFILENAMEWRITER} + +/* Define to 1 if glXCreateGLXPixmap exists. */ +#cmakedefine HAVE_PIXMAPS ${HAVE_PIXMAPS} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_PNG_H ${HAVE_PNG_H} + +/* Define to 1 if PostgreSQL is to be used. */ +#cmakedefine HAVE_POSTGRES ${HAVE_POSTGRES} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_PROJ_API_H ${HAVE_PROJ_API_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_PROJ_H ${HAVE_PROJ_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_PTHREAD_H ${HAVE_PTHREAD_H} + +/* Define to 1 if you have the `putenv' function. */ +#cmakedefine HAVE_PUTENV ${HAVE_PUTENV} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_READLINE_HISTORY_H ${HAVE_READLINE_HISTORY_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_READLINE_READLINE_H ${HAVE_READLINE_READLINE_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_REGEX_H ${HAVE_REGEX_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_PCRE_H ${HAVE_PCRE_H} + +/* Define to 1 if you have the `setenv' function. */ +#cmakedefine HAVE_SETENV ${HAVE_SETENV} + +/* Define to 1 if you have the `seteuid' function. */ +#cmakedefine HAVE_SETEUID ${HAVE_SETEUID} + +/* Define to 1 if you have the `setpriority' function. */ +#cmakedefine HAVE_SETPRIORITY ${HAVE_SETPRIORITY} + +/* Define to 1 if you have the `setreuid' function. */ +#cmakedefine HAVE_SETREUID ${HAVE_SETREUID} + +/* Define to 1 if you have the `setruid' function. */ +#cmakedefine HAVE_SETRUID ${HAVE_SETRUID} + +/* define if socket() exists */ +#cmakedefine HAVE_SOCKET ${HAVE_SOCKET} + +/* Define to 1 if SQLite is to be used. */ +#cmakedefine HAVE_SQLITE ${HAVE_SQLITE} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SQLITE3_H ${HAVE_SQLITE3_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SQL_H ${HAVE_SQLITE3_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_STDINT_H ${HAVE_STDINT_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_STDIO_H ${HAVE_STDIO_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_STDLIB_H ${HAVE_STDLIB_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_STRINGS_H ${HAVE_STRINGS_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_STRING_H ${HAVE_STRING_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SVM_H ${HAVE_SVM_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_IOCTL_H ${HAVE_SYS_IOCTL_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_MTIO_H ${HAVE_SYS_MTIO_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_RESOURCE_H ${HAVE_SYS_RESOURCE_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_STAT_H ${HAVE_SYS_STAT_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_TIMEB_H ${HAVE_SYS_TIMEB_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_TIME_H ${HAVE_SYS_TIME_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_TYPES_H ${HAVE_SYS_TYPES_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_SYS_UTSNAME_H ${HAVE_SYS_UTSNAME_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_TERMIOS_H ${HAVE_TERMIOS_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_TERMIO_H ${HAVE_TERMIO_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_TIFFIO_H ${HAVE_TIFFIO_H} + +/* Define to 1 if you have the `time' function. */ +#cmakedefine HAVE_TIME ${HAVE_TIME} + +/* Define to 1 if you have the `uname' function. */ +#cmakedefine HAVE_UNAME ${HAVE_UNAME} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_UNISTD_H ${HAVE_UNISTD_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_VALUES_H ${HAVE_VALUES_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_WINDOWS_H ${HAVE_WINDOWS_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_ZLIB_H ${HAVE_ZLIB_H} + +/* Define to 1 if you have the header file. */ +#cmakedefine HAVE_ZSTD_H ${HAVE_ZSTD_H} + +// TODO: look at this for a more proper fix +/* Define to 1 if OpenGL uses Aqua (MacOS X). */ +#cmakedefine OPENGL_AQUA ${OPENGL_AQUA} +#cmakedefine OPENGL_AGL ${OPENGL_AQUA} + +/* Define to 1 if OpenGL uses Windows. */ +#cmakedefine OPENGL_WINDOWS ${OPENGL_WINDOWS} + +/* Define to 1 if OpenGL uses X11. */ +#cmakedefine OPENGL_X11 ${OPENGL_X11} + +/* Define to the address where bug reports for this package should be sent. */ +#cmakedefine PACKAGE_BUGREPORT ${PACKAGE_BUGREPORT} + +/* Define to the full name of this package. */ +#cmakedefine PACKAGE_NAME ${PACKAGE_NAME} + +/* Define to the full name and version of this package. */ +#cmakedefine PACKAGE_STRING ${PACKAGE_STRING} + +/* Define to the one symbol short name of this package. */ +#cmakedefine PACKAGE_TARNAME ${PACKAGE_TARNAME} + +/* Define to the home page for this package. */ +#cmakedefine PACKAGE_URL ${PACKAGE_URL} + +/* Define to the version of this package. */ +#cmakedefine PACKAGE_VERSION ${PACKAGE_VERSION} + +/* Define to 1 if the `setpgrp' function requires zero arguments. */ +#cmakedefine SETPGRP_VOID ${SETPGRP_VOID} + +/* Define to 1 for Windows static build. */ +#cmakedefine STATIC_BUILD ${STATIC_BUILD} + +/* Define to 1 if all of the C90 standard headers exist (not just the ones + required in a freestanding environment). This macro is provided for + backward compatibility; new code need not use it. */ +#cmakedefine STDC_HEADERS ${STDC_HEADERS} + +/* Define to 1 if NLS requested. */ +#cmakedefine USE_NLS ${USE_NLS} + +/* Define to 1 if using old PROJ version 4 API. */ +#cmakedefine USE_PROJ4API ${USE_PROJ4API} + +/* Define to 1 if the X Window System is missing or not being used. */ +#cmakedefine X_DISPLAY_MISSING ${X_DISPLAY_MISSING} + +/* Define to 1 if `lex' declares `yytext' as a `char *' by default, not a + `char[]'. */ +#cmakedefine YYTEXT_POINTER ${YYTEXT_POINTER} + +/* Number of bits in a file offset, on hosts where this is settable. */ +#cmakedefine _FILE_OFFSET_BITS ${_FILE_OFFSET_BITS} + +/* Define to make fseeko visible on some hosts (e.g. glibc 2.2). */ +#cmakedefine _LARGEFILE_SOURCE ${_LARGEFILE_SOURCE} + +/* Define for large files, on AIX-style hosts. */ +#cmakedefine _LARGE_FILES ${_LARGE_FILES} + +/* Define to 1 to enable threading extensions on Solaris. */ +#cmakedefine _POSIX_PTHREAD_SEMANTICS ${_POSIX_PTHREAD_SEMANTICS} + +/* Define to 1 for _REENTRANT flag (for SunOS). */ +#cmakedefine _REENTRANT ${_REENTRANT} + +/* + * configuration information solely dependent on the above + * nothing below this point should need changing + */ + +#if defined(HAVE_VALUES_H) && !defined(HAVE_LIMITS_H) +#define INT_MIN -MAXINT +#endif + +/* + * Defines needed to get large file support - from cdrtools-2.01 + */ + +#cmakedefine HAVE_LARGEFILES ${HAVE_LARGEFILES} + +/* define if langinfo.h exists */ +#cmakedefine HAVE_LANGINFO_H ${HAVE_LANGINFO_H} + +#if defined(__MINGW32__) && defined(HAVE_LARGEFILES) && (!defined(_FILE_OFFSET_BITS) || (_FILE_OFFSET_BITS != 64)) +/* add/remove as needed */ +/* redefine off_t */ +#include +#define off_t off64_t +/* fseeko and ftello are safe because not defined by MINGW */ +#define HAVE_FSEEKO +#define fseeko fseeko64 +#define ftello ftello64 +/* redefine lseek */ +#include +#define lseek lseek64 +/* redefine stat and fstat */ +/* use _stati64 compatible with MSVCRT < 6.1 */ +#include +#define stat _stati64 +#define fstat _fstati64 + +#endif /* MINGW32 LFS */ + +#ifdef _MSC_VER + +#ifdef HAVE_LARGEFILES +#include +#define off_t __int64 +#include +#define fseek _fseeki64 +#define ftell _ftelli64 +#include +#undef lseek +#define lseek _lseeki64 +#include +#define stat _stati64 +#define fstat _fstati64 +#endif /* _MSC_VER LFS */ + +#define strncasecmp _strnicmp +#define strcasecmp _stricmp +#define fdopen _fdopen +/* _open() and _creat() are wrapped by msvc/open.c and msvc/creat.c, +* respectively, for compatible permission mode */ +#define read _read +#define write _write +#define close _close +#define unlink _unlink +#define getpid _getpid + +/* define gid_t type */ +typedef @GID_TYPE@ gid_t; + +/* define uid_t type */ +typedef @UID_TYPE@ uid_t; + +/* define pid_t type */ +typedef @PID_TYPE@ pid_t; + +#ifndef S_ISDIR +#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) +#endif + +#include +typedef SSIZE_T ssize_t; + +/* open for reading, writing, or both (not in fcntl.h) */ +#define O_ACCMODE (_O_RDONLY | _O_WRONLY | _O_RDWR) + +#endif //_MSC_VER + +/* To include export.h generated by cmake */ + +#define GRASS_CMAKE_BUILD 1 +#endif /* _config_h */ diff --git a/include/grass/calc.h b/include/grass/calc.h index 9b22a847160..ab89ef3155c 100644 --- a/include/grass/calc.h +++ b/include/grass/calc.h @@ -31,12 +31,18 @@ typedef struct func_desc { #define SET_NULL_F(x) (Rast_set_f_null_value((x), 1)) #define SET_NULL_D(x) (Rast_set_d_null_value((x), 1)) -extern volatile int floating_point_exception; -extern volatile int floating_point_exception_occurred; +#ifdef GRASS_CMAKE_BUILD +#include +#else +#define GRASS_CALC_EXPORT +#endif + +extern GRASS_CALC_EXPORT volatile int floating_point_exception; +extern GRASS_CALC_EXPORT volatile int floating_point_exception_occurred; extern int columns; -extern func_desc calc_func_descs[]; +extern GRASS_CALC_EXPORT func_desc calc_func_descs[]; #include diff --git a/include/grass/config.h.in b/include/grass/config.h.in index 8e04583d6de..ec01b623faa 100644 --- a/include/grass/config.h.in +++ b/include/grass/config.h.in @@ -188,6 +188,9 @@ /* Define to 1 if you have the header file. */ #undef HAVE_REGEX_H +/* Define to 1 if you have the header file. */ +#undef HAVE_PCRE_H + /* Define to 1 if you have the `setenv' function. */ #undef HAVE_SETENV diff --git a/include/grass/defs/gis.h b/include/grass/defs/gis.h index dc5ad2499f0..8bacb260cc2 100644 --- a/include/grass/defs/gis.h +++ b/include/grass/defs/gis.h @@ -485,7 +485,7 @@ void G_ls(const char *, FILE *); void G_ls_format(char **, int, int, FILE *); /* ls_filter.c */ -#ifdef HAVE_REGEX_H +#if defined(HAVE_REGEX_H) || defined(HAVE_PCRE_H) void *G_ls_regex_filter(const char *, int, int, int); void *G_ls_glob_filter(const char *, int, int); void G_free_ls_filter(void *); diff --git a/include/grass/defs/glocale.h b/include/grass/defs/glocale.h index a14b2e4cebe..b153afe21d5 100644 --- a/include/grass/defs/glocale.h +++ b/include/grass/defs/glocale.h @@ -1,6 +1,11 @@ #ifndef GRASS_GLOCALEDEFS_H #define GRASS_GLOCALEDEFS_H +#if !defined __GNUC__ || __GNUC__ < 2 +#undef __attribute__ +#define __attribute__(x) +#endif + extern void G_init_locale(void); extern char *G_gettext(const char *, const char *) __attribute__((format_arg(2))); diff --git a/include/grass/iostream/mm.h b/include/grass/iostream/mm.h index 38b1feb9377..5b5cfa1e2d9 100644 --- a/include/grass/iostream/mm.h +++ b/include/grass/iostream/mm.h @@ -79,9 +79,15 @@ enum MM_stream_usage { MM_STREAM_USAGE_MAXIMUM }; +#ifdef GRASS_CMAKE_BUILD +#include +#else +#define GRASS_IOSTREAM_EXPORT +#endif + // Declarations of a very simple memory manager designed to work with // BTEs that rely on the underlying OS to manage physical memory. -class MM_register { +class GRASS_IOSTREAM_EXPORT MM_register { private: // The number of instances of this class and descendents that exist. static int instances; @@ -155,6 +161,6 @@ class mm_register_init { static mm_register_init source_file_mm_register_init; // Here is the single memory management object (defined in mm.C). -extern MM_register MM_manager; +extern GRASS_IOSTREAM_EXPORT MM_register MM_manager; #endif // _MM_H diff --git a/include/grass/iostream/rtimer.h b/include/grass/iostream/rtimer.h index 547dbeca5ec..9bda4ac9193 100644 --- a/include/grass/iostream/rtimer.h +++ b/include/grass/iostream/rtimer.h @@ -36,13 +36,14 @@ #ifndef RTIMER_H #define RTIMER_H -#ifdef __MINGW32__ +#ifdef _WIN32 #include #include #include +#ifdef __MINGW32__ #include - +#endif typedef struct { time_t tv1, tv2; } Rtimer; diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt new file mode 100644 index 00000000000..dd40c017cd8 --- /dev/null +++ b/lib/CMakeLists.txt @@ -0,0 +1,251 @@ +set(use_math_DEFS "") +if(MSVC) + set(use_math_DEFS "-D_USE_MATH_DEFINES=1") +endif() + +build_library_in_subdir(datetime) + +add_subdirectory(gis) + +build_library_in_subdir( + driver + DEFS + "${use_math_DEFS}" + DEPENDS + grass_gis + FREETYPE + ICONV + ZLIB) + +add_subdirectory(proj) + +build_library_in_subdir(external/parson NAME grass_parson HEADERS "gjson.h" "parson.h") + +build_library_in_subdir( + raster + DEFS + "-DGDAL_LINK=1" + DEPENDS + GDAL + PROJ + grass_gis + grass_gproj + grass_parson) + +if(TARGET LAPACKE) + target_link_libraries(grass_raster PRIVATE LAPACKE) +endif() + +if(CMAKE_SYSTEM_NAME MATCHES "Linux") + find_library(DL_LIBRARY dl) + mark_as_advanced(DL_LIBRARY) + target_link_libraries(grass_raster PRIVATE ${DL_LIBRARY}) +endif() + +configure_file( + external/ccmath/ccmath.h + ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/ccmath_grass.h COPYONLY) +build_library_in_subdir(external/ccmath) + +build_library_in_subdir(external/shapelib NAME grass_shape HEADERS "shapefil.h") + +build_library_in_subdir( + gmath + DEPENDS + grass_ccmath + grass_gis + DEFS + "${use_math_DEFS}" + OPTIONAL_DEPENDS + FFTW + LAPACKE + CBLAS + OPENMP) + +build_library_in_subdir(linkm) + +file(GLOB pngdriver_SRCS "./pngdriver/*.c") +if(NOT WITH_LIBPNG) + list(FILTER pngdriver_SRCS EXCLUDE REGEX [[./pngdriver/.*_png\.c$]]) +endif() +build_library_in_subdir( + pngdriver + SOURCES + ${pngdriver_SRCS} + DEPENDS + grass_driver + grass_gis + ZLIB + OPTIONAL_DEPENDS + LIBPNG) + +build_library_in_subdir( + psdriver + DEPENDS + grass_driver + grass_gis + INCLUDES + "./driver") +add_custom_command( + TARGET grass_psdriver + POST_BUILD + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/psdriver/psdriver.ps + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/psdriver.ps) +install(FILES ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/psdriver.ps + DESTINATION ${GRASS_INSTALL_ETCDIR}) + +build_library_in_subdir( + htmldriver + DEPENDS + grass_gis + grass_driver + INCLUDES + "./driver") + +set(_grass_display_DEFS) + +set(_grass_display_DEPENDS grass_driver grass_raster grass_htmldriver + grass_pngdriver grass_psdriver grass_gis) + +if(WITH_CAIRO) + set(_cairodriver_DEPENDS CAIRO FREETYPE grass_gis grass_driver ICONV) + if(WITH_X11) + list(APPEND _cairodriver_DEPENDS X11) + endif() + + build_library_in_subdir(cairodriver DEPENDS ${_cairodriver_DEPENDS}) + + set(_grass_display_DEFS "-DUSE_CAIRO") + list(APPEND _grass_display_DEPENDS grass_cairodriver) +endif() + +build_library_in_subdir(bitmap SOURCES "./bitmap/bitmap.c" "./bitmap/sparse.c" + DEPENDS grass_linkm) + +build_library_in_subdir(btree) + +build_library_in_subdir(btree2 HEADERS "kdtree.h" DEPENDS grass_gis) + +build_library_in_subdir(display DEFS ${_grass_display_DEFS} DEPENDS + ${_grass_display_DEPENDS}) + +add_subdirectory(db) + +add_subdirectory(fonts) + +add_subdirectory(vector) + +build_library_in_subdir(imagery DEPENDS grass_gis grass_vector grass_raster GDAL) + +build_library_in_subdir(cluster DEPENDS grass_imagery grass_gis grass_raster) + +build_library_in_subdir(rowio DEPENDS grass_gis) + +build_library_in_subdir(segment DEPENDS grass_gis) # addeed DEPENDS grass_gis + # for uninstd.h + +add_subdirectory(rst) + +build_library_in_subdir( + lidar + DEPENDS + grass_gis + grass_vector + grass_raster + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gmath + grass_segment + GDAL + HEADERS + "lidar.h") + +build_library_in_subdir(raster3d NAME grass_raster3d DEPENDS grass_raster + grass_gis) + +build_program_in_subdir( + raster3d/test + NAME + test.raster3d.lib + DEPENDS + grass_gis + grass_raster3d + grass_raster + GDAL) + +build_library_in_subdir( + gpde + HEADERS + "N_*.h" + DEPENDS + grass_gis + grass_raster + grass_raster3d + grass_gmath + ${LIBM} + OPTIONAL_DEPENDS + OPENMP) + +build_library_in_subdir(dspf DEPENDS grass_gis) + +build_library_in_subdir(symbol NAME grass_symb DEPENDS grass_gis) +add_custom_command( + TARGET grass_symb + POST_BUILD + COMMAND + ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_SOURCE_DIR}/symbol/symbol + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/symbol) +install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/symbol + DESTINATION ${GRASS_INSTALL_ETCDIR}) + +add_subdirectory(init) + +build_library_in_subdir(cdhc DEPENDS grass_gis grass_raster) + +build_library_in_subdir(stats DEPENDS grass_gis grass_raster) + +build_library_in_subdir(arraystats DEPENDS grass_gis) + +if(WITH_OPENGL) + build_library_in_subdir( + ogsf + DEPENDS + grass_bitmap + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_raster3d + grass_vector + GDAL + OPENGL + TIFF) + + build_library_in_subdir( + nviz + DEPENDS + grass_display + grass_raster + grass_vector + grass_bitmap + grass_ogsf + grass_gis + OPENGL + TIFF) +endif() + +add_subdirectory(temporal) + +build_library_in_subdir(iostream SRC_REGEX "*.cpp" DEPENDS grass_gis) + +build_library_in_subdir(manage DEPENDS grass_gis grass_raster grass_vector + grass_raster3d GDAL) +file(COPY manage/element_list DESTINATION ${OUTDIR}/${GRASS_INSTALL_ETCDIR}) +install(FILES ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/element_list + DESTINATION ${GRASS_INSTALL_ETCDIR}) + +build_library_in_subdir(calc DEPENDS grass_raster grass_gis) diff --git a/lib/cairodriver/graph.c b/lib/cairodriver/graph.c index 529cc65d347..db2fa62e45f 100644 --- a/lib/cairodriver/graph.c +++ b/lib/cairodriver/graph.c @@ -29,7 +29,7 @@ #endif #include -#ifndef __MINGW32__ +#ifndef _WIN32 #include #include #include @@ -389,7 +389,7 @@ static int ends_with(const char *string, const char *suffix) static void map_file(void) { -#ifndef __MINGW32__ +#ifndef _WIN32 size_t size = HEADER_SIZE + ca.width * ca.height * sizeof(unsigned int); void *ptr; int fd; diff --git a/lib/cairodriver/text.c b/lib/cairodriver/text.c index 49c8e80cd93..12f22172071 100644 --- a/lib/cairodriver/text.c +++ b/lib/cairodriver/text.c @@ -11,6 +11,9 @@ \author Lars Ahlzen (original contributor) \author Glynn Clements */ +#if defined(_MSC_VER) +#include +#endif #include #include "cairodriver.h" diff --git a/lib/calc/calc.c b/lib/calc/calc.c index 4894d4e14da..031a97150e5 100644 --- a/lib/calc/calc.c +++ b/lib/calc/calc.c @@ -20,7 +20,7 @@ static void handle_fpe(int n UNUSED) void pre_exec(void) { -#ifndef __MINGW32__ +#ifndef _WIN32 #ifdef SIGFPE struct sigaction act; @@ -37,7 +37,7 @@ void pre_exec(void) void post_exec(void) { -#ifndef __MINGW32__ +#ifndef _WIN32 #ifdef SIGFPE struct sigaction act; diff --git a/lib/db/CMakeLists.txt b/lib/db/CMakeLists.txt new file mode 100644 index 00000000000..fb61243b6f2 --- /dev/null +++ b/lib/db/CMakeLists.txt @@ -0,0 +1,44 @@ +file(GLOB dbmibase_SRCS "./dbmi_base/*.c") +if(MSVC) + set(dbmibase_INCLUDES "./dbmi_base" "../../msvc") + list(APPEND dbmibase_SRCS "../../msvc/dirent.c") +endif() + +build_library_in_subdir( + dbmi_base + NAME + grass_dbmibase + INCLUDES + ${dbmibase_INCLUDES} + SOURCES + ${dbmibase_SRCS} + DEPENDS + grass_gis + HEADERS + "dbstubs.h") + +build_library_in_subdir( + dbmi_client + NAME + grass_dbmiclient + DEPENDS + grass_dbmibase + grass_gis + INCLUDES + "./dbmi_base") + +build_library_in_subdir(stubs NAME grass_dbstubs DEPENDS grass_gis + grass_dbmibase) + +build_library_in_subdir( + dbmi_driver + NAME + grass_dbmidriver + DEPENDS + grass_dbmibase + grass_dbstubs + grass_gis + INCLUDES + "./dbmi_base") + +add_subdirectory(sqlp) diff --git a/lib/db/dbmi_base/dbmscap.c b/lib/db/dbmi_base/dbmscap.c index 25f1e0a1eec..c6ce8f755de 100644 --- a/lib/db/dbmi_base/dbmscap.c +++ b/lib/db/dbmi_base/dbmscap.c @@ -156,7 +156,7 @@ dbDbmscap *db_read_dbmscap(void) /* START OF NEW CODE FOR SEARCH IN $(GISBASE)/driver/db/ */ /* opend db drivers directory */ -#ifdef __MINGW32__ +#ifdef _WIN32 dirpath = G_malloc(strlen("\\driver\\db\\") + strlen(G_gisbase()) + 1); sprintf(dirpath, "%s\\driver\\db\\", G_gisbase()); G_convert_dirseps_to_host(dirpath); @@ -179,7 +179,7 @@ dbDbmscap *db_read_dbmscap(void) if ((strcmp(ent->d_name, ".") == 0) || (strcmp(ent->d_name, "..") == 0)) continue; -#ifdef __MINGW32__ +#ifdef _WIN32 /* skip manifest files on Windows */ if (strstr(ent->d_name, ".manifest")) continue; @@ -188,7 +188,7 @@ dbDbmscap *db_read_dbmscap(void) /* Remove '.exe' from name (windows extension) */ name = G_str_replace(ent->d_name, ".exe", ""); -#ifdef __MINGW32__ +#ifdef _WIN32 dirpath = G_malloc(strlen("\\driver\\db\\") + strlen(G_gisbase()) + strlen(ent->d_name) + 1); sprintf(dirpath, "%s\\driver\\db\\%s", G_gisbase(), ent->d_name); diff --git a/lib/db/dbmi_base/dirent.c b/lib/db/dbmi_base/dirent.c index 1823ba64726..708795bd4da 100644 --- a/lib/db/dbmi_base/dirent.c +++ b/lib/db/dbmi_base/dirent.c @@ -22,6 +22,7 @@ /* NOTE: these should come from or from */ #ifndef R_OK +#if !defined(HAVE_UNISTD_H) #define R_OK 4 #endif #ifndef W_OK @@ -30,6 +31,7 @@ #ifndef X_OK #define X_OK 1 #endif +#endif static int cmp_dirent(const void *, const void *); static int get_perm(char *); diff --git a/lib/db/dbmi_base/login.c b/lib/db/dbmi_base/login.c index 9c865233d2c..d6e2a704c70 100644 --- a/lib/db/dbmi_base/login.c +++ b/lib/db/dbmi_base/login.c @@ -167,8 +167,9 @@ static int write_file(LOGIN *login) /* fchmod is not available on Windows */ /* fchmod ( fileno(fd), S_IRUSR | S_IWUSR ); */ +#ifndef _MSC_VER chmod(file, S_IRUSR | S_IWUSR); - +#endif for (i = 0; i < login->n; i++) { fprintf(fd, "%s|%s", login->data[i].driver, login->data[i].database); if (login->data[i].user) { diff --git a/lib/db/dbmi_client/start.c b/lib/db/dbmi_client/start.c index bc801685593..9017f31d4cc 100644 --- a/lib/db/dbmi_client/start.c +++ b/lib/db/dbmi_client/start.c @@ -16,7 +16,7 @@ #include #include -#ifdef __MINGW32__ +#ifdef _WIN32 #include #include #include @@ -30,7 +30,7 @@ static void close_on_exec(int fd) { -#ifndef __MINGW32__ +#ifndef _WIN32 int flags = fcntl(fd, F_GETFD); fcntl(fd, F_SETFD, flags | FD_CLOEXEC); @@ -136,7 +136,7 @@ dbDriver *db_start_driver(const char *name) /* run the driver as a child process and create pipes to its stdin, stdout */ -#ifdef __MINGW32__ +#ifdef _WIN32 #define pipe(fds) _pipe(fds, 250000, _O_BINARY | _O_NOINHERIT) #endif diff --git a/lib/db/sqlp/CMakeLists.txt b/lib/db/sqlp/CMakeLists.txt new file mode 100644 index 00000000000..6cdc6a88ac8 --- /dev/null +++ b/lib/db/sqlp/CMakeLists.txt @@ -0,0 +1,13 @@ +flex_target(sqlp.yy.c sqlp.l ${CMAKE_CURRENT_BINARY_DIR}/sqlp.yy.c) + +bison_target(sqlp.tab.c sqlp.y ${CMAKE_CURRENT_BINARY_DIR}/sqlp.tab.c) + +add_flex_bison_dependency(sqlp.yy.c sqlp.tab.c) + +set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/sqlp.yy.c GENERATED) +set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/sqlp.tab.c GENERATED) + +set(sqlp_SRCS alloc.c print.c sql.c ${CMAKE_CURRENT_BINARY_DIR}/sqlp.tab.c + ${CMAKE_CURRENT_BINARY_DIR}/sqlp.yy.c) + +build_module(NAME grass_sqlp SOURCES "${sqlp_SRCS}" NO_DOCS) diff --git a/lib/driver/driver.h b/lib/driver/driver.h index 5a757a323da..9a9763d456b 100644 --- a/lib/driver/driver.h +++ b/lib/driver/driver.h @@ -3,18 +3,24 @@ #include -extern int screen_width; -extern int screen_height; +#ifdef GRASS_CMAKE_BUILD +#include +#else +#define GRASS_DRIVER_EXPORT +#endif -extern double cur_x; -extern double cur_y; +GRASS_DRIVER_EXPORT extern int screen_width; +GRASS_DRIVER_EXPORT extern int screen_height; -extern double text_size_x; -extern double text_size_y; -extern double text_rotation; +GRASS_DRIVER_EXPORT extern double cur_x; +GRASS_DRIVER_EXPORT extern double cur_y; + +GRASS_DRIVER_EXPORT extern double text_size_x; +GRASS_DRIVER_EXPORT extern double text_size_y; +GRASS_DRIVER_EXPORT extern double text_rotation; extern double text_sinrot; extern double text_cosrot; -extern int matrix_valid; +GRASS_DRIVER_EXPORT extern int matrix_valid; extern struct GFONT_CAP *ftcap; diff --git a/lib/driver/init.c b/lib/driver/init.c index c170037e88b..0cddc814ca9 100644 --- a/lib/driver/init.c +++ b/lib/driver/init.c @@ -26,18 +26,18 @@ const struct driver *driver; struct GFONT_CAP *ftcap; -int screen_width; -int screen_height; +GRASS_DRIVER_EXPORT int screen_width; +GRASS_DRIVER_EXPORT int screen_height; -double cur_x; -double cur_y; +GRASS_DRIVER_EXPORT double cur_x; +GRASS_DRIVER_EXPORT double cur_y; -double text_size_x; -double text_size_y; -double text_rotation; +GRASS_DRIVER_EXPORT double text_size_x; +GRASS_DRIVER_EXPORT double text_size_y; +GRASS_DRIVER_EXPORT double text_rotation; double text_sinrot; double text_cosrot; -int matrix_valid; +GRASS_DRIVER_EXPORT int matrix_valid; /*! \brief Initialize display driver diff --git a/lib/dspf/viz.h b/lib/dspf/viz.h index 92abb658908..8fc8b6cf819 100644 --- a/lib/dspf/viz.h +++ b/lib/dspf/viz.h @@ -90,5 +90,9 @@ int print_head_info(file_info *); /* struct_copy.c */ int struct_copy(char *, char *, int); - -extern CELL_ENTRY cell_table[]; +#ifdef GRASS_CMAKE_BUILD +#include +#else +#define GRASS_DSPF_EXPORT +#endif +extern GRASS_DSPF_EXPORT CELL_ENTRY cell_table[]; diff --git a/lib/external/ccmath/ccmath.h b/lib/external/ccmath/ccmath.h index 5774271c2d9..d977c3791da 100644 --- a/lib/external/ccmath/ccmath.h +++ b/lib/external/ccmath/ccmath.h @@ -33,12 +33,19 @@ #endif /* Complex Types */ - #ifndef CPX +#ifndef _MSC_VER struct complex { double re, im; }; typedef struct complex Cpx; +#else +/* _MSVC has complex struct and cannot be used */ +struct gcomplex { + double re, im; +}; +typedef struct gcomplex Cpx; +#endif /* _MSC_VER */ #define CPX 1 #endif @@ -169,6 +176,8 @@ void unitary(Cpx *u, int n); void hmgen(Cpx *h, double *eval, Cpx *u, int n); +int csolv(Cpx *a, Cpx *b, int n); + /* utility routines for hermitian eigen problems */ void chouse(Cpx *a, double *d, double *ud, int n); diff --git a/lib/fonts/CMakeLists.txt b/lib/fonts/CMakeLists.txt new file mode 100644 index 00000000000..5bfa8020b77 --- /dev/null +++ b/lib/fonts/CMakeLists.txt @@ -0,0 +1,43 @@ +set(font_files + cyrilc.hmp + fonts.table + gothgbt.hmp + gothgrt.hmp + gothitt.hmp + greekc.hmp + greekcs.hmp + greekp.hmp + greeks.hmp + hersh.oc1 + hersh.oc2 + hersh.oc3 + hersh.oc4 + italicc.hmp + italiccs.hmp + italict.hmp + romanc.hmp + romancs.hmp + romand.hmp + romans.hmp + romant.hmp + scriptc.hmp + scripts.hmp) +list(TRANSFORM font_files PREPEND fonts/) + +add_custom_target(fonts) + +add_custom_command( + TARGET fonts + PRE_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory ${OUTDIR}/${GRASS_INSTALL_FONTSDIR} + BYPRODUCTS ${OUTDIR}/${GRASS_INSTALL_FONTSDIR}) + +foreach(font_file ${font_files}) + add_custom_command( + TARGET fonts + PRE_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${font_file} + ${OUTDIR}/${GRASS_INSTALL_FONTSDIR}) +endforeach() + +install(FILES ${font_files} DESTINATION ${GRASS_INSTALL_FONTSDIR}) diff --git a/lib/gis/CMakeLists.txt b/lib/gis/CMakeLists.txt new file mode 100644 index 00000000000..a855326c0d8 --- /dev/null +++ b/lib/gis/CMakeLists.txt @@ -0,0 +1,83 @@ +file(GLOB gislib_SRCS "*.c") + +if(NOT WIN32) + list(FILTER gislib_SRCS EXCLUDE REGEX [[.*/fmode\.c$]]) +endif() + +set(grass_gis_DEFS "-DGRASS_VERSION_DATE=\"${GRASS_VERSION_DATE}\"") +if(MSVC) + set(grass_gis_DEFS "${grass_gis_DEFS};-D_USE_MATH_DEFINES=1") + set(gislib_INCLUDES "../../msvc") + list(APPEND gislib_SRCS "../../msvc/dirent.c;../../msvc/open.c;../../msvc/creat.c") +endif() + +build_module( + NAME + grass_gis + INCLUDES + ${gislib_INCLUDES} + SOURCES + "${gislib_SRCS}" + DEPENDS + grass_datetime + ZLIB + OPTIONAL_DEPENDS + PTHREAD + BZIP2 + ZSTD + ICONV + # REGEX + POSTGRES + DEFS + "${grass_gis_DEFS}") + +add_custom_command( + TARGET grass_gis + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/proj + COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/colors + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/colors + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ellipse.table + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/proj + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/datum.table + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/proj + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/datumtransform.table + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/proj + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/FIPS.code + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/proj + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/state27 + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/proj + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/state83 + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/proj + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/projections + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/proj + COMMAND + ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_SOURCE_DIR}/ellipse.table.solar.system + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/proj + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/colors.desc + ${OUTDIR}/${GRASS_INSTALL_ETCDIR} + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/renamed_options + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}) +install(DIRECTORY colors DESTINATION ${GRASS_INSTALL_ETCDIR}) +install( + FILES ellipse.table + ellipse.table.solar.system + datum.table + datumtransform.table + FIPS.code + state27 + state83 + projections + DESTINATION ${GRASS_INSTALL_ETCDIR}/proj) +install(FILES colors.desc renamed_options DESTINATION ${GRASS_INSTALL_ETCDIR}) + +if(UNIX) + target_link_libraries(grass_gis PRIVATE ${LIBM}) +endif() + +if(MSVC) + target_link_libraries(grass_gis PRIVATE PCRE) +endif() diff --git a/lib/gis/G.h b/lib/gis/G.h index 0cbfb5dbaaa..d2e31051797 100644 --- a/lib/gis/G.h +++ b/lib/gis/G.h @@ -1,6 +1,12 @@ #include #include +#ifdef GRASS_CMAKE_BUILD +#include +#else +#define GRASS_GIS_EXPORT +#endif + struct G__ /* Structure of library globals */ { struct Cell_head window; /* Contains the current window */ @@ -9,4 +15,4 @@ struct G__ /* Structure of library globals */ int compression_level; /* zlib compression level */ }; -extern struct G__ G__; /* allocated in gisinit */ +GRASS_GIS_EXPORT extern struct G__ G__; /* allocated in gisinit */ diff --git a/lib/gis/gisinit.c b/lib/gis/gisinit.c index 8a7d04f0093..f749eb8753f 100644 --- a/lib/gis/gisinit.c +++ b/lib/gis/gisinit.c @@ -26,9 +26,28 @@ #include "G.h" #include "gis_local_proto.h" -struct G__ G__; +#if 0 +#ifdef GRASS_CMAKE_BUILD +#include +#else +#define GRASS_GIS_EXPORT +#endif +#endif + +GRASS_GIS_EXPORT struct G__ G__; + +/** initialized is set to 1 when engine is initialized */ +/* GRASS_GIS_EXPORT static int initialized on windows msvc throws below error. +"Error C2201 'initialized': must have external linkage in order to be + exported/imported" +So we do an ifndef on msvc. without GRASS_GIS_EXPORT it will be exported in DLL. +*/ +#ifndef _MSC_VER +static int initialized = 0; +#else +GRASS_GIS_EXPORT int initialized; +#endif -static int initialized = 0; /** Is set when engine is initialized */ static int gisinit(void); /*! @@ -142,7 +161,7 @@ static int gisinit(void) { char *zlib; -#ifdef __MINGW32__ +#if defined(_MSC_VER) || defined(__MINGW32__) _fmode = O_BINARY; #endif /* Mark window as not set */ diff --git a/lib/gis/mapset_msc.c b/lib/gis/mapset_msc.c index 8553ff3807d..2d3351a1393 100644 --- a/lib/gis/mapset_msc.c +++ b/lib/gis/mapset_msc.c @@ -264,7 +264,7 @@ int G__make_mapset_element_misc(const char *dir, const char *name) static int check_owner(const struct stat *info) { -#if defined(__MINGW32__) || defined(SKIP_MAPSET_OWN_CHK) +#if defined(_WIN32) || defined(SKIP_MAPSET_OWN_CHK) return 1; #else const char *check = getenv("GRASS_SKIP_MAPSET_OWNER_CHECK"); diff --git a/lib/gis/parser_interface.c b/lib/gis/parser_interface.c index d2c35fc96ab..fb091af9144 100644 --- a/lib/gis/parser_interface.c +++ b/lib/gis/parser_interface.c @@ -114,9 +114,11 @@ void G__usage_xml(void) /* gettext converts strings to encoding returned by nl_langinfo(CODESET) */ +/* check if local_charset() comes from iconv. If so check for iconv library + * before using it */ #if defined(HAVE_LANGINFO_H) encoding = nl_langinfo(CODESET); -#elif defined(__MINGW32__) && defined(USE_NLS) +#elif defined(_WIN32) && defined(USE_NLS) encoding = locale_charset(); #endif diff --git a/lib/gis/paths.c b/lib/gis/paths.c index a2573762529..047b8d960e9 100644 --- a/lib/gis/paths.c +++ b/lib/gis/paths.c @@ -3,7 +3,7 @@ #include #include -#ifndef __MINGW32__ +#ifndef _WIN32 #include #else #include @@ -26,7 +26,7 @@ int G_mkdir(const char *path) { -#ifdef __MINGW32__ +#ifdef _WIN32 return mkdir(path); #else return mkdir(path, 0777); @@ -62,7 +62,7 @@ int G_is_dirsep(char c) int G_is_absolute_path(const char *path) { if (G_is_dirsep(path[0]) -#ifdef __MINGW32__ +#ifdef _WIN32 || (isalpha(path[0]) && (path[1] == ':') && G_is_dirsep(path[2])) #endif ) @@ -144,7 +144,7 @@ int G_stat(const char *file_name, struct stat *buf) int G_lstat(const char *file_name, struct stat *buf) { -#ifdef __MINGW32__ +#ifdef _WIN32 return stat(file_name, buf); #else return lstat(file_name, buf); @@ -164,7 +164,7 @@ int G_lstat(const char *file_name, struct stat *buf) int G_owner(const char *path) { -#ifndef __MINGW32__ +#ifndef _WIN32 struct stat info; G_stat(path, &info); diff --git a/lib/gis/popen.c b/lib/gis/popen.c index f3e4a2629cf..6b5c9fd07b6 100644 --- a/lib/gis/popen.c +++ b/lib/gis/popen.c @@ -6,7 +6,7 @@ #include #include -#ifdef __MINGW32__ +#ifdef _WIN32 #include #include #define pipe(fds) _pipe(fds, 4096, O_BINARY | O_NOINHERIT) diff --git a/lib/gis/sleep.c b/lib/gis/sleep.c index 1a5e2a07ae0..2f3bdce969c 100644 --- a/lib/gis/sleep.c +++ b/lib/gis/sleep.c @@ -1,8 +1,8 @@ #include -#ifndef __MINGW32__ +#ifndef _WIN32 #include #endif -#ifdef __MINGW32__ +#ifdef _WIN32 #include #endif #include @@ -10,7 +10,7 @@ /* Sleep */ void G_sleep(unsigned int seconds) { -#ifdef __MINGW32__ +#ifdef _WIN32 /* note: Sleep() cannot be interrupted */ Sleep((seconds) * 1000); #else diff --git a/lib/gis/spawn.c b/lib/gis/spawn.c index d6b5ec72896..1b1630ebc78 100644 --- a/lib/gis/spawn.c +++ b/lib/gis/spawn.c @@ -23,7 +23,7 @@ #include #include -#ifndef __MINGW32__ +#ifndef _WIN32 #include #else #include @@ -68,7 +68,7 @@ struct signal { int action; int signum; int valid; -#ifndef __MINGW32__ +#ifndef _WIN32 struct sigaction old_act; sigset_t old_mask; #endif @@ -95,7 +95,7 @@ struct spawn { static void parse_arglist(struct spawn *sp, va_list va); static void parse_argvec(struct spawn *sp, const char **va); -#ifdef __MINGW32__ +#ifdef _WIN32 struct buffer { char *str; @@ -937,7 +937,7 @@ int G_spawn(const char *command, ...) status = G_spawn_ex(command, -#ifndef __MINGW32__ +#ifndef _WIN32 SF_SIGNAL, SST_PRE, SSA_IGNORE, SIGINT, SF_SIGNAL, SST_PRE, SSA_IGNORE, SIGQUIT, SF_SIGNAL, SST_PRE, SSA_BLOCK, SIGCHLD, #endif @@ -948,7 +948,7 @@ int G_spawn(const char *command, ...) int G_wait(int i_pid) { -#ifdef __MINGW32__ +#ifdef _WIN32 DWORD rights = PROCESS_QUERY_INFORMATION | SYNCHRONIZE; HANDLE hProcess = OpenProcess(rights, FALSE, (DWORD)i_pid); DWORD exitcode; diff --git a/lib/gis/user_config.c b/lib/gis/user_config.c index b2bba835c39..4734dfa985e 100644 --- a/lib/gis/user_config.c +++ b/lib/gis/user_config.c @@ -32,7 +32,7 @@ #include #include #include -#ifndef __MINGW32__ +#ifndef _WIN32 #include #endif #include @@ -46,7 +46,7 @@ * path [caller must G_free ()] on success, or NULL on failure *************************************************************************/ -#ifndef __MINGW32__ /* TODO */ +#ifndef _WIN32 /* TODO */ static char *_make_toplevel(void) { size_t len; diff --git a/lib/gis/whoami.c b/lib/gis/whoami.c index d978326b588..4daa35115cc 100644 --- a/lib/gis/whoami.c +++ b/lib/gis/whoami.c @@ -10,11 +10,10 @@ * * \author Original author CERL */ - #include #include -#ifndef __MINGW32__ +#ifndef _WIN32 #include #endif @@ -40,7 +39,7 @@ const char *G_whoami(void) if (G_is_initialized(&initialized)) return name; -#ifdef __MINGW32__ +#ifdef _WIN32 name = getenv("USERNAME"); #endif if (!name || !*name) @@ -49,7 +48,7 @@ const char *G_whoami(void) if (!name || !*name) name = getenv("USER"); -#ifndef __MINGW32__ +#ifndef _WIN32 if (!name || !*name) { struct passwd *p = getpwuid(getuid()); diff --git a/lib/gmath/la.c b/lib/gmath/la.c index 5696a174bda..8cad2028241 100644 --- a/lib/gmath/la.c +++ b/lib/gmath/la.c @@ -31,6 +31,13 @@ #include #include +#if defined(_MSC_VER) +#include +#define LAPACK_COMPLEX_CUSTOM +#define lapack_complex_float _Fcomplex +#define lapack_complex_double _Dcomplex +#endif + #include #if defined(HAVE_CBLAS_ATLAS_H) #include diff --git a/lib/imagery/iscatt_core.c b/lib/imagery/iscatt_core.c index 05ce619eef8..8a3da41d15d 100644 --- a/lib/imagery/iscatt_core.c +++ b/lib/imagery/iscatt_core.c @@ -697,7 +697,6 @@ int I_compute_scatts(struct Cell_head *region, struct scCats *scatt_conds, struct rast_row *bands_rows = G_malloc(n_bands * sizeof(struct rast_row)); RASTER_MAP_TYPE data_type; - int nrows, i_band, n_a_bands, band_id; int i_row, head_nchars, i_cat, id_cat; diff --git a/lib/init/CMakeLists.txt b/lib/init/CMakeLists.txt new file mode 100644 index 00000000000..683a194a0a9 --- /dev/null +++ b/lib/init/CMakeLists.txt @@ -0,0 +1,184 @@ +# #for i18N support + +file(GLOB init_HTMLFILES "*.html") +add_custom_target(ADD_INIT_DOCS ALL COMMENT "Generate init docs.") + +if(WITH_DOCS) + foreach(html_file ${init_HTMLFILES}) + get_filename_component(filename ${html_file} NAME_WLE) + generate_html(TARGET ADD_INIT_DOCS NAME ${filename}) + endforeach() +endif() + +# START_UP is the variable used in grass.py, grass.sh.in and grass.bat.in +set(START_UP "grass") +if(WIN32) + set(START_UP "${START_UP}.py") + set(script_file_name "grass.bat") + set(script_input_file_name ${script_file_name}.in) +else() + set(script_file_name "grass") + set(script_input_file_name ${script_file_name}.sh.in) +endif() + +file(TO_NATIVE_PATH ${CMAKE_BINARY_DIR}/bin BINARY_DIR) +set(CONFIG_PROJSHARE) +get_filename_component(PROJ_INSTALL_PREFIX ${PROJ_INCLUDE_DIR} PATH) +if(DEFINED ENV{PROJSHARE}) + message(WARNING "External PROJ directory not specified; default will be used") + set(CONFIG_PROJSHARE "$ENV{PROJSHARE}") +else() + set(CONFIG_PROJSHARE "${PROJ_INSTALL_PREFIX}/share/proj") + if(EXISTS ${CONFIG_PROJSHARE}/epsg) + message(STATUS "PROJ directory ${CONFIG_PROJSHARE}") + endif() +endif() +file(TO_NATIVE_PATH "${PROJ_INSTALL_PREFIX}/share/proj" PROJ_LIB) +file(TO_NATIVE_PATH ${CONFIG_PROJSHARE} GRASS_PROJSHARE) + +find_path(gdal_share_dir "gdal" PATH_SUFFIXES share) +if(NOT gdal_share_dir) + message(FATAL_ERROR "Cannot find share/gdal") +endif() +mark_as_advanced(gdal_share_dir) + +file(TO_NATIVE_PATH "${gdal_share_dir}/gdal" GDAL_DATA) +get_filename_component(GDAL_DIR ${GDAL_LIBRARY} PATH) +get_filename_component(GDAL_DIR ${GDAL_DIR} PATH) + +file(TO_NATIVE_PATH ${GDAL_DIR}/bin DEPS_DLL_PATH) +list(APPEND DLL_PATH_LIST ${DEPS_DLL_PATH}) + +# For install tree (first do install tree) +set(LD_LIBRARY_PATH_VAR "LD_LIBRARY_PATH") + +if(APPLE) + set(LD_LIBRARY_PATH_VAR "LD_RUN_PATH") +elseif(WIN32) + set(LD_LIBRARY_PATH_VAR "PATH") +endif() + +# configure and install grass.py +set(GISBASE_INSTALL_PATH ${RUNTIME_GISBASE}) +configure_file(grass.py ${OUTDIR}/${CMAKE_INSTALL_BINDIR}/${START_UP} @ONLY) + +set(GISBASE_INSTALL_PATH ${GISBASE}) +configure_file(grass.py ${CMAKE_CURRENT_BINARY_DIR}/${START_UP} @ONLY) +unset(GISBASE_INSTALL_PATH) + +install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${START_UP} + DESTINATION ${CMAKE_INSTALL_BINDIR}) + +file(TO_NATIVE_PATH "${OUTDIR}/${GISBASE_DIR}" gisbase_init_dir) + +file(COPY ${CMAKE_SOURCE_DIR}/demolocation/PERMANENT + DESTINATION ${OUTDIR}/${GRASS_INSTALL_DEMODIR}) + +install(DIRECTORY ${CMAKE_SOURCE_DIR}/demolocation/PERMANENT/ + DESTINATION ${GRASS_INSTALL_DEMODIR}/PERMANENT) + +set(GISDBASE ${OUTDIR}/${GISBASE_DIR}) +configure_file(${CMAKE_SOURCE_DIR}/demolocation/grassrc.tmpl "${GISRC}" @ONLY) +unset(GISDBASE) + +file(TO_NATIVE_PATH ${OUTDIR}/${GRASS_INSTALL_BINDIR} grass_dll_dir) +set(DLL_PATH_LIST) +list(APPEND DLL_PATH_LIST ${grass_dll_dir}) +separate_arguments(DLL_PATH_LIST) + +set(LD_LIBRARY_PATH_VAR) +if(UNIX OR MINGW) + if(DEFINED ENV{LD_LIBRARY_PATH}) + set(LD_LIBRARY_PATH_VAR + "${OUTDIR}/${GRASS_INSTALL_LIBDIR}:$ENV{LD_LIBRARY_PATH}") + else() + set(LD_LIBRARY_PATH_VAR "${OUTDIR}/${GRASS_INSTALL_LIBDIR}") + endif() +endif() +message(STATUS "GISBASE (build) : ${GISBASE_DIR}") +message(STATUS "grass config directory (build): ${grass_config_dir}") + +message(STATUS "gisrc (build): ${GISRC}") + +# finish installtree and buildtree configurations + +build_program( + NAME + echo + SOURCES + echo.c + PACKAGE + "grasslibs" + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_ETCBINDIR} + NO_DOCS) + +build_program( + NAME + run + SOURCES + run.c + PACKAGE + "grasslibs" + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_ETCBINDIR} + NO_DOCS) + +build_program( + NAME + clean_temp + SOURCES + clean_temp.c + DEPENDS + grass_gis + PACKAGE + "grasslibs" + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_ETCBINDIR} + NO_DOCS) + +build_program( + NAME + lock + SOURCES + lock.c + DEPENDS + grass_gis + grass_datetime + PACKAGE + "grasslibs" + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_ETCBINDIR} + NO_DOCS) + +if(MINGW) + build_program( + NAME + winlocale + SOURCES + winlocale.c + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_ETCBINDIR} + NO_DOCS) +endif() + +set(VERSIONNUMBER_CONTENTS "${GRASS_VERSION_NUMBER}") +if(GRASS_VERSION_GIT) + list(APPEND VERSIONNUMBER_CONTENTS + "${VERSIONNUMBER_CONTENTS} ${GRASS_VERSION_GIT}") +endif() + +file(WRITE ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/VERSIONNUMBER + "${VERSIONNUMBER_CONTENTS}") + +install(FILES ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/VERSIONNUMBER + DESTINATION ${GRASS_INSTALL_ETCDIR}) + +execute_process( + COMMAND sh ${CMAKE_CURRENT_SOURCE_DIR}/version.sed "${GRASS_VERSION_NUMBER}" + "${GRASS_VERSION_DATE}" "" + INPUT_FILE ${CMAKE_CURRENT_SOURCE_DIR}/license.txt + OUTPUT_FILE ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/license) + +install(FILES ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/license + DESTINATION ${GRASS_INSTALL_ETCDIR}) diff --git a/lib/init/Makefile b/lib/init/Makefile index 2db853fce95..99366b060a9 100644 --- a/lib/init/Makefile +++ b/lib/init/Makefile @@ -69,7 +69,7 @@ $(ARCH_BINDIR)/$(START_UP): grass.py endif rm -f $@ sed \ - -e 's#@GISBASE@#$(RUN_GISBASE)#' \ + -e 's#@GISBASE_INSTALL_PATH@#$(RUN_GISBASE)#' \ -e 's#@GRASS_VERSION_NUMBER@#$(GRASS_VERSION_NUMBER)#' \ -e 's#@GRASS_VERSION_MAJOR@#$(GRASS_VERSION_MAJOR)#' \ -e 's#@GRASS_VERSION_MINOR@#$(GRASS_VERSION_MINOR)#' \ diff --git a/lib/init/clean_temp.c b/lib/init/clean_temp.c index b1edaaed6fe..29f9da173e6 100644 --- a/lib/init/clean_temp.c +++ b/lib/init/clean_temp.c @@ -36,7 +36,6 @@ #define SLEEP 30 /* 30 seconds */ /* Recursively scan the directory pathname, removing directory and files */ - void clean_dir(const char *pathname, uid_t uid, pid_t pid, time_t now, int max_age) { @@ -140,7 +139,7 @@ int main(int argc, char *argv[]) G_file_name(tmppath, element, "", mapset = G_mapset()); /* get user id and current time in seconds */ -#ifdef __MINGW32__ +#ifdef _WIN32 /* TODO */ uid = -1; #else @@ -172,7 +171,7 @@ int main(int argc, char *argv[]) int find_process(int pid) { -#ifdef __MINGW32__ +#ifdef _WIN32 /* TODO */ return -1; #else diff --git a/lib/init/grass.bat.in b/lib/init/grass.bat.in new file mode 100644 index 00000000000..cb95984ee55 --- /dev/null +++ b/lib/init/grass.bat.in @@ -0,0 +1,29 @@ +@echo off +::set PYTHONHOME=%GISBASE%\Python37 + +set GRASS_PROJSHARE=@GRASS_PROJSHARE@ + +set PROJ_LIB=@PROJ_LIB@ + +set GDAL_DATA=@GDAL_DATA@ + +set GEOTIFF_CSV=@GEOTIFF_CSV@ + +::set FONTCONFIG_FILE=%GISBASE%\etc\fonts.conf + +set PATH=@gisbase_init_dir@\bin;@BINARY_DIR@;@DLL_PATH_LIST@;%PATH% + +set GISBASE=@gisbase_init_dir@ + +set PYTHONPATH=@gisbase_init_dir@\etc\python;@gisbase_init_dir@\gui\wxpython;@gisbase_init_dir@\etc + +set GRASS_PYTHON=@GRASS_PYTHON@ + +set GRASS_CONFIG_DIR=@grass_config_dir@ + +"@GRASS_PYTHON@" "@gisbase_init_dir@\etc\@START_UP@" %* + +rem +rem Pause on error +rem +if %ERRORLEVEL% GEQ 1 pause diff --git a/lib/init/grass.py b/lib/init/grass.py index 9d3bb2bb8a6..dcad7b4a57c 100755 --- a/lib/init/grass.py +++ b/lib/init/grass.py @@ -92,7 +92,7 @@ if "GISBASE" in os.environ and len(os.getenv("GISBASE")) > 0: GISBASE = os.path.normpath(os.environ["GISBASE"]) else: - GISBASE = os.path.normpath("@GISBASE@") + GISBASE = os.path.normpath("@GISBASE_INSTALL_PATH@") os.environ["GISBASE"] = GISBASE CMD_NAME = "@START_UP@" GRASS_VERSION = "@GRASS_VERSION_NUMBER@" diff --git a/lib/init/grass.sh.in b/lib/init/grass.sh.in new file mode 100755 index 00000000000..a37f5b2e624 --- /dev/null +++ b/lib/init/grass.sh.in @@ -0,0 +1,6 @@ +#! /bin/sh +trap "echo 'User break!' ; exit" 2 3 9 15 + +. @grass_config_dir@/bashrc + +"$GRASS_PYTHON" "@gisbase_init_dir@/etc/@START_UP@" "$@" diff --git a/lib/init/lock.c b/lib/init/lock.c index a1dc8ca93e5..7d435c0878a 100644 --- a/lib/init/lock.c +++ b/lib/init/lock.c @@ -38,7 +38,7 @@ int main(int argc, char *argv[]) G_fatal_error(_("Usage: %s file pid"), argv[0]); #define file argv[1] -#ifdef __MINGW32__ +#ifdef _WIN32 G_warning(_("Concurrent mapset locking is not supported on Windows")); exit(0); #else @@ -71,7 +71,7 @@ int find_process(int pid) kill failed because no such process, or because user is not owner of process */ -#ifdef __MINGW32__ +#ifdef _WIN32 return 0; #else if (kill(pid, 0) == 0) diff --git a/lib/init/run.c b/lib/init/run.c index 4c048efdcec..6dae2af309e 100644 --- a/lib/init/run.c +++ b/lib/init/run.c @@ -22,7 +22,7 @@ the user's shell to re-activate interrupts in shell-ese. int main(int argc, char *argv[]) { signal(SIGINT, SIG_DFL); -#ifndef __MINGW32__ +#ifndef _WIN32 signal(SIGQUIT, SIG_DFL); #endif diff --git a/lib/iostream/rtimer.cpp b/lib/iostream/rtimer.cpp index 83ed7e44879..19cb6f39535 100644 --- a/lib/iostream/rtimer.cpp +++ b/lib/iostream/rtimer.cpp @@ -33,10 +33,7 @@ * General Public License for more details. * * **************************************************************************/ -#include -#include -#include -#include +#include #include diff --git a/lib/manage/sighold.c b/lib/manage/sighold.c index 7961f62f3dc..8fdbea604c4 100644 --- a/lib/manage/sighold.c +++ b/lib/manage/sighold.c @@ -27,7 +27,7 @@ int M__hold_signals(int hold) signal(SIGINT, sig); -#ifndef __MINGW32__ +#ifndef _WIN32 signal(SIGQUIT, sig); #endif diff --git a/lib/pngdriver/graph_close.c b/lib/pngdriver/graph_close.c index 3496bdf1fa1..e6dba3f6166 100644 --- a/lib/pngdriver/graph_close.c +++ b/lib/pngdriver/graph_close.c @@ -16,7 +16,7 @@ #include #include #include -#ifdef __MINGW32__ +#ifdef _WIN32 #include #else #include @@ -33,7 +33,7 @@ static void unmap_file(void) if (!png.mapped) return; -#ifdef __MINGW32__ +#ifdef _WIN32 UnmapViewOfFile(ptr); CloseHandle(png.handle); #else diff --git a/lib/pngdriver/graph_set.c b/lib/pngdriver/graph_set.c index 1fcf02bac8a..03c65ebbb8d 100644 --- a/lib/pngdriver/graph_set.c +++ b/lib/pngdriver/graph_set.c @@ -18,7 +18,7 @@ #include #include #include -#ifdef __MINGW32__ +#ifdef _WIN32 #include #else #include @@ -41,7 +41,7 @@ static void map_file(void) if (fd < 0) return; -#ifdef __MINGW32__ +#ifdef _WIN32 png.handle = CreateFileMapping((HANDLE)_get_osfhandle(fd), NULL, PAGE_READWRITE, 0, size, NULL); if (!png.handle) diff --git a/lib/pngdriver/pngdriver.h b/lib/pngdriver/pngdriver.h index 0a4b9564e72..24e7eb5c760 100644 --- a/lib/pngdriver/pngdriver.h +++ b/lib/pngdriver/pngdriver.h @@ -16,7 +16,7 @@ #include -#ifdef __MINGW32__ +#ifdef _WIN32 #include #endif @@ -34,7 +34,7 @@ struct png_state { int true_color; int has_alpha; int mapped; -#ifdef __MINGW32__ +#ifdef _WIN32 HANDLE handle; #endif diff --git a/lib/proj/CMakeLists.txt b/lib/proj/CMakeLists.txt new file mode 100644 index 00000000000..74f4dff67f3 --- /dev/null +++ b/lib/proj/CMakeLists.txt @@ -0,0 +1,22 @@ +file(COPY desc.table DESTINATION etc/proj) +file(COPY parms.table DESTINATION etc/proj) +file(COPY units.table DESTINATION etc/proj) + +set(grass_gproj_SOURCES convert.c datum.c do_proj.c ellipse.c get_proj.c) +if(MINGW) + list(APPEND grass_gproj_SOURCES "ftol.c") +endif() + +build_module( + NAME + grass_gproj + DEPENDS + grass_driver + grass_gis + GDAL + ZLIB + PROJ + SOURCES + "${grass_gproj_SOURCES}" + INCLUDES + "../driver") diff --git a/lib/raster/close.c b/lib/raster/close.c index 36ce924cb8b..50ed7fc1602 100644 --- a/lib/raster/close.c +++ b/lib/raster/close.c @@ -12,7 +12,7 @@ * \author USACERL and many others */ -#ifdef __MINGW32__ +#ifdef _WIN32 #include #endif @@ -51,7 +51,7 @@ static void sync_and_close(int fd, char *element, char *name) * after you are done writing all your data. */ -#ifndef __MINGW32__ +#ifndef _WIN32 if (fsync(fd)) { G_warning(_("Unable to flush file %s for raster map %s: %s"), element, name, strerror(errno)); diff --git a/lib/raster3d/close.c b/lib/raster3d/close.c index 2622eb48d40..8af9ed1ac1a 100644 --- a/lib/raster3d/close.c +++ b/lib/raster3d/close.c @@ -12,7 +12,7 @@ \author USACERL and many others */ -#ifdef __MINGW32__ +#ifdef _WIN32 #include #endif #include @@ -54,7 +54,7 @@ static int close_new(RASTER3D_Map *map) /* finally move tempfile to data file */ Rast3d_filename(path, RASTER3D_CELL_ELEMENT, map->fileName, map->mapset); -#ifdef __MINGW32__ +#ifdef _WIN32 if (CopyFile(map->tempName, path, FALSE) == 0) { #else if (link(map->tempName, path) < 0) { diff --git a/lib/raster3d/test/test_raster3d_lib.h b/lib/raster3d/test/test_raster3d_lib.h index 4bcb53f5f59..5a1c57dd3ef 100644 --- a/lib/raster3d/test/test_raster3d_lib.h +++ b/lib/raster3d/test/test_raster3d_lib.h @@ -20,8 +20,11 @@ #include #include #include +#ifdef HAVE_SYS_TIME_H #include - +#else +#include +#endif double compute_time_difference(struct timeval, struct timeval); int unit_test_coordinate_transform(void); int unit_test_put_get_value(void); diff --git a/lib/raster3d/test/test_tools.c b/lib/raster3d/test/test_tools.c index bb4ff23a7bd..97af63a7f7e 100644 --- a/lib/raster3d/test/test_tools.c +++ b/lib/raster3d/test/test_tools.c @@ -19,6 +19,9 @@ #include #include #include "test_raster3d_lib.h" +#ifdef _MSC_VER +#include +#endif /* *************************************************************** */ /* Compute the difference between two time steps ***************** */ diff --git a/lib/rst/CMakeLists.txt b/lib/rst/CMakeLists.txt new file mode 100644 index 00000000000..47bf990412a --- /dev/null +++ b/lib/rst/CMakeLists.txt @@ -0,0 +1,41 @@ +# add_subdirectory(data) add_subdirectory(qtree) add_subdirectory(interp_float) + +build_library_in_subdir( + data + NAME + grass_interpdata + DEPENDS + grass_gis + HEADERS + "dataquad.h") + +build_library_in_subdir( + qtree + NAME + grass_qtree + DEPENDS + grass_gis + HEADERS + "qtree.h") + +build_library_in_subdir( + interp_float + NAME + grass_interpfl + DEPENDS + grass_gis + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gmath + grass_raster + grass_bitmap + grass_vector + grass_qtree + grass_interpdata + GDAL + ${LIBM} + OPTIONAL_DEPENDS + OPENMP + HEADERS + "interpf.h") diff --git a/lib/rst/interp_float/interpf.h b/lib/rst/interp_float/interpf.h index a4055a41e8a..241c4937e91 100644 --- a/lib/rst/interp_float/interpf.h +++ b/lib/rst/interp_float/interpf.h @@ -12,6 +12,11 @@ #include #include #include +#ifdef GRASS_CMAKE_BUILD +#include +#else +#define GRASS_INTERPFL_EXPORT +#endif /* for resample program */ struct fcell_triple { @@ -22,21 +27,21 @@ struct fcell_triple { }; #ifdef POINT2D_C -struct line_pnts *Pnts; -struct line_cats *Cats2; -dbDriver *driver2; -dbString sql2; -struct Map_info Map2; -struct field_info *ff; -int count; +GRASS_INTERPFL_EXPORT struct line_pnts *Pnts; +GRASS_INTERPFL_EXPORT struct line_cats *Cats2; +GRASS_INTERPFL_EXPORT dbDriver *driver2; +GRASS_INTERPFL_EXPORT dbString sql2; +GRASS_INTERPFL_EXPORT struct Map_info Map2; +GRASS_INTERPFL_EXPORT struct field_info *ff; +GRASS_INTERPFL_EXPORT int count; #else -extern struct line_pnts *Pnts; -extern struct line_cats *Cats2; -extern dbDriver *driver2; -extern dbString sql2; -extern struct Map_info Map2; -extern struct field_info *ff; -extern int count; +GRASS_INTERPFL_EXPORT extern struct line_pnts *Pnts; +GRASS_INTERPFL_EXPORT extern struct line_cats *Cats2; +GRASS_INTERPFL_EXPORT extern dbDriver *driver2; +GRASS_INTERPFL_EXPORT extern dbString sql2; +GRASS_INTERPFL_EXPORT extern struct Map_info Map2; +GRASS_INTERPFL_EXPORT extern struct field_info *ff; +GRASS_INTERPFL_EXPORT extern int count; #endif struct interp_params; diff --git a/lib/temporal/CMakeLists.txt b/lib/temporal/CMakeLists.txt new file mode 100644 index 00000000000..7f9f5054963 --- /dev/null +++ b/lib/temporal/CMakeLists.txt @@ -0,0 +1,12 @@ +file(GLOB SQLFILES "SQL/*.sql") +foreach(sqlfile ${SQLFILES}) + install(FILES "${sqlfile}" DESTINATION ${GRASS_INSTALL_ETCDIR}/sql) +endforeach() +build_library_in_subdir( + lib + NAME + grass_temporal + DEPENDS + grass_gis + grass_dbmibase + grass_datetime) diff --git a/lib/vector/CMakeLists.txt b/lib/vector/CMakeLists.txt new file mode 100644 index 00000000000..61747521050 --- /dev/null +++ b/lib/vector/CMakeLists.txt @@ -0,0 +1,63 @@ +build_library_in_subdir(rtree HEADERS "rtree.h" DEPENDS grass_gis) + +add_subdirectory(dglib) +add_subdirectory(diglib) + +build_library_in_subdir( + Vlib + NAME + grass_vector + DEPENDS + GDAL + grass_btree2 + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_dig2 + grass_gis + grass_gproj + grass_dgl + grass_linkm + grass_raster + grass_rtree + OPTIONAL_DEPENDS + GEOS) + +if(TARGET POSTGRES) + # target_include_directories(grass_vector SYSTEM PUBLIC + # ${PostgreSQL_INCLUDE_DIR}) + target_link_libraries(grass_vector PRIVATE POSTGRES) +endif() + +if(TARGET LAPACKE) + target_link_libraries(grass_vector PRIVATE LAPACKE) +endif() + +build_library_in_subdir( + vedit + NAME + grass_vedit + DEPENDS + grass_gis + grass_vector + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL) + +build_library_in_subdir( + neta + NAME + grass_neta + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_dgl + grass_vector + GDAL) + +if(WITH_DOCS) + generate_html(TARGET grass_vector NAME vectorascii) +endif() diff --git a/lib/vector/dglib/CMakeLists.txt b/lib/vector/dglib/CMakeLists.txt new file mode 100644 index 00000000000..a55e79824c6 --- /dev/null +++ b/lib/vector/dglib/CMakeLists.txt @@ -0,0 +1,48 @@ +# MODULE_TOPDIR = ../../.. + +# include $(MODULE_TOPDIR)/include/Make/Vars.make + +# MOD_OBJS := $(filter-out %-template.o,$(AUTO_OBJS)) + +# LIB = GRAPH + +# include $(MODULE_TOPDIR)/include/Make/Lib.make include +# $(MODULE_TOPDIR)/include/Make/Doxygen.make + +# DGLINC = $(ARCH_INCDIR)/dgl + +# default: headers $(MAKE) lib + +# headers: $(DGLINC)/avl.h $(DGLINC)/tavl.h $(DGLINC)/graph.h $(DGLINC)/heap.h \ +# $(DGLINC)/tree.h $(DGLINC)/type.h $(DGLINC)/helpers.h $(DGLINC)/graph_v1.h +# $(DGLINC)/graph_v2.h \ $(ARCH_INCDIR)/dgl.h + +# $(DGLINC)/%.h: %.h | $(DGLINC) $(INSTALL_DATA) $< $@ + +set(DGL_headers + avl.h + graph.h + graph_v1.h + graph_v2.h + heap.h + helpers.h + tavl.h + tree.h + type.h) +foreach(DGL_header ${DGL_headers}) + file(COPY ${DGL_header} + DESTINATION ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass/dgl) +endforeach() +# file(COPY dgl.h DESTINATION ${OUTDIR}/${GRASS_INSTALL_INCLUDEDIR}/grass) + +set(graphlib_SRCS + avl.c + graph.c + graph_v1.c + graph_v2.c + heap.c + helpers.c + tavl.c + tree.c) + +build_module(NAME grass_dgl SOURCES "${graphlib_SRCS}" HEADERS "dgl.h") diff --git a/lib/vector/diglib/CMakeLists.txt b/lib/vector/diglib/CMakeLists.txt new file mode 100644 index 00000000000..8ee96029c77 --- /dev/null +++ b/lib/vector/diglib/CMakeLists.txt @@ -0,0 +1,38 @@ +set(dig2_SRCS + allocation.c + cindex.c + frmt.c + line_dist.c + plus.c + plus_node.c + port_init.c + prune.c + struct_alloc.c + update.c + angle.c + cindex_rw.c + head.c + linecros.c + plus_area.c + plus_struct.c + spindex.c + box.c + file.c + inside.c + list.c + plus_line.c + poly.c + portable.c + spindex_rw.c + type.c) +build_module( + NAME + grass_dig2 + SOURCES + ${dig2_SRCS} + DEPENDS + grass_gmath + grass_gis + grass_rtree + GDAL + ${LIBM}) diff --git a/locale/CMakeLists.txt b/locale/CMakeLists.txt new file mode 100644 index 00000000000..ab5fd37a04e --- /dev/null +++ b/locale/CMakeLists.txt @@ -0,0 +1,34 @@ +#[===========================================================================[ + Currently this only installs mo files. + TODO: implement update and creation +#]===========================================================================] + +add_custom_target(generate_mo_files ALL COMMENT "Generate mo files") + +add_custom_command( + TARGET generate_mo_files + PRE_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_LOCALEDIR} + BYPRODUCTS ${OUTDIR}/${GRASS_INSTALL_LOCALEDIR}) + +file(GLOB po_files "${CMAKE_CURRENT_SOURCE_DIR}/po/*.po") +foreach(po_file ${po_files}) + get_filename_component(po_file_name ${po_file} NAME) + string(REGEX REPLACE "^([^_]+)_(.*)\.po" "\\2/LC_MESSAGES/\\1.mo" mo_file + ${po_file_name}) + get_filename_component(mo_dir ${mo_file} DIRECTORY) + + add_custom_command( + TARGET generate_mo_files + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_LOCALEDIR}/${mo_dir} + COMMAND ${MSGFMT} --statistics -o + ${OUTDIR}/${GRASS_INSTALL_LOCALEDIR}/${mo_file} ${po_file} + BYPRODUCTS ${OUTDIR}/${GRASS_INSTALL_LOCALEDIR}/${mo_file} + ${OUTDIR}/${GRASS_INSTALL_LOCALEDIR}/${mo_dir}) +endforeach() + +install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_LOCALEDIR}/ + DESTINATION ${GRASS_INSTALL_LOCALEDIR}) diff --git a/man/CMakeLists.txt b/man/CMakeLists.txt new file mode 100644 index 00000000000..629c2fd12e0 --- /dev/null +++ b/man/CMakeLists.txt @@ -0,0 +1,118 @@ +string(TIMESTAMP YEAR %Y) + +add_custom_target( + build_full_index + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/build_full_index.py + ${YEAR} + BYPRODUCTS ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/full_index.html + DEPENDS ALL_MODULES LIB_PYTHON GUI_WXPYTHON + COMMENT "man generation: build full index") + +set(data_files + ${CMAKE_CURRENT_SOURCE_DIR}/jquery.fixedheadertable.min.js + ${CMAKE_CURRENT_SOURCE_DIR}/grassdocs.css + ${CMAKE_CURRENT_SOURCE_DIR}/hamburger_menu.svg + ${CMAKE_CURRENT_SOURCE_DIR}/grass_icon.png + ${CMAKE_CURRENT_SOURCE_DIR}/grass_logo.png + ${CMAKE_CURRENT_SOURCE_DIR}/hamburger_menu_close.svg + ${CMAKE_CURRENT_SOURCE_DIR}/parser_standard_options.css + ${CMAKE_CURRENT_SOURCE_DIR}/parser_standard_options.js) +install(FILES ${data_files} DESTINATION ${GRASS_INSTALL_DOCDIR}) + +add_custom_command( + TARGET build_full_index + PRE_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${data_files} + ${OUTDIR}/${GRASS_INSTALL_DOCDIR} + COMMENT "copying man files") + +add_custom_target( + build_index + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/build_index.py ${OUTDIR}/${GRASS_INSTALL_DOCDIR} + BYPRODUCTS ${OUTDIR}/${GRASS_INSTALL_DOCDIR}/index.html + DEPENDS build_full_index + COMMENT "man generation: build index") + +set(target_names build_topics build_keywords build_graphical_index + build_manual_gallery) +foreach(target_name ${target_names}) + add_custom_target( + ${target_name} + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/${target_name}.py + DEPENDS build_index + COMMENT "man generation: ${target_name}") +endforeach() + +add_custom_target( + build_class_graphical + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/build_class_graphical.py + html + ${OUTDIR}/${GRASS_INSTALL_DOCDIR} + DEPENDS build_index + COMMENT "man generation: build_class_graphical") + +add_custom_target( + build_pso + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/parser_standard_options.py -t + "${CMAKE_SOURCE_DIR}/lib/gis/parser_standard_options.c" -f "grass" -o + "${OUTDIR}/${GRASS_INSTALL_DOCDIR}/parser_standard_options.html" -p + "id='opts_table' class='scroolTable'" + DEPENDS ${target_names} + COMMENT "man generation: parser standard options") + +set(categories + d:display + db:database + g:general + i:imagery + m:miscellaneous + ps:postscript + r:raster + r3:raster3d + t:temporal + v:vector) +set(category_targets "") +foreach(category ${categories}) + string(REPLACE ":" ";" category_list ${category}) + list(GET category_list 0 prefix) + list(GET category_list 1 class_name) + list(APPEND category_targets build_class_${class_name}) + add_custom_target( + build_class_${class_name} + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/build_class.py ${prefix} ${class_name} + ${OUTDIR}/${GRASS_INSTALL_DOCDIR} + DEPENDS build_pso + COMMENT "man generation: build class ${class_name}") +endforeach() + +# TODO: this shouldn't depend on GUI_WXPYTHON +add_custom_target( + build_check ALL + COMMAND + ${grass_env_command} ${PYTHON_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/build_check.py ${OUTDIR}/${GRASS_INSTALL_DOCDIR} + DEPENDS ${category_targets} ALL_MODULES LIB_PYTHON GUI_WXPYTHON + COMMENT "man generation: check output") + +#[=======[ TODO: implement somehow... +add_custom_target( + create_man_pages ALL + DEPENDS build_check + COMMAND ${CMAKE_COMMAND} -DHTML2MAN=${HTML2MAN} + -DGRASS_INSTALL_DOCDIR=${GRASS_INSTALL_DOCDIR} -DOUTDIR=${OUTDIR} + -DGRASS_INSTALL_MANDIR=${GRASS_INSTALL_MANDIR} -P + ${CMAKE_SOURCE_DIR}/cmake/generate_man_pages.cmake + COMMENT "!!! man generation: create man pages") +]=======] diff --git a/misc/CMakeLists.txt b/misc/CMakeLists.txt new file mode 100644 index 00000000000..8cf3002227f --- /dev/null +++ b/misc/CMakeLists.txt @@ -0,0 +1,22 @@ +build_program_in_subdir(m.cogo DEPENDS grass_gis ${LIBM}) + +build_program_in_subdir(m.measure DEPENDS grass_gis) + +build_program_in_subdir(m.transform DEPENDS grass_gis grass_imagery + grass_raster grass_vector ${LIBM}) + +if(TARGET grass_ogsf) + build_program_in_subdir( + m.nviz.image + DEPENDS + grass_gis + grass_ogsf + grass_nviz + grass_vector + grass_dbmibase + grass_dbmiclient + grass_dbmidriver) + + build_program_in_subdir(m.nviz.script DEPENDS grass_display grass_raster + grass_gis ${LIBM}) +endif(TARGET grass_ogsf) diff --git a/msvc/creat.c b/msvc/creat.c new file mode 100644 index 00000000000..6bc6b0dc31d --- /dev/null +++ b/msvc/creat.c @@ -0,0 +1,22 @@ +/*! + * \file msvc/creat.c + * + * \brief A wrapper function for MSVC _creat() that converts permission mode. + * + * (C) 2025 by the GRASS Development Team + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * \author Huidae Cho + * + * \date 2025 + */ + +#include +#include + +int __creat(const char *pathname, int mode) +{ + return _creat(pathname, + (mode & 0400 ? _S_IREAD : 0) | (mode & 0200 ? _S_IWRITE : 0)); +} diff --git a/msvc/dirent.c b/msvc/dirent.c new file mode 100644 index 00000000000..981f35fa2cb --- /dev/null +++ b/msvc/dirent.c @@ -0,0 +1,102 @@ +#include +#include +#include +#include + +typedef ptrdiff_t handle_type; /* C99's intptr_t not sufficiently portable */ + +struct DIR { + handle_type handle; /* -1 for failed rewind */ + struct _finddata_t info; + struct dirent result; /* d_name null iff first time */ + char *name; /* null-terminated char string */ +}; + +DIR *opendir(const char *name) +{ + DIR *dir = 0; + + if (name && name[0]) { + size_t base_length = strlen(name); + const char *all = /* search pattern must end with suitable wildcard */ + strchr("/\\", name[base_length - 1]) ? "*" : "/*"; + dir = (DIR *)malloc(sizeof *dir); + if (dir != 0 && + (dir->name = (char *)malloc(base_length + strlen(all) + 1)) != 0) { + strcpy(dir->name, name); + strcat(dir->name, all); + + if ((dir->handle = + (handle_type)_findfirst(dir->name, &dir->info)) != -1) { + dir->result.d_name = 0; + } + else /* rollback */ + { + free(dir->name); + free(dir); + dir = 0; + } + } + else /* rollback */ + { + free(dir); + dir = 0; + errno = ENOMEM; + } + } + else { + errno = EINVAL; + } + + return dir; +} + +int closedir(DIR *dir) +{ + int result = -1; + + if (dir) { + if (dir->handle != -1) { + result = _findclose(dir->handle); + } + + free(dir->name); + free(dir); + } + + if (result == -1) /* map all errors to EBADF */ + { + errno = EBADF; + } + + return result; +} + +struct dirent *readdir(DIR *dir) +{ + struct dirent *result = 0; + + if (dir && dir->handle != -1) { + if (!dir->result.d_name || _findnext(dir->handle, &dir->info) != -1) { + result = &dir->result; + result->d_name = dir->info.name; + } + } + else { + errno = EBADF; + } + + return result; +} + +void rewinddir(DIR *dir) +{ + if (dir && dir->handle != -1) { + _findclose(dir->handle); + dir->handle = (handle_type)_findfirst(dir->name, &dir->info); + dir->result.d_name = 0; + } + else { + errno = EBADF; + } +} diff --git a/msvc/dirent.h b/msvc/dirent.h new file mode 100644 index 00000000000..8cd2229e21f --- /dev/null +++ b/msvc/dirent.h @@ -0,0 +1,48 @@ +#ifndef DIRENT_INCLUDED +#define DIRENT_INCLUDED + +/* + + Declaration of POSIX directory browsing functions and types for Win32. + + Author: Kevlin Henney (kevlin@acm.org, kevlin@curbralan.com) + History: Created March 1997. Updated June 2003. + Rights: See end of file. + +*/ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct DIR DIR; + +struct dirent { + char *d_name; +}; + +DIR *opendir(const char *); +int closedir(DIR *); +struct dirent *readdir(DIR *); +void rewinddir(DIR *); + +/* + + Copyright Kevlin Henney, 1997, 2003. All rights reserved. + + Permission to use, copy, modify, and distribute this software and its + documentation for any purpose is hereby granted without fee, provided + that this copyright and permissions notice appear in all copies and + derivatives. + + This software is supplied "as is" without express or implied warranty. + + But that said, if there are any problems please get in touch. + +*/ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/msvc/gettimeofday.c b/msvc/gettimeofday.c new file mode 100644 index 00000000000..4e10cb9e821 --- /dev/null +++ b/msvc/gettimeofday.c @@ -0,0 +1,70 @@ +/* + * Copied from vcpkg under the MIT license + * https://github.com/microsoft/vcpkg/blob/master/ports/gettimeofday/gettimeofday.c + */ + +/* + * Copied from PostgreSQL source: + * http://doxygen.postgresql.org/gettimeofday_8c_source.html + * + */ + +/* + * gettimeofday.c + * Win32 gettimeofday() replacement + * + * src/port/gettimeofday.c + * + * Copyright (c) 2003 SRA, Inc. + * Copyright (c) 2003 SKC, Inc. + * + * Permission to use, copy, modify, and distribute this software and + * its documentation for any purpose, without fee, and without a + * written agreement is hereby granted, provided that the above + * copyright notice and this paragraph and the following two + * paragraphs appear in all copies. + * + * IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, + * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING + * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS + * DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * + * THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS + * IS" BASIS, AND THE AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, + * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + */ + +#ifdef _MSC_VER + +#include + +/* FILETIME of Jan 1 1970 00:00:00. */ +static const unsigned __int64 epoch = 116444736000000000Ui64; + +/* + * timezone information is stored outside the kernel so tzp isn't used anymore. + * + * Note: this function is not for Win32 high precision timing purpose. See + * elapsed_time(). + */ +int gettimeofday(struct timeval *tp, struct timezone *tzp) +{ + FILETIME file_time; + SYSTEMTIME system_time; + ULARGE_INTEGER ularge; + + GetSystemTime(&system_time); + SystemTimeToFileTime(&system_time, &file_time); + ularge.LowPart = file_time.dwLowDateTime; + ularge.HighPart = file_time.dwHighDateTime; + + tp->tv_sec = (long)((ularge.QuadPart - epoch) / 10000000L); + tp->tv_usec = (long)(system_time.wMilliseconds * 1000); + + return 0; +} + +#endif /* _MSC_VER */ diff --git a/msvc/io.h b/msvc/io.h new file mode 100644 index 00000000000..ebdd1de7b07 --- /dev/null +++ b/msvc/io.h @@ -0,0 +1,37 @@ +/*! + * \file msvc/io.h + * + * \brief Header file for msvc/open.c and msvc/creat.c + * + * (C) 2025 by the GRASS Development Team + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * \author Huidae Cho + * + * \date 2025 + */ + +#ifndef GRASS_MSVC_IO_H +#define GRASS_MSVC_IO_H + +#include <../ucrt/io.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/* these wrapper functions convert UN*X permission mode for MSVC */ +int __open(const char *, int, ...); +int __creat(const char *, int); + +#ifdef __cplusplus +} +#endif + +#define open __open +#define creat __creat + +#define O_TMPFILE O_TEMPORARY + +#endif diff --git a/msvc/open.c b/msvc/open.c new file mode 100644 index 00000000000..7f92e792e2c --- /dev/null +++ b/msvc/open.c @@ -0,0 +1,37 @@ +/*! + * \file msvc/open.c + * + * \brief A wrapper function for MSVC _open() that converts permission mode. + * + * (C) 2025 by the GRASS Development Team + * + * SPDX-License-Identifier: GPL-2.0-or-later + * + * \author Huidae Cho + * + * \date 2025 + */ + +#include +#include +#include + +#define O_TMPFILE O_TEMPORARY + +int __open(const char *pathname, int flags, ...) +{ + if (flags & (O_CREAT | O_TMPFILE)) { + va_list ap; + int mode; + + va_start(ap, flags); + mode = va_arg(ap, int); + va_end(ap); + + return _open(pathname, flags, + (mode & 0400 ? _S_IREAD : 0) | + (mode & 0200 ? _S_IWRITE : 0)); + } + + return _open(pathname, flags); +} diff --git a/msvc/strings.h b/msvc/strings.h new file mode 100644 index 00000000000..12d39f1a473 --- /dev/null +++ b/msvc/strings.h @@ -0,0 +1,5 @@ +/* MSVC does not have strings.h */ +#ifndef _INC_STRINGS_H +#define _INC_STRINGS_H 1 +#include +#endif diff --git a/msvc/unistd.h b/msvc/unistd.h new file mode 100644 index 00000000000..5ec13da67af --- /dev/null +++ b/msvc/unistd.h @@ -0,0 +1,29 @@ +#ifndef GRASS_MSVC_UNISTD_H +#define GRASS_MSVC_UNISTD_H + +#include +#define access _access +#define close _close +#define dup _dup +#define dup2 _dup2 +#define unlink _unlink +#define isatty _isatty + +#include +#define rmdir _rmdir +#define getcwd _getcwd +#define chdir _chdir + +#include +#define getpid _getpid + +#define F_OK 0 /* Test for existence. */ +#define X_OK 1 /* Test for execute permission. */ +#define W_OK 2 /* Test for write permission. */ +#define R_OK 4 /* Test for read permission. */ + +#define STDIN_FILENO 0 /* Standard input. */ +#define STDOUT_FILENO 1 /* Standard output. */ +#define STDERR_FILENO 2 /* Standard error output. */ + +#endif diff --git a/ps/CMakeLists.txt b/ps/CMakeLists.txt new file mode 100644 index 00000000000..ee7fa452dc6 --- /dev/null +++ b/ps/CMakeLists.txt @@ -0,0 +1,36 @@ +build_program_in_subdir( + ps.map + DEPENDS + grass_gis + grass_raster + grass_gmath + grass_gproj + grass_imagery + grass_vector + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_symb + GDAL + ${LIBM}) + +add_custom_command( + TARGET ps.map + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/paint/decorations + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/paint/patterns + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/ps.map/prolog.ps + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/paint + COMMAND + ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_SOURCE_DIR}/ps.map/decorations + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/paint/decorations + COMMAND + ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_SOURCE_DIR}/ps.map/patterns + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/paint/patterns) + +install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/paint + DESTINATION ${GRASS_INSTALL_ETCDIR}) diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt new file mode 100644 index 00000000000..f3f28a0c1d0 --- /dev/null +++ b/python/CMakeLists.txt @@ -0,0 +1,2 @@ +add_subdirectory(grass) +add_subdirectory(libgrass_interface_generator) diff --git a/python/grass/CMakeLists.txt b/python/grass/CMakeLists.txt new file mode 100644 index 00000000000..eeb0be1deb2 --- /dev/null +++ b/python/grass/CMakeLists.txt @@ -0,0 +1,47 @@ +set(PYDIRS + app + benchmark + exceptions + grassdb + gunittest + imaging + jupyter + pydispatch + pygrass + pygrass/gis + pygrass/messages + pygrass/modules + pygrass/modules/grid + pygrass/modules/interface + pygrass/raster + pygrass/rpc + pygrass/shell + pygrass/tests + pygrass/vector + script + semantic_label + temporal + utils) + +set(PYDIR_GRASS ${GRASS_INSTALL_PYDIR}/grass) + +foreach(pydir ${PYDIRS}) + copy_python_files_in_subdir(${pydir} ${PYDIR_GRASS}) +endforeach() + +configure_file(__init__.py ${OUTDIR}/${PYDIR_GRASS}/ COPYONLY) +configure_file(script/setup.py ${OUTDIR}/${PYDIR_GRASS}/script/setup.py + COPYONLY) + +set(pydir_targets ${PYDIRS}) +list(TRANSFORM pydir_targets REPLACE "/" "_") +list(TRANSFORM pydir_targets PREPEND "python_") + +add_custom_target( + LIB_PYTHON + VERBATIM + DEPENDS ${pydir_targets}) + +set_target_properties(LIB_PYTHON PROPERTIES FOLDER lib) + +install(DIRECTORY ${OUTDIR}/${PYDIR_GRASS} DESTINATION ${GRASS_INSTALL_PYDIR}) diff --git a/python/grass/pygrass/CMakeLists.txt b/python/grass/pygrass/CMakeLists.txt new file mode 100644 index 00000000000..da001607086 --- /dev/null +++ b/python/grass/pygrass/CMakeLists.txt @@ -0,0 +1,26 @@ +execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory + etc/python/grass/pygrass/) +copy_python_file(${CMAKE_CURRENT_SOURCE_DIR}/errors.py etc/python/grass/pygrass) +copy_python_file(${CMAKE_CURRENT_SOURCE_DIR}/utils.py etc/python/grass/pygrass) +copy_python_file(${CMAKE_CURRENT_SOURCE_DIR}/orderdict.py + etc/python/grass/pygrass) + +build_pymodule_in_subdir(messages etc/python/grass/pygrass) + +build_pymodule_in_subdir(modules etc/python/grass/pygrass) + +build_pymodule_in_subdir(modules/interface etc/python/grass/pygrass/modules) + +build_pymodule_in_subdir(modules/grid etc/python/grass/pygrass/modules) + +build_pymodule_in_subdir(raster etc/python/grass/pygrass) + +build_pymodule_in_subdir(vector etc/python/grass/pygrass) + +build_pymodule_in_subdir(gis etc/python/grass/pygrass) + +build_pymodule_in_subdir(shell etc/python/grass/pygrass) + +build_pymodule_in_subdir(tests etc/python/grass/pygrass) + +build_pymodule_in_subdir(rpc etc/python/grass/pygrass) diff --git a/python/libgrass_interface_generator/CMakeLists.txt b/python/libgrass_interface_generator/CMakeLists.txt new file mode 100644 index 00000000000..97d587bd7cd --- /dev/null +++ b/python/libgrass_interface_generator/CMakeLists.txt @@ -0,0 +1,106 @@ +set(MODULES + date + gis + raster + gmath + proj + imagery + vector + rtree + display + stats + dbmi + raster3d + arraystats + cluster + vedit + segment + rowio + temporal) + +if(TARGET grass_ogsf) + list(APPEND MODULES ogsf nviz) +endif() + +set(date_HDRS datetime.h defs/datetime.h) +set(date_LIBS grass_datetime) +set(date_TARGET_NAME grass_datetime_py) + +set(gis_HDRS gis.h defs/gis.h colors.h defs/colors.h) +set(raster_HDRS raster.h defs/raster.h) +set(gmath_HDRS gmath.h defs/gmath.h) +set(proj_HDRS gprojects.h defs/gprojects.h) +set(proj_LIBS grass_gproj) +set(vector_HDRS vector.h defs/vector.h vect/dig_structs.h vect/dig_defines.h + vect/dig_externs.h) +set(display_HDRS display.h defs/display.h) +set(dbmi_HDRS dbmi.h defs/dbmi.h) +set(dbmi_LIBS grass_dbmibase grass_dbmiclient) +set(arraystats_HDRS arraystats.h defs/arraystats.h) +set(vedit_HDRS vedit.h defs/vedit.h) +set(nviz_HDRS nviz.h defs/nviz.h) +set(rowio_HDRS rowio.h defs/rowio.h) +set(temporal_HDRS temporal.h) +set(ogsf_HDRS ogsf.h defs/ogsf.h) +set(segment_HDRS segment.h defs/segment.h) +set(imagery_HDRS imagery.h defs/imagery.h) +set(rtree_HDRS rtree.h) +set(stats_HDRS stats.h defs/stats.h) +set(raster3d_HDRS raster3d.h defs/raster3d.h) +set(cluster_HDRS cluster.h defs/cluster.h) + +# TODO set(VECT_INC ${PQINCPATH} ) set(proj_INC "${PROJ_INCLUDE_DIR}") +# set(vector_INC "${PQINCPATH};${GDAL_INCLUDE_DIR}") set(vedit_INC +# "${GDAL_INCLUDE_DIR}") + +foreach(module ${MODULES}) + if(NOT ${module}_LIBS) + set(${module}_LIBS grass_${module}) + endif() + + if(NOT ${module}_HDRS) + message(FATAL_ERROR "${module}_HDRS is not set") + endif() + +#[[ + foreach(${module}_LIB ${${module}_LIBS}) + if(NOT TARGET ${${module}_LIB}) + message(FATAL_ERROR "${${module}_LIB} is not a target") + endif() + endforeach() +]] + + if(NOT ${module}_TARGET_NAME) + list(GET ${module}_LIBS 0 first_lib) + set(${module}_TARGET_NAME ${first_lib}_py) + endif() + + if(NOT ${module}_TARGET_NAME) + message(FATAL_ERROR "${${module}_TARGET_NAME} is not set") + endif() + + set(output_file "${OUTDIR}/${GRASS_INSTALL_PYDIR}/grass/lib/${module}.py") + add_custom_command( + OUTPUT ${output_file} + DEPENDS ${${module}_LIBS} + COMMAND + ${CMAKE_COMMAND} -DCTYPESGEN_PY=${CMAKE_CURRENT_SOURCE_DIR}/run.py + -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE} -DCOMPILER=${CMAKE_C_COMPILER} + "-DHDRS=${${module}_HDRS}" "-DLIBS=${${module}_LIBS}" -DOUTDIR=${OUTDIR} + -DGRASS_INSTALL_INCLUDEDIR=${GRASS_INSTALL_INCLUDEDIR} + -DGRASS_INSTALL_SCRIPTDIR=${GRASS_INSTALL_SCRIPTDIR} + -DGRASS_INSTALL_DEMODIR=${GRASS_INSTALL_DEMODIR} + -DGRASS_INSTALL_LIBDIR=${GRASS_INSTALL_LIBDIR} + -DRUNTIME_GISBASE=${RUNTIME_GISBASE} -DOUT_FILE=${output_file} + -DGRASS_VERSION_NUMBER=${GRASS_VERSION_NUMBER} + -DGRASS_VERSION_MAJOR=${GRASS_VERSION_MAJOR} + -DGRASS_VERSION_MINOR=${GRASS_VERSION_MINOR} -P + ${CMAKE_SOURCE_DIR}/cmake/ctypesgen.cmake + COMMENT "Generating ${output_file}" + VERBATIM) + + add_custom_target(${${module}_TARGET_NAME} ALL DEPENDS ${output_file}) + set_target_properties(${${module}_TARGET_NAME} PROPERTIES FOLDER lib/python) + install(FILES ${output_file} DESTINATION ${GRASS_INSTALL_PYDIR}/grass/lib) + +endforeach() diff --git a/raster/CMakeLists.txt b/raster/CMakeLists.txt new file mode 100644 index 00000000000..21ee29a9368 --- /dev/null +++ b/raster/CMakeLists.txt @@ -0,0 +1,665 @@ +set(raster_modules_list + r.basins.fill + r.buffer + r.buildvrt + r.carve + r.category + r.circle + r.clump + r.coin + r.colors + r.colors.out + r.composite + r.compress + r.contour + r.cost + r.covar + r.cross + r.describe + r.distance + r.external + r.external.out + r.fill.dir + r.fill.stats + r.flow + r.geomorphon + r.grow.distance + r.gwflow + r.his + r.horizon + r.in.ascii + r.in.bin + r.in.gdal + r.in.gridatb + r.in.lidar + r.in.mat + r.in.pdal + r.in.poly + r.in.xyz + r.info + r.kappa + r.lake + r.latlong + r.li + r.mapcalc + r.mfilter + r.mode + r.neighbors + r.null + r.object.geometry + r.out.ascii + r.out.bin + r.out.gdal + r.out.gridatb + r.out.mat + r.out.mpeg + r.out.pov + r.out.ppm + r.out.ppm3 + r.out.vrml + r.out.vtk + r.param.scale + r.patch + r.path + r.profile + r.proj + r.quant + r.quantile + r.random + r.random.cells + r.random.surface + r.reclass + r.recode + r.region + r.regression.line + r.regression.multi + r.relief + r.report + r.resamp.bspline + r.resamp.filter + r.resamp.interp + r.resamp.rst + r.resamp.stats + r.resample + r.rescale + r.rescale.eq + r.ros + r.series + r.series.accumulate + r.series.interp + r.sim + r.slope.aspect + r.solute.transport + r.spread + r.spreadpath + r.statistics + r.stats + r.stats.quantile + r.stats.zonal + r.stream.extract + r.sun + r.sunhours + r.sunmask + r.support + r.support.stats + r.surf.area + r.surf.contour + r.surf.fractal + r.surf.gauss + r.surf.idw + r.surf.random + r.terraflow + r.texture + r.thin + r.tile + r.timestamp + r.to.rast3 + r.to.rast3elev + r.to.vect + r.topidx + r.topmodel + r.transect + r.univar + r.uslek + r.usler + r.viewshed + r.volume + r.walk + r.water.outlet + r.watershed + r.what + r.what.color) + +if(WITH_LIBPNG) + list(APPEND raster_modules_list r.in.png r.out.png) +endif() + +if(MSVC) + list(REMOVE_ITEM raster_modules_list r.in.xyz) +endif() + +add_custom_target( + ALL_RASTER_MODULES ALL + DEPENDS ${raster_modules_list} + COMMENT "All raster modules are built.") + +if(WITH_DOCS) + generate_html(TARGET ALL_RASTER_MODULES NAME rasterintro) +endif() + +build_program_in_subdir(r.basins.fill DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.buildvrt DEPENDS grass_gis grass_raster grass_gmath ${LIBM}) + +build_program_in_subdir(r.buffer DEPENDS grass_gis grass_raster) + +build_program_in_subdir( + r.carve + DEPENDS + grass_gis + grass_raster + grass_vector + grass_bitmap + grass_dig2 + GDAL + ${LIBM}) + +build_program_in_subdir(r.category DEPENDS grass_gis grass_raster grass_parson) + +build_program_in_subdir(r.circle DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.clump DEPENDS grass_gis grass_raster grass_btree2) + +build_program_in_subdir(r.coin DEPENDS grass_gis grass_raster) + +add_subdirectory(r.colors) + +add_subdirectory(r.colors.out) + +build_program_in_subdir(r.composite DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.compress DEPENDS grass_gis grass_raster) + +build_program_in_subdir( + r.contour + DEPENDS + grass_gis + grass_raster + grass_vector + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL + ${LIBM}) + +build_program_in_subdir(r.cost DEPENDS grass_gis grass_raster grass_segment + grass_vector GDAL ${LIBM}) + +build_program_in_subdir(r.covar DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.cross DEPENDS grass_gis grass_raster grass_btree + grass_btree2) + +build_program_in_subdir(r.describe DEPENDS grass_gis grass_raster grass_parson) + +build_program_in_subdir(r.distance DEPENDS grass_gis grass_raster) + +build_program_in_subdir( + r.external + DEPENDS + grass_gis + grass_raster + grass_imagery + grass_gproj + GDAL + ${LIBM}) + +build_program_in_subdir(r.external.out DEPENDS grass_gis grass_raster GDAL) + +build_program_in_subdir(r.fill.dir DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.fill.stats DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir( + r.flow + DEPENDS + grass_gis + grass_raster + grass_segment + grass_vector + grass_bitmap + GDAL + ${LIBM}) + +build_program_in_subdir(r.geomorphon DEPENDS grass_gis grass_raster grass_gmath ${LIBM}) + +build_program_in_subdir(r.grow.distance DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.gwflow DEPENDS grass_gis grass_raster grass_gpde + grass_gmath) + +build_program_in_subdir(r.his DEPENDS grass_gis grass_raster grass_gproj) + +build_program_in_subdir(r.horizon DEPENDS grass_gis grass_raster grass_gproj + grass_parson GDAL ${LIBM}) + +build_program_in_subdir(r.in.ascii DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.in.bin DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir( + r.in.gdal + DEPENDS + grass_gis + grass_raster + grass_gproj + grass_imagery + GDAL + ${LIBM}) + +build_program_in_subdir(r.in.gridatb DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.in.mat DEPENDS grass_gis grass_raster) + +file(GLOB r_in_pdal_SOURCES "r.in.pdal/*.c" "r.in.pdal/*.cpp") +build_program_in_subdir( + r.in.pdal + SOURCES + "${r_in_pdal_SOURCES}" + DEPENDS + grass_gis + grass_raster + grass_vector + grass_gmath + grass_segment + grass_gproj + GDAL + ${LIBM} + PRIMARY_DEPENDS + PDAL) + +if(WITH_LIBPNG) + build_program_in_subdir(r.in.png DEPENDS grass_gis grass_raster LIBPNG) +endif() + +build_program_in_subdir(r.in.poly DEPENDS grass_gis grass_raster) + +if(NOT MSVC) + build_program_in_subdir(r.in.xyz DEPENDS grass_gis grass_raster ${LIBM}) +endif() +build_program_in_subdir(r.info TEST_SOURCES "test_r_info.py" DEPENDS grass_gis ${LIBM} + grass_raster grass_parson) + +build_program_in_subdir(r.kappa DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.latlong DEPENDS grass_gis grass_raster grass_gproj GDAL) + +build_program_in_subdir(r.lake DEPENDS grass_gis grass_raster) + +build_program_in_subdir( + r.mfilter + DEPENDS + grass_gis + grass_raster + grass_rowio + OPTIONAL_DEPENDS + OPENMP) + +build_program_in_subdir(r.mode DEPENDS grass_gis grass_raster) + +build_program_in_subdir( + r.neighbors + DEPENDS + grass_gis + grass_raster + grass_stats + ${LIBM} + OPTIONAL_DEPENDS + OPENMP) + +build_program_in_subdir(r.null DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.object.geometry DEPENDS grass_gis grass_raster grass_parson ${LIBM}) + +build_program_in_subdir(r.out.ascii DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.out.bin DEPENDS grass_gis grass_raster) + +build_program_in_subdir( + r.out.gdal + DEPENDS + grass_gis + grass_gproj + grass_imagery + grass_gis + grass_raster + grass_dbmibase + grass_imagery + GDAL + ${LIBM} + PROJ) + +set_source_files_properties( + r.out.gdal/main.c + PROPERTIES COMPILE_DEFINITIONS + "GRASS_VERSION_NUMBER=\"${GRASS_VERSION_NUMBER}\"") + +build_program_in_subdir(r.out.gridatb DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.out.mat DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.out.mpeg DEPENDS grass_gis grass_raster) + +if(WITH_LIBPNG) + build_program_in_subdir(r.out.png DEPENDS grass_gis grass_raster LIBPNG) +endif() + +build_program_in_subdir(r.out.pov DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.out.ppm DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.out.ppm3 DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.out.vrml DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.out.vtk DEPENDS grass_gis grass_raster) + +build_program_in_subdir( + r.param.scale + DEPENDS + grass_gis + grass_gmath + grass_raster + grass_interpfl + grass_interpdata + grass_qtree + ${LIBM}) + +build_program_in_subdir(r.patch DEPENDS grass_gis grass_raster OPTIONAL_DEPENDS + OPENMP) + +build_program_in_subdir(r.path DEPENDS grass_gis grass_raster grass_vector GDAL ${LIBM}) + +build_program_in_subdir(r.profile DEPENDS grass_gis grass_raster grass_parson ${LIBM}) + +build_program_in_subdir( + r.proj + DEPENDS + grass_gis + grass_raster + grass_gproj + GDAL + ${LIBM} + OPTIONAL_DEPENDS + OPENMP) + +build_program_in_subdir(r.quant DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.quantile DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir( + r.random + DEPENDS + grass_gis + grass_raster + grass_vector + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL + ${LIBM}) + +build_program_in_subdir(r.random.cells DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.random.surface DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.reclass DEPENDS grass_gis grass_raster grass_manage) + +build_program_in_subdir(r.recode DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.region DEPENDS grass_gis grass_raster grass_vector GDAL) + +build_program_in_subdir(r.regression.line DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.regression.multi DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.report DEPENDS grass_gis grass_raster grass_parson) + +build_program_in_subdir( + r.resamp.bspline + DEPENDS + grass_gis + grass_gmath + grass_raster + grass_vector + grass_segment + grass_lidar + GDAL + ${LIBM}) + +build_program_in_subdir(r.resamp.filter DEPENDS grass_gis grass_raster ${LIBM} + OPTIONAL_DEPENDS OPENMP) + +build_program_in_subdir(r.resamp.interp DEPENDS grass_gis grass_raster ${LIBM} + OPTIONAL_DEPENDS OPENMP) + +build_program_in_subdir( + r.resamp.rst + DEPENDS + grass_gis + grass_raster + grass_gmath + grass_interpfl + grass_interpdata + grass_qtree + GDAL) + + +build_program_in_subdir(r.resamp.stats DEPENDS grass_gis grass_raster + grass_stats ${LIBM}) + +build_program_in_subdir(r.resample DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.rescale DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.rescale.eq DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.ros DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir( + r.series + DEPENDS + grass_gis + grass_raster + grass_stats + OPTIONAL_DEPENDS + OPENMP) + +build_program_in_subdir( + r.series.accumulate + DEPENDS + grass_gis + grass_raster + grass_stats + OPTIONAL_DEPENDS + OPENMP) + +build_program_in_subdir(r.series.interp DEPENDS grass_gis grass_raster + grass_stats) + +build_program_in_subdir(r.relief DEPENDS grass_gis grass_raster ${LIBM}) + +add_subdirectory(r.sim) + +build_program_in_subdir(r.slope.aspect DEPENDS grass_gis grass_raster ${LIBM} + OPTIONAL_DEPENDS OPENMP) + +build_program_in_subdir(r.solute.transport DEPENDS grass_gis grass_raster + grass_gmath grass_gpde ${LIBM}) + +add_subdirectory(r.spread) + +build_program_in_subdir(r.spreadpath DEPENDS grass_gis grass_raster + grass_segment) + +build_program_in_subdir(r.statistics DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.stats.zonal DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.stats.quantile DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.stats DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir( + r.stream.extract + DEPENDS + grass_gis + grass_raster + grass_segment + grass_vector + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL + ${LIBM}) + +build_program_in_subdir( + r.sun + DEPENDS + grass_gis + grass_gmath + grass_raster + grass_gproj + GDAL + ${LIBM} + OPTIONAL_DEPENDS + OPENMP) + +build_program_in_subdir(r.sunhours DEPENDS grass_gis grass_raster grass_gproj GDAL ${LIBM}) + +build_program_in_subdir(r.sunmask DEPENDS grass_gis grass_raster grass_gproj GDAL ${LIBM}) + +build_program_in_subdir(r.support DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.support.stats DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.surf.area DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.surf.contour DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.surf.fractal DEPENDS grass_gis grass_raster + grass_gmath ${LIBM}) + +build_program_in_subdir(r.surf.gauss DEPENDS grass_gis grass_raster grass_gmath) + +build_program_in_subdir(r.surf.idw DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.surf.random DEPENDS grass_gis grass_raster + grass_gmath) + +if(MSVC) + set(USER_NAME $ENV{USERNAME}) +else() + set(USER_NAME $ENV{USER}) +endif() + +build_program_in_subdir(r.texture DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.thin DEPENDS grass_gis grass_raster grass_rowio) + +build_program_in_subdir(r.tile DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.timestamp DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.to.rast3 DEPENDS grass_gis grass_raster + grass_raster3d) + +build_program_in_subdir(r.to.rast3elev DEPENDS grass_gis grass_raster + grass_raster3d) + +build_program_in_subdir( + r.to.vect + DEPENDS + grass_gis + grass_raster + grass_vector + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL) + +build_program_in_subdir(r.topidx DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.topmodel DEPENDS grass_gis grass_raster ${LIBM}) + +build_program_in_subdir(r.transect DEPENDS grass_gis grass_raster ${LIBM}) + +add_subdirectory(r.univar) + +build_program_in_subdir(r.uslek DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.usler DEPENDS grass_gis grass_raster) + +build_program_in_subdir( + r.volume + DEPENDS + grass_gis + grass_raster + grass_vector + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL) + +build_program_in_subdir(r.walk DEPENDS grass_gis grass_raster grass_segment + grass_vector GDAL ${LIBM}) + +build_program_in_subdir(r.water.outlet DEPENDS grass_gis grass_raster) + +build_program_in_subdir(r.what DEPENDS grass_gis grass_raster grass_vector + grass_parson GDAL) + +build_program_in_subdir(r.what.color DEPENDS grass_gis grass_raster) + +build_program_in_subdir( + r.in.lidar + DEPENDS + grass_gis + grass_vector + grass_raster + grass_lidar + grass_gproj + grass_segment + PRIMARY_DEPENDS + LIBLAS + ${LIBM}) + +add_subdirectory(r.li) + +add_subdirectory(r.mapcalc) + +build_program_in_subdir( + r.viewshed + DEPENDS + grass_gis + grass_raster + grass_iostream + ${LIBM} + SRC_REGEX + "*.cpp" + DEFS + "-DUSER=${USER_NAME}") + +build_program_in_subdir( + r.terraflow + DEPENDS + grass_gis + grass_raster + grass_iostream + ${LIBM} + SRC_REGEX + "*.cpp" + DEFS + "-DUSER=${USER_NAME};-DNODATA_FIX;-DELEV_FLOAT") + +add_subdirectory(r.watershed) diff --git a/raster/r.colors.out/CMakeLists.txt b/raster/r.colors.out/CMakeLists.txt new file mode 100644 index 00000000000..9e3d0a593d7 --- /dev/null +++ b/raster/r.colors.out/CMakeLists.txt @@ -0,0 +1,20 @@ +build_program( + NAME + r.colors.out + SOURCES + raster_main.c + DEPENDS + grass_gis + grass_raster + grass_parson) + +build_program( + NAME + r3.colors.out + SOURCES + raster3d_main.c + DEPENDS + grass_gis + grass_raster + grass_raster3d + grass_parson) diff --git a/raster/r.colors/CMakeLists.txt b/raster/r.colors/CMakeLists.txt new file mode 100644 index 00000000000..c810b7e9efd --- /dev/null +++ b/raster/r.colors/CMakeLists.txt @@ -0,0 +1,24 @@ +set(r_colors_SRCS raster_main.c edit_colors.c rules.c stats.c) +set(r3_colors_SRCS raster3d_main.c edit_colors.c rules.c stats.c) + +build_program( + NAME + r.colors + SOURCES + "${r_colors_SRCS}" + DEPENDS + grass_gis + grass_raster + grass_raster3d + ${LIBM}) + +build_program( + NAME + r3.colors + SOURCES + "${r3_colors_SRCS}" + DEPENDS + grass_gis + grass_raster + grass_raster3d + ${LIBM}) diff --git a/raster/r.horizon/main.c b/raster/r.horizon/main.c index 576f85f3afa..4b675b13911 100644 --- a/raster/r.horizon/main.c +++ b/raster/r.horizon/main.c @@ -1188,8 +1188,10 @@ void calculate_raster_mode(const Settings *settings, const Geometry *geometry, _("Calculating map %01d of %01d (angle %.2f, raster map <%s>)"), (k + 1), arrayNumInt, angle_deg, shad_filename); + int j; + #pragma omp parallel for schedule(static, 1) default(shared) - for (int j = hor_row_start; j < hor_row_end; j++) { + for (j = hor_row_start; j < hor_row_end; j++) { G_percent(j - hor_row_start, hor_numrows - 1, 2); for (int i = hor_col_start; i < hor_col_end; i++) { OriginPoint origin_point; diff --git a/raster/r.li/CMakeLists.txt b/raster/r.li/CMakeLists.txt new file mode 100644 index 00000000000..eae49565492 --- /dev/null +++ b/raster/r.li/CMakeLists.txt @@ -0,0 +1,36 @@ +set(SUBDIRS1 + r.li.cwed + r.li.dominance + r.li.edgedensity + r.li.mpa + r.li.mps + r.li.padcv + r.li.padrange + r.li.padsd + r.li.patchdensity + r.li.patchnum + r.li.pielou + r.li.renyi + r.li.richness + r.li.shannon + r.li.shape + r.li.simpson) +# r.li.setup + +build_library_in_subdir( + r.li.daemon + NAME + grass_rli + DEPENDS + grass_gis + grass_raster + HTML_FILE_NAME + "r.li.daemon") + +if(WITH_DOCS) + generate_html(TARGET grass_rli NAME r.li) +endif() + +foreach(SUBDIR ${SUBDIRS1}) + build_program_in_subdir(${SUBDIR} DEPENDS grass_gis grass_rli grass_raster ${LIBM}) +endforeach() diff --git a/raster/r.li/r.li.daemon/daemon.c b/raster/r.li/r.li.daemon/daemon.c index 2ddee5a5c43..d1f31d9b8a5 100644 --- a/raster/r.li/r.li.daemon/daemon.c +++ b/raster/r.li/r.li.daemon/daemon.c @@ -23,7 +23,7 @@ #include #include -#ifdef __MINGW32__ +#ifdef _WIN32 #include #else #include diff --git a/raster/r.li/r.li.daemon/worker.c b/raster/r.li/r.li.daemon/worker.c index 83bfa62cc67..c272334595e 100644 --- a/raster/r.li/r.li.daemon/worker.c +++ b/raster/r.li/r.li.daemon/worker.c @@ -22,7 +22,7 @@ #include #include -#ifdef __MINGW32__ +#ifdef _WIN32 #include #else #include diff --git a/raster/r.mapcalc/CMakeLists.txt b/raster/r.mapcalc/CMakeLists.txt new file mode 100644 index 00000000000..bd31dcacef3 --- /dev/null +++ b/raster/r.mapcalc/CMakeLists.txt @@ -0,0 +1,45 @@ +flex_target(mapcalc.yy.c mapcalc.l ${CMAKE_CURRENT_BINARY_DIR}/mapcalc.yy.c) +bison_target(mapcalc.tab.c mapcalc.y ${CMAKE_CURRENT_BINARY_DIR}/mapcalc.tab.c) +add_flex_bison_dependency(mapcalc.yy.c mapcalc.tab.c) +set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/mapcalc.yy.c GENERATED) +set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/mapcalc.tab.c GENERATED) + +set(r_mapcalc_common_SRCS + column_shift.c + evaluate.c + expression.c + function.c + main.c + xrowcol.c + ${CMAKE_CURRENT_BINARY_DIR}/mapcalc.tab.c + ${CMAKE_CURRENT_BINARY_DIR}/mapcalc.yy.c) + +set(r_mapcalc_SRCS ${r_mapcalc_common_SRCS} map.c xarea.c xcoor.c xres.c) +set(r3_mapcalc_SRCS ${r_mapcalc_common_SRCS} map3.c xarea.c xcoor3.c xres3.c) + +build_program( + NAME + r.mapcalc + SOURCES + "${r_mapcalc_SRCS}" + DEPENDS + grass_btree + grass_calc + grass_gis + grass_raster + OPTIONAL_DEPENDS + READLINE) + +build_program( + NAME + r3.mapcalc + SOURCES + "${r3_mapcalc_SRCS}" + DEPENDS + grass_btree + grass_calc + grass_gis + grass_raster + grass_raster3d + OPTIONAL_DEPENDS + READLINE) diff --git a/raster/r.mapcalc/evaluate.c b/raster/r.mapcalc/evaluate.c index d8eadc73731..e5c2dcdd9d7 100644 --- a/raster/r.mapcalc/evaluate.c +++ b/raster/r.mapcalc/evaluate.c @@ -13,7 +13,7 @@ /****************************************************************************/ int current_depth, current_row; -int depths, rows; +int depths, rows, columns; /* Local variables for map management */ static expression **map_list = NULL; diff --git a/raster/r.mapcalc/map.c b/raster/r.mapcalc/map.c index 118453c0610..65bb85df170 100644 --- a/raster/r.mapcalc/map.c +++ b/raster/r.mapcalc/map.c @@ -22,7 +22,6 @@ /****************************************************************************/ static void prepare_region_from_maps(expression **, int, int); -int columns; struct Cell_head current_region2; void setup_region(void) diff --git a/raster/r.sim/CMakeLists.txt b/raster/r.sim/CMakeLists.txt new file mode 100644 index 00000000000..2191d4c4bf6 --- /dev/null +++ b/raster/r.sim/CMakeLists.txt @@ -0,0 +1,43 @@ +build_library_in_subdir( + simlib + NAME + grass_sim + DEPENDS + grass_gis + grass_datetime + grass_raster + grass_vector + grass_gmath + GDAL + ${LIBM} + OPTIONAL_DEPENDS + OPENMP + HEADERS + "waterglobs.h" + "simlib.h") + +build_program_in_subdir( + r.sim.water + DEPENDS + grass_gis + grass_gmath + grass_sim + grass_raster + GDAL + OPTIONAL_DEPENDS + OPENMP + INCLUDES + "../simlib") + +build_program_in_subdir( + r.sim.sediment + DEPENDS + grass_gis + grass_gmath + grass_sim + grass_raster + GDAL + OPTIONAL_DEPENDS + OPENMP + INCLUDES + "../simlib") diff --git a/raster/r.sim/simlib/waterglobs.h b/raster/r.sim/simlib/waterglobs.h index f1af5965027..5311081c327 100644 --- a/raster/r.sim/simlib/waterglobs.h +++ b/raster/r.sim/simlib/waterglobs.h @@ -6,6 +6,10 @@ #define UNDEF -9999 #include +#ifdef _MSC_VER +#undef min +#undef max +#endif extern char *elevin; extern char *dxin; diff --git a/raster/r.spread/CMakeLists.txt b/raster/r.spread/CMakeLists.txt new file mode 100644 index 00000000000..3187fe6be15 --- /dev/null +++ b/raster/r.spread/CMakeLists.txt @@ -0,0 +1,26 @@ +set(r_spread_SRCS + collect_ori.c + deleteHa.c + fixHa.c + get_minHa.c + insert2Ha.c + insertHa.c + main.c + pick_dist.c + pick_ignite.c + ram2out.c + replaceHa.c + select_linksB.c + spot.c + spread.c) + +build_program( + NAME + r.spread + SOURCES + "${r_spread_SRCS}" + DEPENDS + grass_gis + grass_raster + grass_display + ${LIBM}) diff --git a/raster/r.sun/main.c b/raster/r.sun/main.c index e325cb637f0..4ddd6fa6ff8 100644 --- a/raster/r.sun/main.c +++ b/raster/r.sun/main.c @@ -117,8 +117,6 @@ struct History hist; int INPUT_part(int offset, double *zmax); int OUTGR(void); -int min(int, int); -int max(int, int); /*void cube(int, int); void (*func) (int, int); */ diff --git a/raster/r.terraflow/common.cpp b/raster/r.terraflow/common.cpp index 854193476e0..964d6760585 100644 --- a/raster/r.terraflow/common.cpp +++ b/raster/r.terraflow/common.cpp @@ -22,7 +22,7 @@ #endif #include -#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) +#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || defined(_MSC_VER) #include #else #include diff --git a/raster/r.terraflow/direction.h b/raster/r.terraflow/direction.h index d98d463f7af..609b8d5c734 100644 --- a/raster/r.terraflow/direction.h +++ b/raster/r.terraflow/direction.h @@ -21,7 +21,7 @@ #include -#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) +#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1) || defined(_MSC_VER) #include #else #include diff --git a/raster/r.terraflow/filldepr.cpp b/raster/r.terraflow/filldepr.cpp index 82390d374b4..600cf9005b4 100644 --- a/raster/r.terraflow/filldepr.cpp +++ b/raster/r.terraflow/filldepr.cpp @@ -22,6 +22,9 @@ #include "unionFind.h" #include "common.h" +#ifdef _MSC_VER +#pragma warning(default : 4716) +#endif #define FLOOD_DEBUG if (0) /************************************************************/ diff --git a/raster/r.terraflow/flow.cpp b/raster/r.terraflow/flow.cpp index 83b7de0c378..a6bed97975e 100644 --- a/raster/r.terraflow/flow.cpp +++ b/raster/r.terraflow/flow.cpp @@ -62,7 +62,7 @@ void computeFlowAccumulation(AMI_STREAM *fillStream, perror("time"); exit(1); } -#ifdef __MINGW32__ +#ifdef _WIN32 strcpy(buf, ctime(&t)); #else ctime_r(&t, buf); diff --git a/raster/r.terraflow/main.cpp b/raster/r.terraflow/main.cpp index a831de23f6b..4aa1475190d 100644 --- a/raster/r.terraflow/main.cpp +++ b/raster/r.terraflow/main.cpp @@ -297,7 +297,7 @@ void record_args(int argc, char **argv) exit(1); } -#ifdef __MINGW32__ +#ifdef _WIN32 strcpy(buf, ctime(&t)); #else ctime_r(&t, buf); diff --git a/raster/r.terraflow/stats.cpp b/raster/r.terraflow/stats.cpp index 5325d72e466..ba804679bba 100644 --- a/raster/r.terraflow/stats.cpp +++ b/raster/r.terraflow/stats.cpp @@ -20,8 +20,10 @@ #include #include #include +#ifndef _MSC_VER #include -#ifndef __MINGW32__ +#endif +#ifndef _WIN32 #include #endif #include diff --git a/raster/r.to.vect/lines_io.c b/raster/r.to.vect/lines_io.c index 31dad0b903d..a8120da67b5 100644 --- a/raster/r.to.vect/lines_io.c +++ b/raster/r.to.vect/lines_io.c @@ -26,7 +26,7 @@ #include #include -#ifdef __MINGW32__ +#ifdef _WIN32 #include #else #include diff --git a/raster/r.to.vect/util.c b/raster/r.to.vect/util.c index 2a1498d88ec..93b629853b5 100644 --- a/raster/r.to.vect/util.c +++ b/raster/r.to.vect/util.c @@ -1,7 +1,7 @@ #include #include -#ifdef __MINGW32__ +#ifdef _WIN32 #include #else #include diff --git a/raster/r.univar/CMakeLists.txt b/raster/r.univar/CMakeLists.txt new file mode 100644 index 00000000000..c2979a42b47 --- /dev/null +++ b/raster/r.univar/CMakeLists.txt @@ -0,0 +1,29 @@ +set(r_univar_SRCS r.univar_main.c sort.c stats.c) +set(r3_univar_SRCS r3.univar_main.c sort.c stats.c) + +build_program( + NAME + r.univar + SOURCES + "${r_univar_SRCS}" + DEPENDS + grass_gis + grass_raster + grass_parson + ${LIBM} + OPTIONAL_DEPENDS + OPENMP) + +build_program( + NAME + r3.univar + SOURCES + "${r3_univar_SRCS}" + DEPENDS + grass_gis + grass_raster + grass_raster3d + grass_parson + ${LIBM} + OPTIONAL_DEPENDS + OPENMP) diff --git a/raster/r.univar/r.univar_main.c b/raster/r.univar/r.univar_main.c index e56301a1364..7a3cbc0c7c4 100644 --- a/raster/r.univar/r.univar_main.c +++ b/raster/r.univar/r.univar_main.c @@ -370,6 +370,7 @@ static void process_raster(univar_stat *stats, thread_workspace *tw, #endif int computed = 0; + int row; #pragma omp parallel { @@ -396,7 +397,7 @@ static void process_raster(univar_stat *stats, thread_workspace *tw, } #pragma omp for - for (int row = 0; row < rows; row++) { + for (row = 0; row < rows; row++) { thread_workspace *w = &tw[t_id]; Rast_get_row(w->fd, w->raster_row, row, map_type); diff --git a/raster/r.watershed/CMakeLists.txt b/raster/r.watershed/CMakeLists.txt new file mode 100644 index 00000000000..c99dcc96815 --- /dev/null +++ b/raster/r.watershed/CMakeLists.txt @@ -0,0 +1,25 @@ +build_program_in_subdir( + ram + DEPENDS + grass_gis + grass_raster + grass_btree2 + grass_gmath + ${LIBM} + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_ETCBINDIR}/r.watershed + NO_DOCS) + +build_program_in_subdir( + seg + DEPENDS + grass_gis + grass_raster + grass_gmath + grass_segment + ${LIBM} + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_ETCBINDIR}/r.watershed + NO_DOCS) + +build_program_in_subdir(front NAME r.watershed DEPENDS grass_gis grass_raster) diff --git a/raster3d/CMakeLists.txt b/raster3d/CMakeLists.txt new file mode 100644 index 00000000000..6ccddda3d21 --- /dev/null +++ b/raster3d/CMakeLists.txt @@ -0,0 +1,107 @@ +set(raster3d_modules_list + r3.cross.rast + r3.flow + r3.gradient + r3.gwflow + r3.in.ascii + r3.in.bin + r3.in.lidar + r3.in.v5d + r3.info + r3.mask + r3.mkdspf + r3.neighbors + r3.null + r3.out.ascii + r3.out.bin + r3.out.netcdf + r3.out.v5d + r3.out.vtk + r3.retile + r3.stats + r3.support + r3.timestamp + r3.to.rast) + +if(MSVC) + list(REMOVE_ITEM raster3d_modules_list r3.in.v5d r3.out.v5d) +endif() + +add_custom_target( + ALL_RASTER3D_MODULES ALL + DEPENDS ${raster3d_modules_list} + COMMENT "All temporal modules are built.") + +if(WITH_DOCS) + generate_html(TARGET ALL_RASTER3D_MODULES NAME raster3dintro) +endif() + +build_program_in_subdir(r3.cross.rast DEPENDS grass_gis grass_raster + grass_raster3d) + +add_subdirectory(r3.flow) + +build_program_in_subdir(r3.gradient DEPENDS grass_gis grass_raster3d ${LIBM}) + +build_program_in_subdir(r3.gwflow DEPENDS grass_gis grass_gmath grass_raster3d + grass_gpde) + +build_program_in_subdir(r3.in.ascii DEPENDS grass_gis grass_gmath grass_raster + grass_raster3d) + +build_program_in_subdir(r3.in.bin DEPENDS grass_gis grass_raster grass_raster3d) + +build_program_in_subdir(r3.info DEPENDS grass_gis grass_raster grass_raster3d) + +build_program_in_subdir(r3.mask DEPENDS grass_gis grass_raster3d) + +build_program_in_subdir(r3.null DEPENDS grass_gis grass_raster3d) + +build_program_in_subdir(r3.neighbors DEPENDS grass_gis grass_raster3d + grass_stats grass_raster) + +build_program_in_subdir(r3.out.ascii DEPENDS grass_gis grass_raster3d) + +build_program_in_subdir(r3.out.bin DEPENDS grass_gis grass_raster3d) + +if(NOT MSVC) + build_program_in_subdir(r3.out.v5d DEPENDS grass_gis grass_raster3d ${LIBM}) +endif() + +build_program_in_subdir(r3.retile DEPENDS grass_gis grass_raster grass_raster3d) + +build_program_in_subdir(r3.stats DEPENDS grass_gis grass_raster3d) + +build_program_in_subdir(r3.support DEPENDS grass_gis grass_raster + grass_raster3d) + +build_program_in_subdir(r3.timestamp DEPENDS grass_gis grass_raster3d) + +build_program_in_subdir(r3.to.rast DEPENDS grass_gis grass_raster + grass_raster3d) + +build_program_in_subdir(r3.out.vtk DEPENDS grass_gis grass_raster + grass_raster3d) + +build_program_in_subdir(r3.mkdspf DEPENDS grass_gis grass_raster3d grass_gpde + grass_dspf ${LIBM}) + +build_program_in_subdir( + r3.in.lidar + DEPENDS + grass_gis + grass_gproj + grass_raster + grass_raster3d + grass_segment + ${LIBM} + PRIMARY_DEPENDS + LIBLAS) + +build_program_in_subdir(r3.out.netcdf DEPENDS grass_gis grass_raster3d + PRIMARY_DEPENDS NETCDF) + +# mode_t is not available on msvc. Discuss +if(NOT MSVC) + build_program_in_subdir(r3.in.v5d DEPENDS grass_gis grass_raster3d ${LIBM}) +endif() diff --git a/raster3d/r3.flow/CMakeLists.txt b/raster3d/r3.flow/CMakeLists.txt new file mode 100644 index 00000000000..2ca58d8bb8c --- /dev/null +++ b/raster3d/r3.flow/CMakeLists.txt @@ -0,0 +1,36 @@ +set(r3_flow_SRCS main.c flowline.c integrate.c interpolate.c voxel_traversal.c) + +build_program( + NAME + r3.flow + SOURCES + "${r3_flow_SRCS}" + DEPENDS + grass_gis + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_raster + grass_raster3d + grass_vector + GDAL + ${LIBM}) + +set(test_r3flow_SRCS test_main.c flowline.c integrate.c interpolate.c + voxel_traversal.c) + +build_program( + NAME + test.r3flow + SOURCES + "${test_r3flow_SRCS}" + DEPENDS + grass_gis + grass_raster + grass_raster3d + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_vector + GDAL + ${LIBM}) diff --git a/scripts/CMakeLists.txt b/scripts/CMakeLists.txt new file mode 100644 index 00000000000..cfd7af2b828 --- /dev/null +++ b/scripts/CMakeLists.txt @@ -0,0 +1,155 @@ +set(script_DIRS + d.background + d.correlate + d.frame + d.out.file + d.polar + d.rast.edit + d.rast.leg + d.shade + d.to.rast + d.what.rast + d.what.vect + db.dropcolumn + db.droptable + db.in.ogr + db.out.ogr + db.test + db.univar + g.download.location + g.download.project + g.extension + g.extension.all + g.manual + g.search.modules + i.band.library + i.colors.enhance + i.image.mosaic + i.in.spotvgt + i.oif + i.pansharpen + i.spectral + i.tasscap + m.proj + r.blend + r.buffer.lowmem + r.colors.stddev + r.drain + r.fillnulls + r.grow + r.import + r.in.aster + r.in.srtm + r.in.wms + r.mapcalc.simple + r.mask + r.out.xyz + r.pack + r.plane + r.reclass.area + r.rgb + r.semantic.label + r.shade + r.tileset + r.unpack + r3.in.xyz + v.build.all + v.centroids + v.clip + v.db.addcolumn + v.db.addtable + v.db.dropcolumn + v.db.droprow + v.db.droptable + v.db.join + v.db.reconnect.all + v.db.renamecolumn + v.db.univar + v.db.update + v.dissolve + v.import + v.in.e00 + v.in.geonames + v.in.lines + v.in.mapgen + v.in.wfs + v.pack + v.rast.stats + v.report + v.to.lines + v.unpack + v.what.strds + v.what.vect + wxpyimgview) + +foreach(script_DIR ${script_DIRS}) + build_script_in_subdir(${script_DIR}) +endforeach() + +add_custom_command( + TARGET d.polar + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/d.polar + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/d.polar/ps_defs.eps + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/d.polar) +install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/d.polar + DESTINATION ${GRASS_INSTALL_ETCDIR}) + +add_custom_command( + TARGET db.test + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/db.test + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/db.test/test1 + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/db.test) +install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/db.test + DESTINATION ${GRASS_INSTALL_ETCDIR}) + +add_custom_command( + TARGET i.band.library + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/i.band.library + COMMAND + ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_SOURCE_DIR}/i.band.library/landsat.json + ${CMAKE_CURRENT_SOURCE_DIR}/i.band.library/sentinel.json + ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/i.band.library) +install(DIRECTORY ${OUTDIR}/${GRASS_INSTALL_ETCDIR}/i.band.library + DESTINATION ${GRASS_INSTALL_ETCDIR}) + +# TODO: Create CMakeLists.txt in scripts/r.in.wms and scripts/wxpyimgview +# respectively, and put the following there. + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/r.in.wms + DESTINATION ${OUTDIR}/${GRASS_INSTALL_ETCBINDIR}) + +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/wxpyimgview/wxpyimgview_gui.py + DESTINATION ${OUTDIR}/${GRASS_INSTALL_ETCBINDIR}) + +add_custom_target( + r.in.wms_files + COMMAND ${CMAKE_COMMAND} -E make_directory + ${OUTDIR}/${GRASS_INSTALL_ETCBINDIR}/r.in.wms + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/r.in.wms/wms_base.py + ${OUTDIR}/${GRASS_INSTALL_ETCBINDIR}/r.in.wms + COMMAND + ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_SOURCE_DIR}/r.in.wms/wms_cap_parsers.py + ${OUTDIR}/${GRASS_INSTALL_ETCBINDIR}/r.in.wms + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/r.in.wms/wms_drv.py + ${OUTDIR}/${GRASS_INSTALL_ETCBINDIR}/r.in.wms + COMMAND + ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_SOURCE_DIR}/r.in.wms/wms_gdal_drv.py + ${OUTDIR}/${GRASS_INSTALL_ETCBINDIR}/r.in.wms + COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/r.in.wms/srs.py + ${OUTDIR}/${GRASS_INSTALL_ETCBINDIR}/r.in.wms + DEPENDS v.to.lines) +add_dependencies(r.in.wms r.in.wms_files) + +set_target_properties(r.in.wms_files PROPERTIES FOLDER scripts) diff --git a/temporal/CMakeLists.txt b/temporal/CMakeLists.txt new file mode 100644 index 00000000000..ae4fc25fab6 --- /dev/null +++ b/temporal/CMakeLists.txt @@ -0,0 +1,68 @@ +set(temporal_script_modules_list + t.copy + t.create + t.info + t.list + t.merge + t.rast.accdetect + t.rast.accumulate + t.rast.aggregate + t.rast.aggregate.ds + t.rast.algebra + t.rast.colors + t.rast.contour + t.rast.export + t.rast.extract + t.rast.gapfill + t.rast.import + t.rast.list + t.rast.mapcalc + t.rast.neighbors + t.rast.out.vtk + t.rast.series + t.rast.to.rast3 + t.rast.to.vect + t.rast.univar + t.rast.what + t.rast3d.algebra + t.rast3d.extract + t.rast3d.list + t.rast3d.mapcalc + t.rast3d.univar + t.register + t.remove + t.rename + t.sample + t.select + t.shift + t.snap + t.support + t.topology + t.unregister + t.upgrade + t.vect.algebra + t.vect.db.select + t.vect.export + t.vect.extract + t.vect.import + t.vect.list + t.vect.observe.strds + t.vect.univar + t.vect.what.strds) + +set(temporal_modules_list t.connect) + +add_custom_target( + ALL_TEMPORAL_MODULES ALL + DEPENDS ${temporal_script_modules_list} ${temporal_modules_list} + COMMENT "All temporal modules are built.") + +if(WITH_DOCS) + generate_html(TARGET ALL_TEMPORAL_MODULES NAME temporalintro) +endif() + +build_program_in_subdir(t.connect DEPENDS grass_gis grass_temporal) + +foreach(temporal_DIR ${temporal_script_modules_list}) + build_script_in_subdir(${temporal_DIR}) +endforeach() diff --git a/utils/CMakeLists.txt b/utils/CMakeLists.txt new file mode 100644 index 00000000000..8f0c2f53481 --- /dev/null +++ b/utils/CMakeLists.txt @@ -0,0 +1,84 @@ +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/mkhtml.py + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/mkdocs.py + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/mkmarkdown.py + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/mkrest.py + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/thumbnails.py + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) +file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/generate_last_commit_file.py + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) + +set(current_time_s_ms_SRCS "timer/main.c") +if(MSVC) + list(APPEND current_time_s_ms_SRCS "../msvc/gettimeofday.c") +endif() +build_program_in_subdir( + timer + NAME + current_time_s_ms + DEPENDS + grass_gis + SOURCES + "${current_time_s_ms_SRCS}" + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_ETCBINDIR} + NO_DOCS) + +build_program( + NAME + g.echo + SOURCES + g.echo.c + RUNTIME_OUTPUT_DIR + ${GRASS_INSTALL_UTILSDIR} + PACKAGE + "NONE" + NO_DOCS) +add_dependencies(g.echo python_doc_utils) +add_custom_target( + python_doc_utils + COMMAND + ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_SOURCE_DIR}/g.html2man/g.html2man.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR} + COMMAND + ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_SOURCE_DIR}/generate_last_commit_file.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR} + COMMAND + ${CMAKE_COMMAND} -E copy + ${CMAKE_CURRENT_SOURCE_DIR}/g.html2man/g.html2man.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR} + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/g.html2man/ggroff.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR} + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/g.html2man/ghtml.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR} + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/mkhtml.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR} + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/mkdocs.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR} + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/mkmarkdown.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR} + COMMAND + ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/mkrest.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}) + +install( + FILES ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/g.html2man.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/generate_last_commit_file.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/ggroff.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/g.html2man.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/ghtml.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/mkhtml.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/mkdocs.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/mkmarkdown.py + ${OUTDIR}/${GRASS_INSTALL_UTILSDIR}/mkrest.py + DESTINATION ${GRASS_INSTALL_UTILSDIR}) diff --git a/utils/timer/main.c b/utils/timer/main.c index 72a1f9c3813..38fe0926b0b 100644 --- a/utils/timer/main.c +++ b/utils/timer/main.c @@ -12,8 +12,13 @@ * for details. * *****************************************************************************/ - +#ifdef _MSC_VER +#include +#include +#else #include +#endif + #include #include diff --git a/vector/CMakeLists.txt b/vector/CMakeLists.txt new file mode 100644 index 00000000000..6afc477f806 --- /dev/null +++ b/vector/CMakeLists.txt @@ -0,0 +1,1022 @@ +set(vector_modules_list + v.buffer + v.build + v.build.polylines + v.category + v.class + v.clean + v.cluster + v.colors + v.colors.out + v.db.connect + v.db.select + v.decimate + v.delaunay + v.distance + v.drape + v.edit + v.external + v.external.out + v.extract + v.extrude + v.fill.holes + v.generalize + v.hull + v.in.ascii + v.in.db + v.in.dxf + v.in.lidar + v.in.ogr + v.in.pdal + v.in.region + v.info + v.kcv + v.kernel + v.label + v.label.sa + v.lidar.correction + v.lidar.edgedetection + v.lidar.growing + v.lrs.create + v.lrs.label + v.lrs.segment + v.lrs.where + v.mkgrid + v.neighbors + v.net + v.net.alloc + v.net.allpairs + v.net.bridge + v.net.centrality + v.net.components + v.net.connectivity + v.net.distance + v.net.flow + v.net.iso + v.net.path + v.net.salesman + v.net.spanningtree + v.net.steiner + v.net.timetable + v.net.visibility + v.normal + v.out.ascii + v.out.dxf + v.out.lidar + v.out.ogr + v.out.postgis + v.out.pov + v.out.svg + v.out.vtk + v.outlier + v.overlay + v.parallel + v.patch + v.perturb + v.profile + v.proj + v.qcount + v.random + v.reclass + v.rectify + v.sample + v.segment + v.select + v.split + v.support + v.surf.bspline + v.surf.idw + v.surf.rst + v.timestamp + v.to.3d + v.to.db + v.to.points + v.to.rast + v.to.rast3 + v.transform + v.type + v.univar + v.vect.stats + v.vol.rst + v.voronoi + v.what + v.what.rast + v.what.rast3) + +if(WITH_OPENDWG) + list(APPEND vector_modules_list v.in.dwg) +endif() + +add_custom_target( + ALL_VECTOR_MODULES ALL + DEPENDS ${vector_modules_list} + COMMENT "All vector modules are built.") + +if(WITH_DOCS) + generate_html(TARGET ALL_VECTOR_MODULES NAME vectorintro) + generate_html(TARGET ALL_VECTOR_MODULES NAME lrs SOURCEDIR + ${CMAKE_CURRENT_SOURCE_DIR}/v.lrs) +endif() + +build_program_in_subdir( + v.buffer + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir(v.build DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir(v.build.polylines DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir(v.category DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir( + v.class + DEPENDS + grass_arraystats + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir(v.clean DEPENDS grass_gis grass_vector GDAL ${LIBM}) + +build_program_in_subdir(v.cluster DEPENDS grass_btree2 grass_gis grass_vector GDAL ${LIBM}) + +build_program_in_subdir( + v.colors + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_raster3d + grass_vector + GDAL) + +build_program_in_subdir( + v.colors.out + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_vector + GDAL) + +build_program_in_subdir( + v.db.connect + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.db.select + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.decimate + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_vector + GDAL) + +build_program_in_subdir(v.delaunay DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir( + v.distance + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gmath + grass_vector + grass_parson + GDAL + ${LIBM}) + +build_program_in_subdir(v.drape DEPENDS grass_gis grass_raster grass_vector GDAL) + +build_program_in_subdir( + v.edit + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + grass_vedit + GDAL) + +build_program_in_subdir( + v.extract + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gmath + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.extrude + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_vector + GDAL) + +build_program_in_subdir( + v.fill.holes + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.generalize + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_dgl + grass_dig2 + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir(v.hull DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir( + v.info + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_dig2 + grass_gis + grass_vector + grass_parson + GDAL) + +build_program_in_subdir( + v.in.ascii + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.in.db + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.in.dxf + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +file(GLOB v_in_pdal_SOURCES "v.in.pdal/*.c" "v.in.pdal/main.cpp") +build_program_in_subdir( + v.in.pdal + SOURCES + "${v_in_pdal_SOURCES}" + DEPENDS + grass_gis + grass_gproj + grass_vector + GDAL + ${LIBM} + PRIMARY_DEPENDS + PDAL) + +build_program_in_subdir( + v.in.region + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_vector + GDAL) + +build_program_in_subdir( + v.kcv + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir(v.kernel DEPENDS grass_gis grass_gmath grass_raster + grass_vector GDAL ${LIBM}) + +build_program_in_subdir( + v.label + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_display + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.label.sa + DEPENDS + FREETYPE + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_dig2 + grass_display + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir(v.proj DEPENDS grass_gis grass_gproj grass_vector GDAL ${LIBM}) + +build_program_in_subdir( + v.profile + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_gis + grass_vector + GDAL) + +add_subdirectory(v.lrs) + +build_program_in_subdir( + v.mkgrid + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.neighbors + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_stats + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.net + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.net.alloc + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_dgl + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.net.allpairs + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_neta + grass_vector + GDAL) + +build_program_in_subdir(v.net.bridge DEPENDS grass_gis grass_neta grass_vector GDAL) + +build_program_in_subdir( + v.net.centrality + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_dgl + grass_gis + grass_neta + grass_vector + GDAL) + +build_program_in_subdir( + v.net.components + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_neta + grass_vector + GDAL) + +build_program_in_subdir(v.net.connectivity DEPENDS grass_gis grass_neta + grass_vector GDAL) + +build_program_in_subdir( + v.net.distance + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_dgl + grass_gis + grass_neta + grass_vector + GDAL) + +build_program_in_subdir( + v.net.flow + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_neta + grass_vector + GDAL) + +build_program_in_subdir( + v.net.iso + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_dgl + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.net.path + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir(v.net.salesman DEPENDS grass_gis grass_neta + grass_vector GDAL) + +build_program_in_subdir(v.net.spanningtree DEPENDS grass_gis grass_neta + grass_vector GDAL) + +build_program_in_subdir(v.net.steiner DEPENDS grass_gis grass_neta grass_vector GDAL) + +build_program_in_subdir( + v.net.timetable + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_neta + grass_vector + GDAL) + +build_program_in_subdir(v.net.visibility DEPENDS grass_dgl grass_gis + grass_vector GDAL) + +build_program_in_subdir( + v.normal + DEPENDS + grass_cdhc + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir(v.out.ascii DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir(v.out.dxf DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir(v.out.pov DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir( + v.out.svg + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.out.vtk + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.outlier + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gmath + grass_lidar + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.overlay + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir(v.parallel DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir( + v.patch + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.perturb + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir(v.split DEPENDS grass_gis grass_vector GDAL ${LIBM}) + +build_program_in_subdir(v.qcount DEPENDS grass_gis grass_vector GDAL ${LIBM}) + +build_program_in_subdir( + v.random + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.reclass + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir(v.rectify DEPENDS grass_gis grass_gmath grass_imagery + grass_vector GDAL ${LIBM}) + +build_program_in_subdir( + v.sample + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_vector + GDAL) + +build_program_in_subdir(v.segment DEPENDS grass_gis grass_vector GDAL ${LIBM}) + +build_program_in_subdir( + v.select + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir(v.support DEPENDS grass_gis grass_vector GDAL) + +build_program_in_subdir( + v.surf.bspline + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gmath + grass_gpde + grass_lidar + grass_raster + grass_segment + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.surf.idw + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.surf.rst + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gmath + grass_interpdata + grass_interpfl + grass_qtree + grass_vector + grass_raster + GDAL + ${LIBM} + OPTIONAL_DEPENDS + OPENMP) + +build_program_in_subdir( + v.transform + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir(v.timestamp DEPENDS grass_gis grass_vector) + +build_program_in_subdir( + v.to.3d + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.to.db + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.to.points + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.to.rast + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.to.rast3 + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster3d + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir(v.type DEPENDS grass_gis grass_vector GDAL) + +# XXX: to workaround an MSVC bug where NAN is not a contant +# v.univar\main.c(77,8): error C2099: initializer is not a constant +# REMOVEME later once the fix is released +# https://developercommunity.visualstudio.com/t/NAN-is-no-longer-compile-time-constant-i/10688907#T-N10849410 +set(ucrt_noisy_nan_DEFS "") +if(WIN32) + set(ucrt_noisy_nan_DEFS "-D_UCRT_NOISY_NAN") +endif() + +build_program_in_subdir( + v.univar + DEFS + "${ucrt_noisy_nan_DEFS}" + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + grass_parson + GDAL + ${LIBM}) + +build_program_in_subdir( + v.voronoi + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_dig2 + grass_gis + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.what + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + GDAL) + +build_program_in_subdir( + v.what.rast + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_vector + GDAL) + +build_program_in_subdir( + v.what.rast3 + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster3d + grass_vector + GDAL) + +build_program_in_subdir( + v.vect.stats + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_stats + grass_vector + GDAL) + +build_program_in_subdir( + v.vol.rst + DEPENDS + grass_bitmap + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_raster + grass_raster3d + grass_vector + GDAL + ${LIBM}) + +build_program_in_subdir( + v.out.ogr + DEPENDS + GDAL + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gproj + grass_vector + PROJ) + +build_program_in_subdir( + v.in.ogr + DEPENDS + GDAL + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gproj + grass_vector + ${LIBM}) + +build_program_in_subdir( + v.external + DEPENDS + GDAL + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gproj + grass_vector + PROJ + OPTIONAL_DEPENDS + POSTGRES) + +build_program_in_subdir(v.external.out DEPENDS GDAL grass_gis grass_vector) + +build_program_in_subdir( + v.in.lidar + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gproj + grass_vector + ${LIBM} + PRIMARY_DEPENDS + LIBLAS) + +build_program_in_subdir( + v.lidar.correction + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gmath + grass_lidar + grass_vector + ${LIBM} + PRIMARY_DEPENDS + LIBLAS) + +build_program_in_subdir( + v.lidar.edgedetection + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gmath + grass_lidar + grass_vector + ${LIBM} + PRIMARY_DEPENDS + LIBLAS) + +build_program_in_subdir( + v.lidar.growing + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gmath + grass_raster + grass_vector + PRIMARY_DEPENDS + LIBLAS) + +build_program_in_subdir( + v.out.lidar + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_gproj + grass_raster + grass_vector + ${LIBM} + PRIMARY_DEPENDS + LIBLAS) + +build_program_in_subdir( + v.out.postgis + DEPENDS + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + grass_gis + grass_vector + PRIMARY_DEPENDS + POSTGRES) + +if(WITH_OPENDWG) + build_program_in_subdir(v.in.dwg DEPENDS grass_gis grass_vector ${LIBM}) +endif() diff --git a/vector/v.in.pdal/main.cpp b/vector/v.in.pdal/main.cpp index 0f48e1d5fea..6886328b6d4 100644 --- a/vector/v.in.pdal/main.cpp +++ b/vector/v.in.pdal/main.cpp @@ -36,6 +36,7 @@ extern "C" { #include #include #include +#include } extern "C" { diff --git a/vector/v.lrs/CMakeLists.txt b/vector/v.lrs/CMakeLists.txt new file mode 100644 index 00000000000..ebfd88f97f1 --- /dev/null +++ b/vector/v.lrs/CMakeLists.txt @@ -0,0 +1,58 @@ +build_library_in_subdir( + lib + NAME + grass_lrs + DEPENDS + grass_gis + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + HEADERS + "lrs.h") +add_dependencies(grass_lrs db.drivers) +build_program_in_subdir( + v.lrs.create + DEPENDS + grass_lrs + grass_vector + grass_gis + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL + ${LIBM}) + +build_program_in_subdir( + v.lrs.segment + DEPENDS + grass_lrs + grass_vector + grass_gis + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL + ${LIBM}) + +build_program_in_subdir( + v.lrs.label + DEPENDS + grass_lrs + grass_vector + grass_gis + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL + ${LIBM}) + +build_program_in_subdir( + v.lrs.where + DEPENDS + grass_lrs + grass_vector + grass_gis + grass_dbmibase + grass_dbmiclient + grass_dbmidriver + GDAL)