cmake: use imported targets

Author: scivision

.github/workflows/ci_linux.yml

@@ -3,7 +3,7 @@ name: ci_linux
 on:
   push:
     paths:
-      - "**.txt"
+      - "**/CMakeLists.txt"
       - "**.cmake"
       - "**.f90"
       - ".github/workflows/ci_linux.yml"
@@ -14,15 +14,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - uses: actions/setup-python@v2
-      with:
-        python-version: '3.x'
 
     - run: |
         sudo apt update -yq
         sudo apt install -yq --no-install-recommends gfortran libnetcdff-dev
 
-    - run: cmake --warn-uninitialized -B build
-    - run: ctest -S setup.cmake -V
-      env:
-        FC: gfortran
+    - run: ctest -S setup.cmake -VV

.github/workflows/ci_linux_meson.yml

@@ -3,9 +3,10 @@ name: ci_linux_meson
 on:
   push:
     paths:
-      - "**.build"
+      - "**/meson.build"
       - ".github/workflows/ci_linux_meson.yml"
 
+
 jobs:
 
   meson:
@@ -22,10 +23,7 @@ jobs:
         sudo apt install -yq --no-install-recommends gfortran ninja-build libnetcdff-dev
 
     - run: meson setup build
-
-    - run: ninja -C build
-
-    # this catches configuration and build log
+    - run: meson compile -C build
     - uses: actions/upload-artifact@v1
       if: failure()
       with:

.github/workflows/ci_mac.yml

@@ -3,9 +3,8 @@ name: ci_mac
 on:
   push:
     paths:
-      - "**.txt"
+      - "**/CMakeLists.txt"
       - "**.cmake"
-      - "**.f90"
       - ".github/workflows/ci_mac.yml"
 
 jobs:

CMakeLists.txt

@@ -1,11 +1,11 @@
-cmake_minimum_required(VERSION 3.13)  # 3.13 for target_sources() absolute
+cmake_minimum_required(VERSION 3.14)
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release CACHE STRING "Debug or Release")
 endif()
 project(nc4fortran
   LANGUAGES Fortran
   VERSION 0.4.4
-  DESCRIPTION "thin, light, easy NetCDF4 Fortran interface"
+  DESCRIPTION "thin, light object-oriented NetCDF4 Fortran interface"
   HOMEPAGE_URL https://github.com/geospace-code/nc4fortran)
 
 enable_testing()
@@ -23,23 +23,22 @@ include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/netcdf.cmake)
 
 if(NOT NCDFOK)
   message(STATUS "nc4fortran: NetCDF4 not working")
