Import candidate for v1.6.0

Author: tkittel

CHANGELOG

@@ -1,3 +1,33 @@
+v1.6.0 2022-11-11
+      * Updated all MCPL CMake options to have named prefixed with MCPL_ and use
+        a more consistent naming scheme (mctools/mcpl#67). For example
+        BUILD_EXAMPLES is now instead MCPL_ENABLE_EXAMPLES. See the file
+        cmake/modules/mcpl_options.cmake for details.
+      * The default behaviour was until now to try to locate ZLIB and let the
+        configuration fail if not succesful, unless the old option
+        BUILD_WITHZLIB was explicitly set to OFF. The new option
+        MCPL_ENABLE_ZLIB is more flexible and supports one of several values:
+        IFAVAILABLE, FETCH, USEPREINSTALLED, ALWAYS, OFF, or NEVER.  The default
+        value of IFAVAILABLE will try to locate ZLIB, but will simply disable
+        ZLIB support if unsuccesful. The aliased options OFF and NEVER are
+        obviously simply disabling ZLIB support irrespective of presence on the
+        system. The option ALWAYS will attempt to find ZLIB on the system, and
+        if it fails it will instead fetch the zlib sources from the official
+        zlib location at github, and build the appropriate capabilities right
+        into the MCPL binaries. The option, USEPREINSTALLED is actually like the
+        old default behaviour: look for ZLIB on the system and fail if it it is
+        not available. Finally, the option FETCH will always fetch sources
+        online, ignoring any ZLIB already present on the system.
+      * Add (hidden) option MCPL_ENABLE_CPACK. If set, a few CPACK-related
+        variables will be set and an "include(CPack)" statement is triggered
+        just after the "project(..)" statement (mctools/mcpl#68).
+      * We now newer fiddle with CMAKE_BUILD_TYPE if a multi-cfg generator is
+        detected.
+      * Add (hidden) option MCPL_DISABLE_CXX.. If set, C++ support is not
+        requested from CMake, potentially removing an unnecessary
+        dependency. This option should obviously not be used with
+        MCPL_ENABLE_GEANT4=ON.
+
 v1.5.1 2022-11-07
       * Allow MCPL_PYPATH and MCPL_CMAKEDIR to be modified by users.
       * Avoid CMake warnings when setting MCPL_NOTOUCH_CMAKE_BUILD_TYPE.

CMakeLists.txt

@@ -42,35 +42,63 @@ cmake_minimum_required(VERSION 3.10...3.24)
 
 # Respect value of CMAKE_BUILD_TYPE if already defined, otherwise fall back to
 # Release. In any case, expose CMAKE_BUILD_TYPE as an explicit cache variable
-# (gives drop-down list in gui). This must come before the call to project(..).
+# (gives drop-down list in gui). This must come before the call to
+# project(..). We do not do this in case the generator is multi-cfg, and we also
+# provide the hidden MCPL_NOTOUCH_CMAKE_BUILD_TYPE option to not do it.
+#
 if( NOT MCPL_NOTOUCH_CMAKE_BUILD_TYPE )
-  if(DEFINED CMAKE_BUILD_TYPE)
-    set(_def_cbt ${CMAKE_BUILD_TYPE})
-  else()
-    set(_def_cbt Release)
+  get_property( gen_is_multicfg GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+  if ( NOT gen_is_multicfg )
+    if( DEFINED CMAKE_BUILD_TYPE )
+      set( _def_cbt ${CMAKE_BUILD_TYPE} )
+    else()
+      set( _def_cbt Release )
+    endif()
+    set( CMAKE_BUILD_TYPE ${_def_cbt}  CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo and MinSizeRel." )
+    set_property( CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS Debug Release RelWithDebInfo MinSizeRel None )
   endif()
-  set(CMAKE_BUILD_TYPE ${_def_cbt}  CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo and MinSizeRel." )
-  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS Debug Release RelWithDebInfo MinSizeRel None )
 endif()
 
 #Setup project:
-project(MCPL VERSION 1.5.1 LANGUAGES CXX C)
+
+set( _project_metadata LANGUAGES C )
+if ( NOT MCPL_DISABLE_CXX )
+  #Hidden option to not need a c++ compiler (in principle only needed for geant4 hooks).
+  list( APPEND _project_metadata CXX )
+endif()
+list( APPEND _project_metadata DESCRIPTION "Monte Carlo Particle Lists" )
+if( "${CMAKE_VERSION}" VERSION_GREATER_EQUAL "3.12.0" )
+  list( APPEND _project_metadata HOMEPAGE_URL "https://github.com/mctools/mcpl")
+endif()
+
+cmake_policy( SET CMP0048 NEW )#Not sure if this is really needed
+
+project( MCPL VERSION 1.6.0 ${_project_metadata} )
+
+unset( _project_metadata )
+
+if ( MCPL_ENABLE_CPACK )
+  set(CPACK_PACKAGE_CONTACT "mcpl-developers@cern.ch")
+  set(CPACK_NSIS_PACKAGE_NAME "${PROJECT_NAME} ${PROJECT_VERSION}")
+  set(CPACK_NSIS_DISPLAY_NAME "${PROJECT_NAME} ${PROJECT_VERSION}")
+  include(CPack)
+endif()
+
 if( NOT MCPL_NOTOUCH_CMAKE_BUILD_TYPE )
-  if ("${CMAKE_BUILD_TYPE}" STREQUAL "")
-    #This can happen if parent project called the project(..) function before
-    #doing the song and dance we did above.
-    set(CMAKE_BUILD_TYPE Release)
+  if ( NOT gen_is_multicfg )
+    if ("${CMAKE_BUILD_TYPE}" STREQUAL "")
+      #This can happen if parent project called the project(..) function before
+      #doing the song and dance we did above.
+      set( CMAKE_BUILD_TYPE Release )
+    endif()
   endif()
 endif()
 
-option( BUILD_EXAMPLES  "Whether to build examples." OFF )
-option( BUILD_WITHZLIB  "Whether to link with zlib if available." ON )
-option( BUILD_WITHSSW   "Whether to build the MCPL-SSW converters (for MCNP)." ON )
-option( BUILD_WITHPHITS "Whether to build the MCPL-PHITS converters." ON )
-option( BUILD_WITHG4    "Whether to build Geant4 plugins." OFF )
-option( BUILD_FAT       "Whether to also build the fat binaries." OFF )
-option( INSTALL_PY      "Whether to also install MCPL python files." ON )
-option( MODIFY_RPATH    "Whether to try to set RPATH in installed binaries (if disabled all special RPATH handling is skipped)." ON )
+# Set module path
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/modules")
+
+#Define options:
+include(mcpl_options)
 
 #Installation directories (try to follow standard conventions):
 include(GNUInstallDirs)
@@ -107,7 +135,9 @@ file(RELATIVE_PATH MCPL_relpath_CMAKEDIR2PYPATH   "${PROJECT_BINARY_DIR}/${MCPL_
 #Dummy interface target for common properties.
 add_library( mcpl_common INTERFACE )
 target_compile_features( mcpl_common INTERFACE c_std_99 )
-target_compile_features( mcpl_common INTERFACE cxx_std_11 )
+if ( NOT MCPL_DISABLE_CXX )
+  target_compile_features( mcpl_common INTERFACE cxx_std_11 )
+endif()
 
 #Properties for binaries / executables (can't transfer all properties via
 #INTERFACE targets, so we need this variable-based workaround):
@@ -153,6 +183,15 @@ set(SRCFAT "${PROJECT_SOURCE_DIR}/src_fat")
 set(SRCEX "${PROJECT_SOURCE_DIR}/examples")
 set(INSTDEST "RUNTIME;DESTINATION;${MCPL_BINDIR};LIBRARY;DESTINATION;${MCPL_LIBDIR};ARCHIVE;DESTINATION;${MCPL_LIBDIR}")
 
+#ZLib support:
+include( mcpl_zlib )
+if ( MCPL_ZLIB )
+  set( MCPL_ZLIB_ONOFF ON )
+else()
+  set( MCPL_ZLIB_ONOFF OFF )
+  message("zlib support not enabled - gzipped input files will NOT be directly readable by resulting binaries.")
+endif()
+
 #Make sure we link in math functions correctly (typically the linker needs libm on unix, but nothing on Windows).
 set(TMP_TESTLIBMSRC "#include <math.h>\nint main(int argc,char** argv) { (void)argv;double a=(exp)(argc+1.0); return (int)(a*0.1); }\n")
 set(TMP_TESTDIR ${PROJECT_BINARY_DIR}/test_libm)
@@ -173,6 +212,7 @@ endif()
 add_library( mcpl SHARED "${SRC}/mcpl/mcpl.c" )
 set(MCPL_LIBNAME "${CMAKE_SHARED_LIBRARY_PREFIX}mcpl${CMAKE_SHARED_LIBRARY_SUFFIX}")
 target_link_libraries( mcpl PRIVATE mcpl_common )
+add_zlib_dependency( mcpl -DMCPL_HASZLIB )
 
 target_include_directories(mcpl
  PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/mcpl>
@@ -181,8 +221,9 @@ target_include_directories(mcpl
 if (MATH_NEEDS_LIBM)
   target_link_libraries( mcpl PRIVATE m )
 endif()
+
 add_executable(mcpltool "${SRC}/mcpl/mcpltool_app.c")
-target_link_libraries( mcpltool mcpl mcpl_common )
+target_link_libraries( mcpltool PRIVATE mcpl mcpl_common )
 if (binaryprops)
   set_target_properties(mcpltool PROPERTIES ${binaryprops})
 endif()
@@ -204,17 +245,18 @@ install( FILES "${PROJECT_BINARY_DIR}/MCPLConfigVersion.cmake" "${PROJECT_BINARY
 
 install(FILES "${SRC}/mcpl/mcpl.h" DESTINATION ${MCPL_INCDIR})
 
-if (BUILD_WITHSSW)
+if ( MCPL_ENABLE_SSW )
   add_library(sswmcpl SHARED "${SRC}/mcnpssw/sswmcpl.c" "${SRC}/mcnpssw/sswread.c")
-  target_include_directories(sswmcpl PUBLIC "${SRC}/mcnpssw")
-  target_link_libraries(sswmcpl mcpl mcpl_common)
+  target_include_directories( sswmcpl PUBLIC "${SRC}/mcnpssw")
+  target_link_libraries( sswmcpl PRIVATE mcpl mcpl_common)
   if (MATH_NEEDS_LIBM)
-    target_link_libraries(sswmcpl m)
+    target_link_libraries(sswmcpl PRIVATE m)
   endif()
+  add_zlib_dependency( sswmcpl -DDSSWREAD_HASZLIB )
   add_executable(ssw2mcpl "${SRC}/mcnpssw/ssw2mcpl_app.c")
-  target_link_libraries(ssw2mcpl sswmcpl)
+  target_link_libraries(ssw2mcpl PRIVATE sswmcpl)
   add_executable(mcpl2ssw "${SRC}/mcnpssw/mcpl2ssw_app.c")
-  target_link_libraries(mcpl2ssw sswmcpl)
+  target_link_libraries(mcpl2ssw PRIVATE sswmcpl)
   if (binaryprops)
     set_target_properties(sswmcpl PROPERTIES ${binaryprops})
     set_target_properties(ssw2mcpl PROPERTIES ${binaryprops})
@@ -223,14 +265,15 @@ if (BUILD_WITHSSW)
   install(TARGETS mcpl2ssw ssw2mcpl sswmcpl ${INSTDEST})
 endif()
 
-if (BUILD_WITHPHITS)
+if ( MCPL_ENABLE_PHITS )
   add_library(phitsmcpl SHARED "${SRC}/phits/phitsmcpl.c" "${SRC}/phits/phitsread.c")
-  target_include_directories(phitsmcpl PUBLIC "${SRC}/phits")
-  target_link_libraries(phitsmcpl mcpl mcpl_common)
+  target_include_directories( phitsmcpl PUBLIC "${SRC}/phits")
+  target_link_libraries( phitsmcpl PRIVATE mcpl mcpl_common )
+  add_zlib_dependency( phitsmcpl -DDPHITSREAD_HASZLIB )
   add_executable(phits2mcpl "${SRC}/phits/phits2mcpl_app.c")
-  target_link_libraries(phits2mcpl phitsmcpl)
+  target_link_libraries( phits2mcpl PRIVATE phitsmcpl )
   add_executable(mcpl2phits "${SRC}/phits/mcpl2phits_app.c")
-  target_link_libraries(mcpl2phits phitsmcpl)
+  target_link_libraries( mcpl2phits PRIVATE phitsmcpl )
   install(TARGETS mcpl2phits phits2mcpl phitsmcpl ${INSTDEST})
   if (binaryprops)
     set_target_properties(phitsmcpl PROPERTIES ${binaryprops})
@@ -239,24 +282,24 @@ if (BUILD_WITHPHITS)
   endif()
 endif()
 
-if (INSTALL_PY)
+if ( MCPL_ENABLE_PYTHON )
   install(FILES "${SRC}/python/mcpl.py" DESTINATION ${MCPL_PYPATH})
   install(PROGRAMS "${SRC}/python/pymcpltool" DESTINATION ${MCPL_BINDIR})
-  if (BUILD_EXAMPLES)
+  if ( MCPL_ENABLE_EXAMPLES )
     install(PROGRAMS "${SRCEX}/pyexample_readmcpl" DESTINATION ${MCPL_BINDIR} RENAME mcplexample_pyread)
   endif()
-  if (BUILD_FAT)
+  if ( MCPL_ENABLE_FATBINARIES )
     install(PROGRAMS "${SRCFAT}/pymcpltool" DESTINATION ${MCPL_BINDIR} RENAME pymcpltool_fat)
   endif()
 endif()
 
-if (BUILD_EXAMPLES)
-  add_executable(mcplexample_read "${SRCEX}/rawexample_readmcpl.c")
-  target_link_libraries(mcplexample_read mcpl mcpl_common)
+if ( MCPL_ENABLE_EXAMPLES )
+  add_executable( mcplexample_read "${SRCEX}/rawexample_readmcpl.c")
+  target_link_libraries( mcplexample_read PRIVATE mcpl mcpl_common)
   add_executable(mcplexample_write "${SRCEX}/rawexample_writemcpl.c")
-  target_link_libraries(mcplexample_write mcpl mcpl_common)
+  target_link_libraries(mcplexample_write PRIVATE mcpl mcpl_common)
   add_executable(mcplexample_filter "${SRCEX}/rawexample_filtermcpl.c")
-  target_link_libraries(mcplexample_filter mcpl mcpl_common)
+  target_link_libraries(mcplexample_filter PRIVATE mcpl mcpl_common)
   install(TARGETS mcplexample_read mcplexample_write mcplexample_filter ${INSTDEST})
   if (binaryprops)
     set_target_properties(mcplexample_read PROPERTIES ${binaryprops})
@@ -265,66 +308,42 @@ if (BUILD_EXAMPLES)
   endif()
 endif()
 
-if (BUILD_FAT)
+if ( MCPL_ENABLE_FATBINARIES )
   add_library(mcpl_fat SHARED "${SRCFAT}/mcpl_fat.c")
   target_include_directories(mcpl_fat PUBLIC "${SRC}/mcpl")
   add_executable(mcpltool_fat "${SRCFAT}/mcpltool_app_fat.c")
   install(TARGETS mcpl_fat mcpltool_fat ${INSTDEST})
   if (MATH_NEEDS_LIBM)
-    target_link_libraries( mcpl_fat m mcpl_common )
-    target_link_libraries( mcpltool_fat m mcpl_common )
+    target_link_libraries( mcpl_fat PRIVATE m mcpl_common )
+    target_link_libraries( mcpltool_fat PRIVATE m mcpl_common )
   endif()
-  if (BUILD_WITHSSW)
+  if ( MCPL_ENABLE_SSW )
     add_executable(ssw2mcpl_fat "${SRCFAT}/ssw2mcpl_app_fat.c")
     add_executable(mcpl2ssw_fat "${SRCFAT}/mcpl2ssw_app_fat.c")
     if (MATH_NEEDS_LIBM)
-      target_link_libraries( ssw2mcpl_fat m mcpl_common )
-      target_link_libraries( mcpl2ssw_fat m mcpl_common )
+      target_link_libraries( ssw2mcpl_fat PRIVATE m mcpl_common )
+      target_link_libraries( mcpl2ssw_fat PRIVATE m mcpl_common )
     endif()
     install(TARGETS ssw2mcpl_fat mcpl2ssw_fat ${INSTDEST})
   endif()
-  if (BUILD_WITHPHITS)
+  if ( MCPL_ENABLE_PHITS )
     add_executable(phits2mcpl_fat "${SRCFAT}/phits2mcpl_app_fat.c")
     add_executable(mcpl2phits_fat "${SRCFAT}/mcpl2phits_app_fat.c")
     if (MATH_NEEDS_LIBM)
-      target_link_libraries( phits2mcpl_fat m mcpl_common )
-      target_link_libraries( mcpl2phits_fat m mcpl_common )
+      target_link_libraries( phits2mcpl_fat PRIVATE m mcpl_common )
+      target_link_libraries( mcpl2phits_fat PRIVATE m mcpl_common )
     endif()
     install(TARGETS phits2mcpl_fat mcpl2phits_fat ${INSTDEST})
   endif()
 endif()
 
-if (BUILD_WITHZLIB)
-  find_package(ZLIB)
-  if(NOT ZLIB_FOUND)
-    message(FATAL_ERROR "BUILD_WITHZLIB set to ON but failed to enable zlib support.")
-  endif()
-else()
-  set(ZLIB_FOUND NO)
-endif()
-
-if(ZLIB_FOUND)
-  target_compile_definitions(mcpl PRIVATE "-DMCPL_HASZLIB")
-  target_include_directories(mcpl SYSTEM PRIVATE ${ZLIB_INCLUDE_DIRS})
-  target_link_libraries(mcpl PRIVATE ${ZLIB_LIBRARIES})
-  if (BUILD_WITHSSW)
-    target_compile_definitions(sswmcpl PRIVATE "-DSSWREAD_HASZLIB")
-    target_include_directories(sswmcpl SYSTEM PRIVATE ${ZLIB_INCLUDE_DIRS})
-    target_link_libraries(sswmcpl ${ZLIB_LIBRARIES})
+if ( MCPL_ENABLE_GEANT4 )
+  if ( MCPL_DISABLE_CXX )
+    message(FATAL_ERROR "Do not use MCPL_ENABLE_GEANT4 with MCPL_DISABLE_CXX.")
   endif()
-  if (BUILD_WITHPHITS)
-    target_compile_definitions(phitsmcpl PRIVATE "-DPHITSREAD_HASZLIB")
-    target_include_directories(phitsmcpl SYSTEM PRIVATE ${ZLIB_INCLUDE_DIRS})
-    target_link_libraries(phitsmcpl ${ZLIB_LIBRARIES})
-  endif()
-else()
-  message("zlib support not enabled - gzipped input files will NOT be directly readable by resulting binaries.")
-endif()
-
-if (BUILD_WITHG4)
-  find_package(Geant4)
-  if(NOT Geant4_FOUND)
-    message(FATAL_ERROR "BUILD_WITHG4 set to ON but failed to enable Geant4 support.")
+  find_package( Geant4 )
+  if( NOT Geant4_FOUND )
+    message(FATAL_ERROR "MCPL_ENABLE_GEANT4 set to ON but failed to enable Geant4 support.")
   endif()
 else()
   set(Geant4_FOUND NO)
@@ -348,11 +367,11 @@ if (Geant4_FOUND)
   add_library(MCPL::g4mcpl ALIAS g4mcpl)#always alias namespaces locally
 
   install(FILES "${SRC}/geant4/G4MCPLGenerator.hh" "${SRC}/geant4/G4MCPLWriter.hh" DESTINATION ${MCPL_INCDIR})
-  if (BUILD_EXAMPLES)
+  if ( MCPL_ENABLE_EXAMPLES )
     add_executable(mcplexample_geant4read "${SRCEX}/g4example_readmcpl.cc")
-    target_link_libraries(mcplexample_geant4read g4mcpl mcpl_common)
+    target_link_libraries(mcplexample_geant4read PRIVATE g4mcpl mcpl_common)
     add_executable(mcplexample_geant4write "${SRCEX}/g4example_writemcpl.cc")
-    target_link_libraries(mcplexample_geant4write g4mcpl mcpl_common)
+    target_link_libraries(mcplexample_geant4write PRIVATE g4mcpl mcpl_common)
     if (binaryprops)
       set_target_properties(mcplexample_geant4read PROPERTIES ${binaryprops})
       set_target_properties(mcplexample_geant4write PROPERTIES ${binaryprops})

INSTALL

@@ -33,22 +33,16 @@ is a quick recipe (using an in-source build for simplicity):
 
    This will fail if your system is missing basic build tools, such as a C/C++
    capable compiler. In addition to generic CMake options, you can fine-tune
-   what will be build by adding one or more of the following flags to the
-   command:
-
-   * -DBUILD_WITHZLIB=OFF  [whether to link with zlib if available, default is ON]
-   * -DBUILD_EXAMPLES=ON   [whether to build examples, default is OFF]
-   * -DBUILD_FAT=ON        [whether to build "fat" binaries, default is OFF]
-   * -DBUILD_WITHG4=ON     [whether to build G4 hooks, default is OFF]
-   * -DBUILD_WITHSSW=OFF   [whether to build SSW hooks, default is ON]
-   * -DBUILD_WITHPHITS=OFF [whether to build PHITS hooks, default is ON]
-   * -DINSTALL_PY=OFF      [whether to install python files, default is ON]
-   * -DMODIFY_RPATH=OFF    [whether to provide special rpath treatment for binaries, default is ON]
-
-3. Perform the build and install in one step with (assuming you are on a
-   platform where CMake generates makefiles):
-
-   make install
+   what will be build by adding flags to the command. For instance
+   -DMCPL_ENABLE_EXAMPLES=ON would cause the included examples to be built, or
+   -DMCPL_ENABLE_GEANT4 would enable the Geant4 hooks. For a full list of
+   available high-level options, one can simply peek into the file
+   cmake/modules/mcpl_options.cmake, although depending on your CMake client the
+   options might also be available there.
+
+3. Next, perform the build and install in one step with:
+
+   cmake --build . --target install --config Release
 
 4. Now you can use the installed files from /path/to/mcplinstall. For instance,
    you can invoke the mcpltool with (showing usage instructions):

VERSION

@@ -1 +1 @@
-1.5.1
+1.6.0