-  if(NOT PROJECT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+  if(PROJECT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    message(FATAL_ERROR)
+  else()
     return()
   endif()
 endif()
 
-set(CTEST_TEST_TIMEOUT 15)
-
 # --- build
 
 add_library(nc4fortran)
 target_include_directories(nc4fortran
-  PRIVATE ${NetCDF_INCLUDE_DIRS}
   PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/include  # for IBM XL
   INTERFACE
   $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
   $<INSTALL_INTERFACE:include>)
-target_link_libraries(nc4fortran PUBLIC ${NetCDF_LIBRARIES})
+target_link_libraries(nc4fortran PUBLIC NetCDF::NetCDF_Fortran)
 set_target_properties(nc4fortran PROPERTIES Fortran_MODULE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include)
 add_library(nc4fortran::nc4fortran ALIAS nc4fortran)
 

cmake/Modules/FindNetCDF.cmake

@@ -1,16 +1,55 @@
-# based on: https://github.com/Kitware/VTK/blob/master/CMake/FindNetCDF.cmake
-# in general, NetCDF requires C compiler even if only using Fortran
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindNetCDF
+----------
+
+Find NetCDF4 library
+
+based on: https://github.com/Kitware/VTK/blob/master/CMake/FindNetCDF.cmake
+in general, NetCDF requires C compiler even if only using Fortran
+
+Imported targets
+^^^^^^^^^^^^^^^^
+
+This module defines the following :prop_tgt:`IMPORTED` target:
+
+``NetCDF::NetCDF_C``
+  NetCDF C / C++ libraries
+
+``NetCDF::NetCDF_Fortran``
+  NetCDF Fortran libraries
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module defines the following variables:
+
+``NetCDF_FOUND``
+  NetCDF4 is found (also ``NetCDF_C_FOUND`` and ``NetCDF_Fortran_FOUND``)
+``NetCDF_C_LIBRARIES`` and ``NetCDF_Fortran_LIBRARIES
+  uncached list of libraries (using full path name) to link against
+``NetCDF_C_INCLUDE_DIRS`` and ``NetCDF_Fortran_INCLUDE_DIRS``
+  uncached list of libraries (using full path name) to include
+
+Search details:
+
+1. look for CMake-build config files (for C / C++ only)
+2. CMake manual search optionally using pkg-config (this step always needed for Fortran, and for C if step 1 fails)
+
+#]=======================================================================]
 
 function(netcdf_c)
 
-pkg_check_modules(pc_nc netcdf QUIET)  # C / CXX
+pkg_check_modules(pc_nc netcdf QUIET)
 
-find_path(NetCDF_INCLUDE_DIR
+find_path(NetCDF_C_INCLUDE_DIR
   NAMES netcdf.h
   HINTS ${pc_nc_INCLUDE_DIRS}
-  DOC "NetCDF include directories")
+  DOC "NetCDF C include directory")
 
-if(NOT NetCDF_INCLUDE_DIR)
+if(NOT NetCDF_C_INCLUDE_DIR)
   return()
 endif()
 
@@ -24,20 +63,17 @@ if(NOT NetCDF_C_LIBRARY)
 endif()
 
 set(NetCDF_C_FOUND true PARENT_SCOPE)
-set(NetCDF_INCLUDE_DIR ${NetCDF_INCLUDE_DIR} PARENT_SCOPE)
-set(NetCDF_LIBRARY ${NetCDF_C_LIBRARY} PARENT_SCOPE)
+set(NetCDF_C_INCLUDE_DIR ${NetCDF_C_INCLUDE_DIR} PARENT_SCOPE)
+set(NetCDF_C_LIBRARY ${NetCDF_C_LIBRARY} PARENT_SCOPE)
 
 endfunction(netcdf_c)
 
 
 function(netcdf_fortran)
 
-if(NOT CMAKE_Fortran_COMPILER)
-  return()
-endif()
-
 pkg_check_modules(pc_nc netcdf-fortran QUIET)
-if(NOT pc_nc_FOUND) # homebrew
+if(NOT pc_nc_FOUND)
+  # homebrew
   pkg_check_modules(pc_nc netcdf QUIET)
 endif()
 
@@ -60,28 +96,76 @@ if(NOT NetCDF_Fortran_LIBRARY)
 endif()
 
 set(NetCDF_Fortran_FOUND true PARENT_SCOPE)
-set(NetCDF_INCLUDE_DIR ${NetCDF_INCLUDE_DIR} ${NetCDF_Fortran_INCLUDE_DIR} PARENT_SCOPE)
-set(NetCDF_LIBRARY ${NetCDF_LIBRARY} ${NetCDF_Fortran_LIBRARY} PARENT_SCOPE)
+set(NetCDF_Fortran_INCLUDE_DIR ${NetCDF_Fortran_INCLUDE_DIR} PARENT_SCOPE)
+set(NetCDF_Fortran_LIBRARY ${NetCDF_Fortran_LIBRARY} PARENT_SCOPE)
 
 endfunction(netcdf_fortran)
 
 #============================================================
-find_package(PkgConfig)
-
-netcdf_c()
+# main program
+
+# 1. CMake-built NetCDF.
+find_package(netCDF CONFIG QUIET)
+if(netCDF_FOUND)
+  set(NetCDF_C_FOUND "${netCDF_FOUND}")
+  set(NetCDF_C_INCLUDE_DIR "${netCDF_INCLUDE_DIR}")
+  set(NetCDF_C_LIBRARY "${netCDF_LIBRARIES}")
+  set(NetCDF_VERSION "${NetCDFVersion}")
+
+  add_library(NetCDF::NetCDF_C INTERFACE IMPORTED)
+  if (TARGET "netCDF::netcdf")
+      # 4.7.3
+    set_target_properties(NetCDF::NetCDF_C PROPERTIES
+      INTERFACE_LINK_LIBRARIES "netCDF::netcdf")
+  elseif (TARGET "netcdf")
+    set_target_properties(NetCDF::NetCDF_C PROPERTIES
+      INTERFACE_LINK_LIBRARIES "netcdf")
+  else()
+    set_target_properties(NetCDF::NetCDF_C PROPERTIES
+      INTERFACE_LINK_LIBRARIES "${netCDF_LIBRARIES}")
+  endif()
+  set_target_properties(NetCDF::NetCDF_C PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${NetCDF_C_INCLUDE_DIR}")
+endif(netCDF_FOUND)
+
+# 2. manual search for Fortran (and C if needed) using optional pkg-config
+find_package(PkgConfig QUIET)
+if(NOT NetCDF_C_FOUND)
+  netcdf_c()
+endif()
+set(_ncdf_req ${NetCDF_C_LIBRARY})
 
-if(NetCDF_LIBRARY AND Fortran IN_LIST NetCDF_FIND_COMPONENTS)
+if(Fortran IN_LIST NetCDF_FIND_COMPONENTS)
   netcdf_fortran()
+  list(APPEND _ncdf_req ${NetCDF_Fortran_LIBRARY})
 endif()
-mark_as_advanced(NetCDF_LIBRARY NetCDF_INCLUDE_DIR)
 
+mark_as_advanced(NetCDF_C_INCLUDE_DIR NetCDF_Fortran_INCLUDE_DIR NetCDF_C_LIBRARY NetCDF_Fortran_LIBRARY)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(NetCDF
-  REQUIRED_VARS NetCDF_LIBRARY NetCDF_INCLUDE_DIR
+  REQUIRED_VARS _ncdf_req
   HANDLE_COMPONENTS)
 
 if(NetCDF_FOUND)
-  set(NetCDF_INCLUDE_DIRS ${NetCDF_INCLUDE_DIR})
-  set(NetCDF_LIBRARIES ${NetCDF_LIBRARY})
+  set(NetCDF_C_INCLUDE_DIRS ${NetCDF_C_INCLUDE_DIR})
+  set(NetCDF_C_LIBRARIES ${NetCDF_C_LIBRARY})
+
+  if(NetCDF_Fortran_FOUND)
+    set(NetCDF_Fortran_INCLUDE_DIRS ${NetCDF_Fortran_INCLUDE_DIR})
+    set(NetCDF_Fortran_LIBRARIES ${NetCDF_Fortran_LIBRARY})
+    if(NOT TARGET NetCDF::NetCDF_Fortran)
+      add_library(NetCDF::NetCDF_Fortran INTERFACE IMPORTED)
+      set_target_properties(NetCDF::NetCDF_Fortran PROPERTIES
+                            INTERFACE_LINK_LIBRARIES "${NetCDF_Fortran_LIBRARY}"
+                            INTERFACE_INCLUDE_DIRECTORIES "${NetCDF_Fortran_INCLUDE_DIR}")
+    endif()
+  endif()
+
+  if(NOT TARGET NetCDF::NetCDF_C)
+    add_library(NetCDF::NetCDF_C INTERFACE IMPORTED)
+    set_target_properties(NetCDF::NetCDF_C PROPERTIES
+                          INTERFACE_LINK_LIBRARIES "${NetCDF_C_LIBRARY}"
+                          INTERFACE_INCLUDE_DIRECTORIES "${NetCDF_C_INCLUDE_DIR}")
+  endif()
 endif()

cmake/netcdf.cmake

@@ -6,8 +6,9 @@ else()
   find_package(NetCDF COMPONENTS Fortran)
 endif()
 
-set(CMAKE_REQUIRED_INCLUDES ${NetCDF_INCLUDE_DIRS})
-set(CMAKE_REQUIRED_LIBRARIES ${NetCDF_LIBRARIES})
+set(CMAKE_REQUIRED_FLAGS)
+set(CMAKE_REQUIRED_INCLUDES)
+set(CMAKE_REQUIRED_LIBRARIES NetCDF::NetCDF_Fortran)
 
 include(CheckFortranSourceCompiles)
 check_fortran_source_compiles("use netcdf; end" NCDFOK SRC_EXT f90)

setup.cmake

@@ -7,19 +7,36 @@ set(_opts)
 
 # --- boilerplate follows
 message(STATUS "CMake ${CMAKE_VERSION}")
-if(CMAKE_VERSION VERSION_LESS 3.15)
-  message(FATAL_ERROR "Please update CMake >= 3.15")
+if(CMAKE_VERSION VERSION_LESS 3.14)
+  message(FATAL_ERROR "Please update CMake >= 3.14")
 endif()
 
 # site is OS name
 if(NOT DEFINED CTEST_SITE)
   set(CTEST_SITE ${CMAKE_SYSTEM_NAME})
 endif()
 
+# parallel test--use ctest_test(PARALLEL_LEVEL ${Ncpu} as setting CTEST_PARALLEL_LEVEL has no effect
+include(ProcessorCount)
+ProcessorCount(Ncpu)
+message(STATUS "${Ncpu} CPU cores detected")
+
 # test name is Fortran compiler in FC
 # Note: ctest scripts cannot read cache variables like CMAKE_Fortran_COMPILER
 if(DEFINED ENV{FC})
-  set(CTEST_BUILD_NAME $ENV{FC})
+  set(FC $ENV{FC})
+  set(CTEST_BUILD_NAME ${FC})
+
+  if(NOT DEFINED ENV{CC})
+    # use same compiler for C and Fortran, which CMake might not do itself
+    if(FC STREQUAL ifort)
+      if(WIN32)
+        set(ENV{CC} icl)
+      else()
+        set(ENV{CC} icc)
+      endif()
+    endif()
+  endif()
 endif()
 
 if(NOT DEFINED CTEST_BUILD_CONFIGURATION)
@@ -45,18 +62,41 @@ if(NOT DEFINED CTEST_CMAKE_GENERATOR)
   endif()
 endif()
 
+# -- build and test
 ctest_start("Experimental" ${CTEST_SOURCE_DIRECTORY} ${CTEST_BINARY_DIRECTORY})
-if(NOT EXISTS ${CTEST_BINARY_DIRECTORY}/CMakeCache.txt)
-  ctest_configure(BUILD ${CTEST_BINARY_DIRECTORY} SOURCE ${CTEST_SOURCE_DIRECTORY} OPTIONS "${_opts}")
+
+ctest_configure(
+  BUILD ${CTEST_BINARY_DIRECTORY}
+  SOURCE ${CTEST_SOURCE_DIRECTORY}
+  OPTIONS "${_opts}"
+  RETURN_VALUE return_code
+  CAPTURE_CMAKE_ERROR cmake_err)
+
+if(return_code EQUAL 0 AND cmake_err EQUAL 0)
+  ctest_build(
+    BUILD ${CTEST_BINARY_DIRECTORY}
+    CONFIGURATION ${CTEST_BUILD_CONFIGURATION}
+    RETURN_VALUE return_code
+    NUMBER_ERRORS Nerror
+    CAPTURE_CMAKE_ERROR cmake_err
+    )
+else()
+  message(STATUS "SKIP: ctest_build(): returncode: ${return_code}; CMake error code: ${cmake_err}")
 endif()
-ctest_build(BUILD ${CTEST_BINARY_DIRECTORY} CONFIGURATION ${CTEST_BUILD_CONFIGURATION})
-ctest_test(BUILD ${CTEST_BINARY_DIRECTORY})
 
-# using ctest_submit makes error code 0 even if test(s) failed!
-if(DEFINED ENV{CI})
-  set(CI $ENV{CI})
+if(return_code EQUAL 0 AND Nerror EQUAL 0 AND cmake_err EQUAL 0)
+  ctest_test(
+  BUILD ${CTEST_BINARY_DIRECTORY}
+  RETURN_VALUE return_code
+  CAPTURE_CMAKE_ERROR ctest_err
+  PARALLEL_LEVEL ${Ncpu}
+  )
+else()
+  message(STATUS "SKIP: ctest_test(): returncode: ${return_code}; CMake error code: ${cmake_err}")
 endif()
 
-if(NOT CI)
-  ctest_submit()
+ctest_submit()
+
+if(NOT (return_code EQUAL 0 AND Nerror EQUAL 0 AND cmake_err EQUAL 0 AND ctest_err EQUAL 0))
+  message(FATAL_ERROR "Build and test failed.")
 endif()