cmake_minimum_required(VERSION 2.8.11) include(CheckIncludeFileCXX) if (DEFINED COOLPROP_INSTALL_PREFIX) #set(COOLPROP_INSTALL_PREFIX ${CMAKE_CURRENT_SOURCE_DIR}/install_root) message(STATUS "COOLPROP_INSTALL_PREFIX=${COOLPROP_INSTALL_PREFIX}") else() set(COOLPROP_INSTALL_PREFIX ${CMAKE_CURRENT_SOURCE_DIR}/install_root) message(STATUS "COOLPROP_INSTALL_PREFIX=${COOLPROP_INSTALL_PREFIX}") endif() set(CMAKE_INSTALL_PREFIX ${COOLPROP_INSTALL_PREFIX} CACHE PATH "default install path" FORCE) ####################################### # BUILD OPTIONS # #-------------------------------------# # These options are available to be # # modified in the build process. # # packages may want to modify these # # to suit, or just leave as defaults. # ####################################### option (COOLPROP_STATIC_LIBRARY "Build CoolProp as a static library (.lib, .a)" OFF) option (COOLPROP_SHARED_LIBRARY "Build CoolProp as a shared library (.dll, .so)" OFF) option (COOLPROP_OBJECT_LIBRARY "Build CoolProp objects, but do not link them (.obj, .o)" OFF) option (COOLPROP_EES_MODULE "Build the EES module" OFF) option (COOLPROP_WINDOWS_PACKAGE "Build the Windows installer" OFF) option (BUILD_TESTING "Enable testing for this given builder" OFF) option (FORCE_BITNESS_32 "Force a 32bit build regardless of the host" OFF) option (FORCE_BITNESS_64 "Force a 64bit build regardless of the host" OFF) option (FORCE_BITNESS_NATIVE "Force a native bitness build regardless of the host" OFF) option (COOLPROP_RELEASE "Optimize the builds with the release specs" OFF) option (COOLPROP_DEBUG "Make a debug build" OFF) option (COOLPROP_SMATH_WORK_INPLACE "Build SMath wrapper in source directory" OFF) option (COOLPROP_MSVC_STATIC "Statically link Microsoft Standard library removes dependency on MSVCRXXX.dll." OFF) option (COOLPROP_MSVC_DYNAMIC "Dynamically link Microsoft Standard library to integrate with other builds." OFF) option (COOLPROP_MSVC_DEBUG "Link the debug version of Microsoft Standard library to the debug builds." ON) option (COOLPROP_NO_EXAMPLES "Do not generate example code, does only apply to some wrappers." OFF) #option (DARWIN_USE_LIBCPP # "On Darwin systems, compile and link with -std=libc++ instead of the default -std=libstdc++" # ON) # see # https://stackoverflow.com/questions/52509602/cant-compile-c-program-on-a-mac-after-upgrade-to-mojave # https://support.enthought.com/hc/en-us/articles/204469410-OS-X-GCC-Clang-and-Cython-in-10-9-Mavericks # https://github.com/pandas-dev/pandas/pull/24274/files # https://github.com/explosion/thinc/pull/84/files # https://github.com/jlfaucher/builder/commit/d144d3a695949f90c5e2acff4dfd94fdcf8dcdfa # https://github.com/CoolProp/CoolProp/issues/1778 # https://gitlab.kitware.com/cmake/cmake/issues/18396 if (DEFINED DARWIN_USE_LIBCPP) if(DARWIN_USE_LIBCPP) set(CMAKE_OSX_DEPLOYMENT_TARGET "10.9" CACHE STRING "Minimum OS X deployment version") set(OSX_COMPILE_FLAGS "${OSX_COMPILE_FLAGS} -stdlib=libc++") set(OSX_COMPILE_FLAGS "${OSX_COMPILE_FLAGS} -mmacosx-version-min=10.9") set(OSX_COMPILE_FLAGS "${OSX_COMPILE_FLAGS} -std=c++11") set(OSX_LINK_FLAGS "${OSX_LINK_FLAGS} -lc++") set(OSX_LINK_FLAGS "${OSX_LINK_FLAGS} -nodefaultlibs") set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") else(DARWIN_USE_LIBCPP) set(CMAKE_OSX_DEPLOYMENT_TARGET "10.5" CACHE STRING "Minimum OS X deployment version") # Default is 10.7 set(OSX_COMPILE_FLAGS "${OSX_COMPILE_FLAGS} -stdlib=libstdc++") set(OSX_COMPILE_FLAGS "${OSX_COMPILE_FLAGS} -mmacosx-version-min=10.5") set(OSX_LINK_FLAGS "${OSX_LINK_FLAGS} -lstdc++") set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libstdc++") endif(DARWIN_USE_LIBCPP) message(STATUS "DARWIN_USE_LIBCPP was set added some flags:") message(STATUS " OSX_COMPILE_FLAGS: ${OSX_COMPILE_FLAGS}") message(STATUS " OSX_LINK_FLAGS: ${OSX_LINK_FLAGS}") else (DEFINED DARWIN_USE_LIBCPP) if ("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin") message(STATUS "OSX build detected:") message(STATUS " You might want to pass the -DDARWIN_USE_LIBCPP=ON/OFF parameter") message(STATUS " to enable or disable different C++ standard libraries.") message(STATUS " You can also specify the environment variable MACOSX_DEPLOYMENT_TARGET=10.9 to force clang builds.") endif ("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin") endif (DEFINED DARWIN_USE_LIBCPP) #if("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin") # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}${OSX_COMPILE_FLAGS}") # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}${OSX_COMPILE_FLAGS}") #endif() # Alternatively you could use # set_target_properties(TARGET_NAME PROPERTIES APPEND_STRING PROPERTY COMPILE_FLAGS "-mmacosx-version-min=10.5") # set_target_properties(TARGET_NAME PROPERTIES APPEND_STRING PROPERTY LINK_FLAGS "-mmacosx-version-min=10.5") ####################################### # PROJECT INFORMATION # #-------------------------------------# # This CMakeLists.txt file is for the # # CoolProp thermodynamic library # # written by Ian Bell. The following # # section contains project and # # version information. # ####################################### # Project name set(project_name "CoolProp") set(app_name ${project_name}) project(${project_name}) # Project version set (COOLPROP_VERSION_MAJOR 6) set (COOLPROP_VERSION_MINOR 4) set (COOLPROP_VERSION_PATCH 2) set (COOLPROP_VERSION_REVISION dev) set (COOLPROP_VERSION "${COOLPROP_VERSION_MAJOR}.${COOLPROP_VERSION_MINOR}.${COOLPROP_VERSION_PATCH}${COOLPROP_VERSION_REVISION}") message(STATUS "CoolProp version: ${COOLPROP_VERSION}") string ( TIMESTAMP COOLPROP_YEAR 2010-%Y ) #set ( COOLPROP_YEAR "2010-2016" ) set ( COOLPROP_PUBLISHER "The CoolProp developers") # Add definitions to silence warnings in MSVC2017 related to shared ptr code. #if (MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS_EQUAL 1919) # OR MSVC_TOOLSET_VERSION EQUAL 141) # This requuires CMake >= 3.7 # add_definitions(-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING) #endif (MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS_EQUAL 1919) if (MSVC AND NOT(MSVC_VERSION LESS 1910) AND NOT(MSVC_VERSION GREATER 1919)) add_definitions(-D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING) endif () IF ( COOLPROP_RELEASE AND COOLPROP_DEBUG ) MESSAGE(FATAL_ERROR "You can only make a release OR and debug build.") ENDIF() IF (COOLPROP_RELEASE) SET(CMAKE_BUILD_TYPE Release) ELSEIF (COOLPROP_DEBUG) SET(CMAKE_BUILD_TYPE Debug) #ELSEIF ("${CMAKE_BUILD_TYPE}" STREQUAL "") # IF("${COOLPROP_VERSION_REVISION}" STREQUAL "dev") # SET(CMAKE_BUILD_TYPE Debug) # ELSE () # SET(CMAKE_BUILD_TYPE Release) # ENDIF() ENDIF () IF (COOLPROP_MSVC_STATIC) SET(COOLPROP_MSVC_REL "/MT") IF (COOLPROP_MSVC_DEBUG) SET(COOLPROP_MSVC_DBG "/MTd") ELSE() SET(COOLPROP_MSVC_DBG "/MT") ENDIF() ELSEIF (COOLPROP_MSVC_DYNAMIC) SET(COOLPROP_MSVC_REL "/MD") IF (COOLPROP_MSVC_DEBUG) SET(COOLPROP_MSVC_DBG "/MDd") ELSE() SET(COOLPROP_MSVC_DBG "/MD") ENDIF() ELSE (COOLPROP_MSVC_DYNAMIC) SET(COOLPROP_MSVC_REL "IGNORE") SET(COOLPROP_MSVC_DBG "IGNORE") ENDIF() SET(COOLPROP_MSVC_ALL "/MTd" "/MT" "/MDd" "/MD") # order matters "/MXd" before "/MX" ####################################### # FIND ALL SOURCES # #-------------------------------------# # The project is organised with # # split includes and source folders # # this makes it easier for developers # # to quickly find relevant includes. # # This section finds all sources, # # headers and corresponding dirs. # ####################################### # These backends will be compiled in set(COOLPROP_ENABLED_BACKENDS Cubics IF97 Helmholtz REFPROP Incompressible Tabular PCSAFT) # Get everything in the src/ directory (always), but not recursive file(GLOB APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp") # For each enabled backend, grab its files foreach (backend ${COOLPROP_ENABLED_BACKENDS}) file(GLOB_RECURSE BACKEND_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/Backends/${backend}/*.cpp") list(APPEND APP_SOURCES ${BACKEND_SOURCES}) endforeach() ## You can exclude this file, in case you want to run your own tests or use Catch list(REMOVE_ITEM APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/Tests/Tests.cpp") list(REMOVE_ITEM APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/Tests/CoolProp-Tests.cpp") ## This file is only needed for the library, normal builds do not need it. list(REMOVE_ITEM APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolPropLib.cpp") set (APP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}") list (APPEND APP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/externals/Eigen") list (APPEND APP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/externals/msgpack-c/include") list (APPEND APP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/externals/fmtlib/include") list (APPEND APP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/externals/fmtlib") # should be deprecated list (APPEND APP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/include") list (APPEND APP_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/src") include_directories(${APP_INCLUDE_DIRS}) set(SWIG_DEPENDENCIES ${CMAKE_CURRENT_SOURCE_DIR}/include/DataStructures.h ${CMAKE_CURRENT_SOURCE_DIR}/include/CoolProp.h ${CMAKE_CURRENT_SOURCE_DIR}/include/AbstractState.h ${CMAKE_CURRENT_SOURCE_DIR}/include/Configuration.h ${CMAKE_CURRENT_SOURCE_DIR}/include/PhaseEnvelope.h) set(COOLPROP_APP_SOURCES ${APP_SOURCES} CACHE LIST "List of CPP sources needed for CoolProp") set(COOLPROP_INCLUDE_DIRECTORIES ${APP_INCLUDE_DIRS} CACHE LIST "List of include directories needed for CoolProp") ####################################### # REQUIRED MODULES # #-------------------------------------# # CoolProp requires some standard OS # # features, these include: # # DL (CMAKE_DL_LIBS) for REFPROP # ####################################### set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/dev/cmake/Modules/") set(Python_ADDITIONAL_VERSIONS 2.7 2.6 2.5 2.4) find_package (PythonInterp 2.7) if (NOT PYTHON_EXECUTABLE) MESSAGE(STATUS "Looking for Python") find_package (Python COMPONENTS Interpreter) endif() if (NOT PYTHON_EXECUTABLE) MESSAGE(STATUS "Looking for Python2") find_package (Python2 COMPONENTS Interpreter) if(Python2_Interpreter_FOUND) set(PYTHON_EXECUTABLE ${Python2_EXECUTABLE}) endif() endif() if (NOT PYTHON_EXECUTABLE) MESSAGE(STATUS "Looking for Python3") find_package (Python3 COMPONENTS Interpreter) if(Python3_Interpreter_FOUND) set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE}) endif() endif() if (NOT PYTHON_EXECUTABLE) MESSAGE(WARNING "Could not find Python, be prepared for errors.") endif() if(CMAKE_DL_LIBS) find_package (${CMAKE_DL_LIBS} REQUIRED) endif() include(FlagFunctions) # Is found since it is in the module path. macro(modify_msvc_flag_release flag_new) # Use a macro to avoid a new scope foreach (flag_old IN LISTS COOLPROP_MSVC_ALL) remove_compiler_flag_release("${flag_old} ") # add a space remove_compiler_flag_release(" ${flag_old}") # add a space endforeach() add_compiler_flag_release("${flag_new}") endmacro() macro(modify_msvc_flag_debug flag_new) # Use a macro to avoid a new scope foreach (flag_old IN LISTS COOLPROP_MSVC_ALL) remove_compiler_flag_debug("${flag_old} ") # add a space remove_compiler_flag_debug(" ${flag_old}") # add a space endforeach() add_compiler_flag_debug("${flag_new}") endmacro() macro(modify_msvc_flags flag_default) # Use a macro to avoid a new scope if(NOT "${COOLPROP_MSVC_REL}" STREQUAL "IGNORE") modify_msvc_flag_release("${COOLPROP_MSVC_REL}") else() modify_msvc_flag_release("${flag_default}") endif() if(NOT "${COOLPROP_MSVC_DBG}" STREQUAL "IGNORE") modify_msvc_flag_debug("${COOLPROP_MSVC_DBG}") else() modify_msvc_flag_debug("${flag_default}d") endif() endmacro() #if(MSVC) # add_compiler_flag_release("/EHsc") # add_compiler_flag_debug("/EHsc") #endif() ####################################### # BITNESS # #-------------------------------------# # Calculate if 32 or 64 # ####################################### if(WIN32) if (CMAKE_CL_64) SET(BITNESS "64") else() SET(BITNESS "32") endif() else() if (CMAKE_SIZEOF_VOID_P MATCHES "8") SET(BITNESS "64") else() SET(BITNESS "32") endif() endif() IF(MSVC AND (FORCE_BITNESS_32 OR FORCE_BITNESS_64)) MESSAGE(STATUS "You cannot force a certain bitness for Visual Studio, use the generator settings for this purpose." ) MESSAGE(STATUS "Pass '-G \"Visual Studio 10 2010 Win64\"' to CMake to make a 64bit binary using VS2010." ) MESSAGE(STATUS "Pass '-G \"Visual Studio 10 2010\"' to CMake to make a 32bit binary using VS2010." ) MESSAGE(STATUS "Pass '-G \"Visual Studio 9 2008 Win64\"' to CMake to make a 64bit binary using VS2008." ) MESSAGE(STATUS "Pass '-G \"Visual Studio 9 2008\"' to CMake to make a 32bit binary using VS2008." ) MESSAGE(FATAL_ERROR "Fix that and try again...") ENDIF() IF(FORCE_BITNESS_32) SET(BITNESS "32") ELSEIF(FORCE_BITNESS_64) SET(BITNESS "64") ELSEIF(FORCE_BITNESS_NATIVE) SET(BITNESS "NATIVE") ENDIF() ####################################### # SHARED POINTER # #-------------------------------------# # In this section we define the # # flags needed to use shared_ptr # # reliably # ####################################### include("${CMAKE_CURRENT_SOURCE_DIR}/dev/cmake/Modules/FindSharedPtr.cmake") FIND_SHARED_PTR() if(NOT SHARED_PTR_FOUND) message(FATAL_ERROR "Must be able to find shared_ptr") else() if (SHARED_PTR_TR1_MEMORY_HEADER) add_definitions("-DSHARED_PTR_TR1_MEMORY_HEADER") endif() if (SHARED_PTR_TR1_NAMESPACE) add_definitions("-DSHARED_PTR_TR1_NAMESPACE") endif() endif() ####################################### # MAKE ARTEFACTS # #-------------------------------------# # In this section we define the # # artefacts (exes, libs) that will be # # made for CoolProp, these include # # customisation from earlier options. # ####################################### ### FLUIDS, MIXTURES JSON ### add_custom_target(generate_headers COMMAND "${PYTHON_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/dev/generate_headers.py") if (NOT COOLPROP_NO_EXAMPLES) add_custom_target(generate_examples COMMAND "${PYTHON_EXECUTABLE}" example_generator.py Python "${CMAKE_CURRENT_BINARY_DIR}/Example.py" COMMAND "${PYTHON_EXECUTABLE}" example_generator.py Octave "${CMAKE_CURRENT_BINARY_DIR}/Example.m" COMMAND "${PYTHON_EXECUTABLE}" example_generator.py R "${CMAKE_CURRENT_BINARY_DIR}/Example.R" #COMMAND "${PYTHON_EXECUTABLE}" example_generator.py MATLAB "${CMAKE_CURRENT_BINARY_DIR}/Example.m" COMMAND "${PYTHON_EXECUTABLE}" example_generator.py Java "${CMAKE_CURRENT_BINARY_DIR}/Example.java" COMMAND "${PYTHON_EXECUTABLE}" example_generator.py Csharp "${CMAKE_CURRENT_BINARY_DIR}/Example.cs" WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/dev/scripts/examples") else() add_custom_target(generate_examples COMMAND echo "Example generation has been disabled with the COOLPROP_NO_EXAMPLES option.") endif() ### Library options ### # We already know the bitness from the earlier # settings. Let us rely on that and only handle # calling conventions and shared/static issues. option (COOLPROP_STDCALL_LIBRARY "Build CoolProp as a 32bit shared library with stdcall" OFF) option (COOLPROP_CDECL_LIBRARY "Build CoolProp as a 32bit shared library with cdecl" OFF) option (COOLPROP_EXTERNC_LIBRARY "Overwrite the export settings to force extern C" OFF) SET (COOLPROP_LIBRARY_SOURCE "src/CoolPropLib.cpp" CACHE STRING "The file that contains the exported functions") SET (COOLPROP_LIBRARY_HEADER "include/CoolPropLib.h" CACHE STRING "The file that contains the export header") SET (COOLPROP_LIBRARY_NAME "${app_name}" CACHE STRING "The name of the generated library") SET (COOLPROP_LIBRARY_EXPORTS "" CACHE STRING "The file that contains the export alias list") # Rule out cases that do not make sense IF ("${BITNESS}" STREQUAL "32") IF (COOLPROP_CDECL_LIBRARY) SET(CONVENTION "__cdecl") ELSEIF (COOLPROP_STDCALL_LIBRARY) SET(CONVENTION "__stdcall") ELSE() SET(CONVENTION "") ENDIF() ELSEIF ("${BITNESS}" STREQUAL "64") IF (COOLPROP_CDECL_LIBRARY) MESSAGE(WARNING "You cannot use cdecl conventions in a 64-bit library.") ELSEIF (COOLPROP_STDCALL_LIBRARY) MESSAGE(WARNING "You cannot use stdcall conventions in a 64-bit library.") ENDIF() SET(CONVENTION "") ELSEIF ("${BITNESS}" STREQUAL "NATIVE") SET(CONVENTION "") ELSE() MESSAGE(FATAL_ERROR "Bitness is not defined. Set it and run cmake again.") ENDIF() IF ( ( COOLPROP_OBJECT_LIBRARY AND COOLPROP_STATIC_LIBRARY ) OR ( COOLPROP_OBJECT_LIBRARY AND COOLPROP_SHARED_LIBRARY ) OR ( COOLPROP_STATIC_LIBRARY AND COOLPROP_SHARED_LIBRARY ) ) MESSAGE(FATAL_ERROR "You can only use one of the library switches!") ENDIF() IF ( COOLPROP_OBJECT_LIBRARY OR COOLPROP_STATIC_LIBRARY OR COOLPROP_SHARED_LIBRARY ) # Project name SET (LIB_NAME ${COOLPROP_LIBRARY_NAME}) # Object, static or shared? IF ( COOLPROP_OBJECT_LIBRARY ) ADD_LIBRARY(${LIB_NAME} OBJECT ${APP_SOURCES}) SET(COOLPROP_LIBRARY_SOURCE "") SET(COOLPROP_LIBRARY_HEADER "") ELSEIF (COOLPROP_STATIC_LIBRARY) LIST(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/${COOLPROP_LIBRARY_SOURCE}") ADD_LIBRARY(${LIB_NAME} STATIC ${APP_SOURCES} ${COOLPROP_LIBRARY_EXPORTS}) IF (MSVC) # Add postfix for debugging SET_PROPERTY(TARGET ${LIB_NAME} PROPERTY DEBUG_POSTFIX d) SET_PROPERTY(TARGET ${LIB_NAME} PROPERTY RELEASE_POSTFIX ) modify_msvc_flags("/MD") # Note that the default is not used if ${COOLPROP_MSVC_REL} or ${COOLPROP_MSVC_DBG} is set ENDIF (MSVC) INSTALL(TARGETS ${LIB_NAME} DESTINATION static_library/${CMAKE_SYSTEM_NAME}/${BITNESS}bit_${CMAKE_CXX_COMPILER_ID}_${CMAKE_CXX_COMPILER_VERSION} ) INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${COOLPROP_LIBRARY_HEADER} DESTINATION static_library) ELSEIF (COOLPROP_SHARED_LIBRARY) LIST(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/${COOLPROP_LIBRARY_SOURCE}") ADD_LIBRARY(${LIB_NAME} SHARED ${APP_SOURCES} ${COOLPROP_LIBRARY_EXPORTS}) INSTALL(TARGETS ${LIB_NAME} DESTINATION shared_library/${CMAKE_SYSTEM_NAME}/${BITNESS}bit${CONVENTION} ) INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${COOLPROP_LIBRARY_HEADER} DESTINATION shared_library) SET_PROPERTY (TARGET ${LIB_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS " -DCOOLPROP_LIB") # Now all the compiler specific settings for Visual Studio IF (MSVC) # Add postfix for debugging SET_PROPERTY(TARGET ${LIB_NAME} PROPERTY DEBUG_POSTFIX d) SET_PROPERTY(TARGET ${LIB_NAME} PROPERTY RELEASE_POSTFIX ) # No lib prefix for the shared library SET_PROPERTY(TARGET ${LIB_NAME} PROPERTY PREFIX "") modify_msvc_flags("/MT") # Note that the default is not used if ${COOLPROP_MSVC_REL} or ${COOLPROP_MSVC_DBG} is set ADD_CUSTOM_COMMAND(TARGET ${LIB_NAME} POST_BUILD COMMAND dumpbin /EXPORTS $ > ${CMAKE_CURRENT_BINARY_DIR}/exports.txt) INSTALL (FILES ${CMAKE_CURRENT_BINARY_DIR}/exports.txt DESTINATION shared_library/${CMAKE_SYSTEM_NAME}/${BITNESS}bit${CONVENTION}) ENDIF() # For Linux IF ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux") SET_PROPERTY (TARGET ${LIB_NAME} PROPERTY VERSION ${COOLPROP_VERSION}) SET_PROPERTY (TARGET ${LIB_NAME} PROPERTY SOVERSION ${COOLPROP_VERSION_MAJOR}) ENDIF() ELSE() MESSAGE(FATAL_ERROR "You have to build a static or shared library.") ENDIF() if (NOT COOLPROP_OBJECT_LIBRARY) target_link_libraries (${LIB_NAME} ${CMAKE_DL_LIBS}) endif() # For windows systems, bug workaround for Eigen IF (MSVC90) MESSAGE(STATUS "EIGEN WORKAROUND ACTIVE!!") SET_PROPERTY(TARGET ${LIB_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS " -DEIGEN_DONT_VECTORIZE") ENDIF() # For mac systems, explicitly set the c++ libraries if ("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin") if(DEFINED OSX_COMPILE_FLAGS) set_target_properties(${LIB_NAME} PROPERTIES APPEND_STRING PROPERTY COMPILE_FLAGS "${OSX_COMPILE_FLAGS}") endif(DEFINED OSX_COMPILE_FLAGS) if(DEFINED OSX_COMPILE_FLAGS) set_target_properties(${LIB_NAME} PROPERTIES APPEND_STRING PROPERTY LINK_FLAGS "${OSX_LINK_FLAGS}") endif(DEFINED OSX_COMPILE_FLAGS) endif() # Name mangling settings IF(COOLPROP_EXTERNC_LIBRARY) SET_PROPERTY (TARGET ${LIB_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS " -DEXTERNC") ENDIF() ### All options are set, we are building a library ### ADD_DEPENDENCIES(${LIB_NAME} generate_headers) # if (CMAKE_VERSION VERSION_GREATER 3.0) # Add target include directories for easy linking with other applications target_include_directories(${LIB_NAME} PUBLIC ${APP_INCLUDE_DIRS}) endif() # Set the bitness IF (NOT MSVC) IF (NOT "${BITNESS}" STREQUAL "NATIVE") MESSAGE(STATUS "Setting bitness flag -m${BITNESS}") SET_PROPERTY (TARGET ${LIB_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS " -m${BITNESS}") SET_PROPERTY (TARGET ${LIB_NAME} APPEND_STRING PROPERTY LINK_FLAGS " -m${BITNESS}") ENDIF() ENDIF() # ADD -fPIC flag if needed IF (COOLPROP_FPIC) MESSAGE(STATUS "Setting bitness flag -m${BITNESS}") SET_PROPERTY (TARGET ${LIB_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS " -fPIC") ENDIF() # # calling conventions IF ( ("${CONVENTION}" STREQUAL "NULL") OR ("${CONVENTION}" STREQUAL "") ) #MESSAGE(STATUS "Skipping unknown calling convention.") ELSE() SET_PROPERTY (TARGET ${LIB_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS " -DCONVENTION=${CONVENTION}") ENDIF() # #set_property(SOURCE MyFile.cpp APPEND_STRING PROPERTY COMPILE_FLAGS " -msse4.1 ") MESSAGE(STATUS "Library compilation detected:") MESSAGE(STATUS "Creating ${LIB_NAME}, a ${BITNESS}-bit library") MESSAGE(STATUS "CMAKE_SYSTEM_NAME: ${CMAKE_SYSTEM_NAME}") MESSAGE(STATUS "COOLPROP_STATIC_LIBRARY: ${COOLPROP_STATIC_LIBRARY}") MESSAGE(STATUS "COOLPROP_SHARED_LIBRARY: ${COOLPROP_SHARED_LIBRARY}") MESSAGE(STATUS "COOLPROP_OBJECT_LIBRARY: ${COOLPROP_OBJECT_LIBRARY}") MESSAGE(STATUS "CONVENTION: ${CONVENTION}") MESSAGE(STATUS "COOLPROP_LIBRARY_HEADER: ${COOLPROP_LIBRARY_HEADER}") MESSAGE(STATUS "COOLPROP_LIBRARY_SOURCE: ${COOLPROP_LIBRARY_SOURCE}") # GET_PROPERTY(tmpVar TARGET ${LIB_NAME} PROPERTY COMPILE_FLAGS) MESSAGE(STATUS "COMPILE_FLAGS: ${tmpVar}") GET_PROPERTY(tmpVar TARGET ${LIB_NAME} PROPERTY LINK_FLAGS) MESSAGE(STATUS "LINK_FLAGS: ${tmpVar}") # ENDIF() if (COOLPROP_IOS_TARGET) # Set the Base SDK (only change the SDKVER value, if for instance, you are building for iOS 5.0): set(SDKVER "9.2") set(DEVROOT "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer") set(SDKROOT "${DEVROOT}/SDKs/iPhoneOS${SDKVER}.sdk") if(EXISTS ${SDKROOT}) set(CMAKE_OSX_SYSROOT "${SDKROOT}") else() message("Warning, iOS Base SDK path not found: " ${SDKROOT}) endif() # Will resolve to "Standard (armv6 armv7)" on Xcode 4.0.2 and to "Standard (armv7)" on Xcode 4.2: set(CMAKE_OSX_ARCHITECTURES "$(ARCHS_STANDARD_32_BIT)") # seamless toggle between device and simulator set(CMAKE_XCODE_EFFECTIVE_PLATFORMS "-iphoneos;-iphonesimulator") include_directories( ${CMAKE_CURRENT_SOURCE_DIR} ) endif() if (COOLPROP_DEBIAN_PACKAGE) if(NOT UNIX) message(FATAL_ERROR "COOLPROP_DEBIAN_PACKAGE can only be used on linux host") endif() list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolPropLib.cpp") add_library(${app_name} SHARED ${APP_SOURCES}) set_target_properties (${app_name} PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -DCOOLPROP_LIB") set_target_properties (${app_name} PROPERTIES VERSION ${COOLPROP_VERSION} SOVERSION ${COOLPROP_VERSION_MAJOR}) add_dependencies (${app_name} generate_headers) install (TARGETS ${app_name} DESTINATION "${CMAKE_INSTALL_PREFIX}/usr/lib") install (FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/CoolPropLib.h DESTINATION "${CMAKE_INSTALL_PREFIX}/usr/include") endif() if (COOLPROP_VXWORKS_MAKEFILE) set(INCLUDE_DIRECTORIES) foreach (_srcFile ${APP_INCLUDE_DIRS}) string(CONCAT _el "-I\"" ${_srcFile} "\"") string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}" "$(COOLPROP_ROOT)" _el "${_el}") list (APPEND INCLUDE_DIRECTORIES ${_el}) endforeach() string(REPLACE ";" " " INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}") set(OLD_ROOT /home/ian/.wine/drive_c/) set(NEW_ROOT c:/) string(REPLACE ${OLD_ROOT} ${NEW_ROOT} INCLUDE_DIRECTORIES "${INCLUDE_DIRECTORIES}") set(SRC "${CMAKE_CURRENT_SOURCE_DIR}/src") string(REPLACE ${OLD_ROOT} ${NEW_ROOT} SRC "${SRC}") file(RELATIVE_PATH COOLPROP_ROOT "${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}") CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/wrappers/Labview/vxWorks/Makefile.in" "vxWorksMakefile") endif() if (COOLPROP_VXWORKS_LIBRARY_MODULE OR COOLPROP_VXWORKS_LIBRARY) list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolPropLib.cpp") add_executable(${app_name} ${APP_SOURCES}) set_target_properties (${app_name} PROPERTIES SUFFIX ".out" COMPILE_FLAGS "${COMPILE_FLAGS} -DEXTERNC") add_dependencies (${app_name} generate_headers) install (TARGETS ${app_name} DESTINATION "${COOLPROP_INSTALL_PREFIX}/shared_library/VxWorks") endif() if (COOLPROP_PRIME_MODULE) if(NOT WIN32) message(FATAL_ERROR "COOLPROP_PRIME_MODULE can only be used on windows host") endif() IF( "${COOLPROP_PRIME_ROOT}" STREQUAL "") message(FATAL_ERROR "You must provide the path to MathCAD Prime Root directory using something like -DCOOLPROP_PRIME_ROOT=\"C:/Program Files/PTC/Mathcad Prime 3.1\"") else() message(STATUS "COOLPROP_PRIME_ROOT: ${COOLPROP_PRIME_ROOT}") endif() list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolPropLib.cpp") list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/MathCAD/CoolPropMathcad.cpp") add_library(CoolPropMathcadWrapper SHARED ${APP_SOURCES}) include_directories("${COOLPROP_PRIME_ROOT}/Custom Functions") target_link_libraries(CoolPropMathcadWrapper "${COOLPROP_PRIME_ROOT}/Custom Functions/mcaduser.lib") SET_TARGET_PROPERTIES(CoolPropMathcadWrapper PROPERTIES LINK_FLAGS "/ENTRY:\"DllEntryPoint\"") add_dependencies (CoolPropMathcadWrapper generate_headers) set_target_properties(CoolPropMathcadWrapper PROPERTIES SUFFIX ".dll" PREFIX "") install (TARGETS CoolPropMathcadWrapper DESTINATION "${COOLPROP_INSTALL_PREFIX}/MathCADPrime") install (FILES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/MathCAD/Prime/CoolPropFluidProperties.mcdx" DESTINATION MathCADPrime) endif() if (COOLPROP_MATHCAD15_MODULE) if(NOT WIN32) message(FATAL_ERROR "COOLPROP_MATHCAD15_MODULE can only be used on windows host") endif() IF( "${COOLPROP_MATHCAD15_ROOT}" STREQUAL "") message(FATAL_ERROR "You must provide the path to MathCAD 15 Root directory using something like -DCOOLPROP_MATHCAD15_ROOT=\"C:/Program Files (x86)/Mathcad/Mathcad 15\"") else() message(STATUS "COOLPROP_MATHCAD15_ROOT: ${COOLPROP_MATHCAD15_ROOT}") endif() list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolPropLib.cpp") list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/MathCAD/CoolPropMathcad.cpp") add_library(CoolPropMathcadWrapper SHARED ${APP_SOURCES}) include_directories("${COOLPROP_MATHCAD15_ROOT}/userefi/microsft/include") target_link_libraries(CoolPropMathcadWrapper "${COOLPROP_MATHCAD15_ROOT}/userefi/microsft/lib/mcaduser.lib") SET_TARGET_PROPERTIES(CoolPropMathcadWrapper PROPERTIES LINK_FLAGS "/ENTRY:\"DllEntryPoint\"") add_dependencies (CoolPropMathcadWrapper generate_headers) set_target_properties(CoolPropMathcadWrapper PROPERTIES SUFFIX ".dll" PREFIX "") install (TARGETS CoolPropMathcadWrapper DESTINATION "${COOLPROP_INSTALL_PREFIX}/MathCAD15") install (FILES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/MathCAD/CoolPropFluidProperties.xmcdz" DESTINATION MathCAD15) install (FILES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/MathCAD/CoolProp_EN.xml" DESTINATION MathCAD15) endif() # EES is only compiled for 32bit Windows if (COOLPROP_EES_MODULE) IF (NOT "${BITNESS}" STREQUAL "32") MESSAGE(FATAL_ERROR "You cannot build the EES wrapper as a 64-bit library.") ENDIF() # Prepare the sources include_directories(${APP_INCLUDE_DIRS}) list (APPEND APP_SOURCES "wrappers/EES/main.cpp") list (APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/${COOLPROP_LIBRARY_SOURCE}") add_library(COOLPROP_EES SHARED ${APP_SOURCES}) # Modify the target and add dependencies add_dependencies (COOLPROP_EES generate_headers) set_target_properties (COOLPROP_EES PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -DCOOLPROP_LIB -DCONVENTION=__cdecl") set_target_properties (COOLPROP_EES PROPERTIES SUFFIX ".dlf" PREFIX "") # Creates "COOLPROP_EES.dlf" if ( NOT MSVC ) set_target_properties (COOLPROP_EES PROPERTIES COMPILE_FLAGS "-m32" LINK_FLAGS "-m32") elseif ( MSVC ) set_target_properties (COOLPROP_EES PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} ) set_target_properties (COOLPROP_EES PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_CURRENT_BINARY_DIR}) set_target_properties (COOLPROP_EES PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_CURRENT_BINARY_DIR}) # etc for the other available configuration types (MinSizeRel, RelWithDebInfo) endif () # copy required files add_custom_command (TARGET COOLPROP_EES PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/EES/CoolProp.htm" "${CMAKE_CURRENT_BINARY_DIR}/." COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/EES/CoolProp.LIB" "${CMAKE_CURRENT_BINARY_DIR}/." COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/EES/CoolProp_EES_Sample.EES" "${CMAKE_CURRENT_BINARY_DIR}/." WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Copying the EES files to the build directory" VERBATIM ) # install the generated library and the other files install(TARGETS COOLPROP_EES DESTINATION "${CMAKE_INSTALL_PREFIX}/EES/${CMAKE_SYSTEM_NAME}") install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/EES/CoolProp.htm" DESTINATION "${CMAKE_INSTALL_PREFIX}/EES/${CMAKE_SYSTEM_NAME}") install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/EES/CoolProp.LIB" DESTINATION "${CMAKE_INSTALL_PREFIX}/EES/${CMAKE_SYSTEM_NAME}") install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/EES/CoolProp_EES_Sample.EES" DESTINATION "${CMAKE_INSTALL_PREFIX}/EES/${CMAKE_SYSTEM_NAME}") endif() # Windows package if (COOLPROP_WINDOWS_PACKAGE) message(STATUS "Creating Windows installer for COOLPROP_VERSION=${COOLPROP_VERSION}") # Setting some basic build paths set(COOLPROP_WINDOWS_PACKAGE_32B_DIR "${CMAKE_CURRENT_BINARY_DIR}/32bitDLL") set(COOLPROP_WINDOWS_PACKAGE_32B_DIR_STDCALL "${CMAKE_CURRENT_BINARY_DIR}/32bitDLL_stdcall") set(COOLPROP_WINDOWS_PACKAGE_32B_DIR_CDECL "${CMAKE_CURRENT_BINARY_DIR}/32bitDLL_cdecl") set(COOLPROP_WINDOWS_PACKAGE_64B_DIR "${CMAKE_CURRENT_BINARY_DIR}/64bitDLL") set(COOLPROP_WINDOWS_PACKAGE_EES_DIR "${CMAKE_CURRENT_BINARY_DIR}/EES") set(COOLPROP_WINDOWS_PACKAGE_TMP_DIR "${CMAKE_CURRENT_BINARY_DIR}/InnoScript") # Pointers to the sources set(COOLPROP_WINDOWS_PACKAGE_EXCEL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/Excel") set(COOLPROP_WINDOWS_PACKAGE_ISS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/externals/ExcelAddinInstaller") # Generator for DLLs set(COOLPROP_WINDOWS_PACKAGE_DLL_GEN "${CMAKE_GENERATOR}") # Use the currently selected generator, architecture is hard-coded below # Configure variables like version number and build year CONFIGURE_FILE("${COOLPROP_WINDOWS_PACKAGE_ISS_DIR}/cmake-templates/config.iss" "${COOLPROP_WINDOWS_PACKAGE_ISS_DIR}/config.iss") # Find the installer generator executable SET(BINDIR32_ENV_NAME "ProgramFiles(x86)") SET(BINDIR32 $ENV{${BINDIR32_ENV_NAME}}) SET(BINDIR64_ENV_NAME "ProgramFiles") SET(BINDIR64 $ENV{${BINDIR64_ENV_NAME}}) find_program (COOLPROP_WINDOWS_PACKAGE_ISS_EXE NAMES iscc.exe HINTS "${BINDIR32}/Inno Setup 6" "${BINDIR64}/Inno Setup 6" ) # ****************************************************************** # Add the targets that prepare the build directory for the subbuilds # ****************************************************************** add_custom_target(COOLPROP_WINDOWS_PACKAGE_PREPARE) # Prepare directories add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_PREPARE PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_32B_DIR}" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_32B_DIR_STDCALL}" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_32B_DIR_CDECL}" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_64B_DIR}" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_EES_DIR}" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source" #COMMAND ${CMAKE_COMMAND} ARGS "-E" "remove_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/deploy" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/deploy" #COMMAND ${CMAKE_COMMAND} ARGS "-E" "remove_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin" WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Preparing the directories for the Windows installer" VERBATIM ) add_custom_target(COOLPROP_WINDOWS_PACKAGE_DELETE) # Delete directories add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_DELETE PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source" COMMAND ${CMAKE_COMMAND} ARGS "-E" "remove_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/deploy" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/deploy" COMMAND ${CMAKE_COMMAND} ARGS "-E" "remove_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin" WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Removing the old build directories for the Windows installer" VERBATIM ) # ************************************************************** # Add the target for the shared libraries, 2x 32bit and 1x 64bit # ************************************************************** add_custom_target(COOLPROP_WINDOWS_PACKAGE_SHARED_LIBRARIES) add_dependencies (COOLPROP_WINDOWS_PACKAGE_SHARED_LIBRARIES COOLPROP_WINDOWS_PACKAGE_PREPARE) # Copy the header file add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_SHARED_LIBRARIES PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${CMAKE_CURRENT_SOURCE_DIR}/include/CoolPropLib.h" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source/CoolPropLib.h" WORKING_DIRECTORY ${COOLPROP_WINDOWS_PACKAGE_32B_DIR} COMMENT "Copy the header file for the CoolProp library" VERBATIM ) # Build the 32bit DLLs add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_SHARED_LIBRARIES PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-G${COOLPROP_WINDOWS_PACKAGE_DLL_GEN}" "-AWin32" "${CMAKE_CURRENT_SOURCE_DIR}" "-DCOOLPROP_SHARED_LIBRARY=ON" "-DCOOLPROP_STDCALL_LIBRARY=ON" COMMAND ${CMAKE_COMMAND} ARGS "--build" "." "--target" "CoolProp" "--config" "Release" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${COOLPROP_WINDOWS_PACKAGE_32B_DIR_STDCALL}/Release/CoolProp.dll" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source/CoolProp_stdcall.dll" WORKING_DIRECTORY ${COOLPROP_WINDOWS_PACKAGE_32B_DIR_STDCALL} COMMENT "Building the 32bit shared library with stdcall" VERBATIM ) add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_SHARED_LIBRARIES PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-G${COOLPROP_WINDOWS_PACKAGE_DLL_GEN}" "-AWin32" "${CMAKE_CURRENT_SOURCE_DIR}" "-DCOOLPROP_SHARED_LIBRARY=ON" "-DCOOLPROP_CDECL_LIBRARY=ON" COMMAND ${CMAKE_COMMAND} ARGS "--build" "." "--target" "CoolProp" "--config" "Release" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${COOLPROP_WINDOWS_PACKAGE_32B_DIR_CDECL}/Release/CoolProp.dll" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source/CoolProp_cdecl.dll" WORKING_DIRECTORY ${COOLPROP_WINDOWS_PACKAGE_32B_DIR_CDECL} COMMENT "Building the 32bit shared library with cdecl" VERBATIM ) # Build the 64bit DLL add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_SHARED_LIBRARIES PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-G${COOLPROP_WINDOWS_PACKAGE_DLL_GEN}" "-Ax64" "${CMAKE_CURRENT_SOURCE_DIR}" "-DCOOLPROP_SHARED_LIBRARY=ON" COMMAND ${CMAKE_COMMAND} ARGS "--build" "." "--target" "CoolProp" "--config" "Release" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${COOLPROP_WINDOWS_PACKAGE_64B_DIR}/Release/CoolProp.dll" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source/CoolProp_x64.dll" WORKING_DIRECTORY ${COOLPROP_WINDOWS_PACKAGE_64B_DIR} COMMENT "Building the 64bit shared library" VERBATIM ) # ************************************************************* # Add the target for EES and populate it with custom commands # ************************************************************* add_custom_target(COOLPROP_WINDOWS_PACKAGE_EES) add_dependencies (COOLPROP_WINDOWS_PACKAGE_EES COOLPROP_WINDOWS_PACKAGE_PREPARE) add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_EES PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-G${COOLPROP_WINDOWS_PACKAGE_DLL_GEN}" "-AWin32" "${CMAKE_CURRENT_SOURCE_DIR}" "-DCOOLPROP_EES_MODULE=ON" COMMAND ${CMAKE_COMMAND} ARGS "--build" "." "--target" "COOLPROP_EES" "--config" "Release" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy_directory" "${COOLPROP_WINDOWS_PACKAGE_EES_DIR}" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source/EES" WORKING_DIRECTORY ${COOLPROP_WINDOWS_PACKAGE_EES_DIR} COMMENT "Building the 32bit library for EES" VERBATIM ) # ************************************************************* # Add the target for Excel and populate it with custom commands # ************************************************************* add_custom_target(COOLPROP_WINDOWS_PACKAGE_EXCEL) add_dependencies (COOLPROP_WINDOWS_PACKAGE_EXCEL COOLPROP_WINDOWS_PACKAGE_SHARED_LIBRARIES COOLPROP_WINDOWS_PACKAGE_PREPARE) # Copy the Excel files add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_EXCEL PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${COOLPROP_WINDOWS_PACKAGE_EXCEL_DIR}/CoolProp.xla" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source/" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${COOLPROP_WINDOWS_PACKAGE_EXCEL_DIR}/CoolProp.xlam" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source/" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${COOLPROP_WINDOWS_PACKAGE_EXCEL_DIR}/TestExcel.xlsx" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/source/" COMMAND ${CMAKE_COMMAND} ARGS "-E" "remove_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin/MicrosoftExcel/" COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin/MicrosoftExcel/" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${COOLPROP_WINDOWS_PACKAGE_EXCEL_DIR}/CoolProp.xla" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin/MicrosoftExcel/" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${COOLPROP_WINDOWS_PACKAGE_EXCEL_DIR}/CoolProp.xlam" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin/MicrosoftExcel/" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${COOLPROP_WINDOWS_PACKAGE_EXCEL_DIR}/TestExcel.xlsx" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin/MicrosoftExcel/" WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Copying the Excel files for the installer" VERBATIM ) # ******************************************************************* # Add the target for Inno Script and populate it with custom commands # ******************************************************************* add_custom_target(COOLPROP_WINDOWS_PACKAGE_ISS) add_dependencies (COOLPROP_WINDOWS_PACKAGE_ISS COOLPROP_WINDOWS_PACKAGE_EXCEL COOLPROP_WINDOWS_PACKAGE_SHARED_LIBRARIES COOLPROP_WINDOWS_PACKAGE_PREPARE) # Copy the ISS files add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_ISS PRE_BUILD COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy_directory" "${COOLPROP_WINDOWS_PACKAGE_ISS_DIR}" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}" WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Copying the Inno Script files for the installer" VERBATIM ) # ***************************************************************************** # Add the target for the installer package and populate it with custom commands # ***************************************************************************** add_custom_target(COOLPROP_WINDOWS_PACKAGE_INSTALLER) add_dependencies (COOLPROP_WINDOWS_PACKAGE_INSTALLER COOLPROP_WINDOWS_PACKAGE_DELETE) add_dependencies (COOLPROP_WINDOWS_PACKAGE_INSTALLER COOLPROP_WINDOWS_PACKAGE_PREPARE) add_dependencies (COOLPROP_WINDOWS_PACKAGE_INSTALLER COOLPROP_WINDOWS_PACKAGE_SHARED_LIBRARIES) add_dependencies (COOLPROP_WINDOWS_PACKAGE_INSTALLER COOLPROP_WINDOWS_PACKAGE_EES) add_dependencies (COOLPROP_WINDOWS_PACKAGE_INSTALLER COOLPROP_WINDOWS_PACKAGE_EXCEL) add_dependencies (COOLPROP_WINDOWS_PACKAGE_INSTALLER COOLPROP_WINDOWS_PACKAGE_ISS) # Build the installer and copy it to the bin directory add_custom_command(TARGET COOLPROP_WINDOWS_PACKAGE_INSTALLER POST_BUILD COMMAND ${COOLPROP_WINDOWS_PACKAGE_ISS_EXE} ARGS "addin-installer.iss" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy_directory" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/deploy" "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin/Installers/Windows" WORKING_DIRECTORY "${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}" COMMENT "The new installer is located in '${COOLPROP_WINDOWS_PACKAGE_TMP_DIR}/bin/Installers/Windows'" VERBATIM ) endif() if (COOLPROP_OCTAVE_MODULE) if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") set(CMAKE_CXX_STANDARD 11) endif() # Must have SWIG and Octave FIND_PACKAGE(SWIG REQUIRED) INCLUDE(${SWIG_USE_FILE}) FIND_PACKAGE(Octave REQUIRED) # Make a src directory to deal with file permissions problem with MinGW makefile file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/src) # Set the include folders SET(OCTAVE_WRAP_INCLUDE_DIRS ${INCLUDE_DIR}) foreach(ITR ${OCTAVE_INCLUDE_DIRS}) list(APPEND OCTAVE_WRAP_INCLUDE_DIRS ${ITR}) endforeach() include_directories(${OCTAVE_INCLUDE_DIRS}) add_definitions(-DNO_ERROR_CATCHING) #disable internal error catching and allow swig to do the error catching itself set(I_FILE "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolProp.i") set(SWIG_OPTIONS "${COOLPROP_SWIG_OPTIONS}") SET_SOURCE_FILES_PROPERTIES(${I_FILE} PROPERTIES SWIG_FLAGS "${SWIG_OPTIONS}") SET_SOURCE_FILES_PROPERTIES(${I_FILE} PROPERTIES CPLUSPLUS ON) SET(SWIG_MODULE_CoolProp_EXTRA_DEPS ${SWIG_DEPENDENCIES} ) SWIG_ADD_MODULE(CoolProp octave ${I_FILE} ${APP_SOURCES}) if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") # We need to see which library to link with on OSX - clang++ or stdc++ message(STATUS "OCTAVE_OCTAVE_LIBRARY = ${OCTAVE_OCTAVE_LIBRARY}") if(${CMAKE_VERSION} VERSION_LESS "3.10.0") execute_process(COMMAND "otool -L ${OCTAVE_OCTAVE_LIBRARY} | grep libc++" OUTPUT_VARIABLE COOLPROP_OCTAVE_USING_CLANG) MESSAGE(STATUS "COOLPROP_OCTAVE_USING_CLANG = ${COOLPROP_OCTAVE_USING_CLANG}") string(STRIP "${COOLPROP_OCTAVE_USING_CLANG}" COOLPROP_OCTAVE_USING_CLANG) else() execute_process( COMMAND "otool -L ${OCTAVE_OCTAVE_LIBRARY}" COMMAND "grep libc++" OUTPUT_VARIABLE COOLPROP_OCTAVE_USING_CLANG ERROR_VARIABLE COOLPROP_OCTAVE_USING_CLANG ) MESSAGE(STATUS "COOLPROP_OCTAVE_USING_CLANG = ${COOLPROP_OCTAVE_USING_CLANG}") string(STRIP "${COOLPROP_OCTAVE_USING_CLANG}" COOLPROP_OCTAVE_USING_CLANG) endif() STRING(LENGTH "${COOLPROP_OCTAVE_USING_CLANG}" LEN) if (${LEN} GREATER 0) message(STATUS "Using -stdlib=libc++, this might override the settings based on DARWIN_USE_LIBCPP") SET(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++") else() message(STATUS "Using -stdlib=libstdc++, this might override the settings based on DARWIN_USE_LIBCPP") SET(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libstdc++") endif() endif() if (WIN32) include_directories($ENV{OCTAVE_ROOT}/include) include_directories($ENV{OCTAVE_ROOT}/include/octave-${OCTAVE_VERSION}/octave) set_target_properties(CoolProp PROPERTIES COMPILE_FLAGS "-fpermissive") SWIG_LINK_LIBRARIES(CoolProp octave octinterp) set_target_properties(CoolProp PROPERTIES LINK_FLAGS "-L$ENV{OCTAVE_ROOT}/mingw64/lib/octave/${OCTAVE_VERSION} -L$ENV{OCTAVE_ROOT}") else() SWIG_LINK_LIBRARIES(CoolProp ${OCTAVE_LIBRARIES}) endif() set_target_properties(CoolProp PROPERTIES SUFFIX ".oct" PREFIX "") add_dependencies (${app_name} generate_headers generate_examples) #add_custom_command(TARGET CoolProp # POST_BUILD # COMMAND "${PYTHON_EXECUTABLE}" example_generator.py Octave "${CMAKE_CURRENT_BINARY_DIR}/Example.m" # WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/dev/scripts/examples") install (FILES "${CMAKE_CURRENT_BINARY_DIR}/Example.m" DESTINATION Octave) install (TARGETS ${app_name} DESTINATION Octave/Octave${OCTAVE_VERSION}_${CMAKE_SYSTEM_NAME}_${BITNESS}bit) endif() if (COOLPROP_CSHARP_MODULE) # Must have SWIG and C# FIND_PACKAGE(SWIG REQUIRED) INCLUDE(${SWIG_USE_FILE}) FIND_PACKAGE(Csharp REQUIRED) # Make a src directory to deal with file permissions problem with MinGW makefile file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/src) if (WIN32) SET(MORE_SWIG_FLAGS -dllimport \"CoolProp\") endif() # Define which headers the CoolProp wrapper is dependent on SET(SWIG_MODULE_CoolProp_EXTRA_DEPS ${SWIG_DEPENDENCIES}) set(SWIG_OPTIONS "${COOLPROP_SWIG_OPTIONS}" "${MORE_SWIG_FLAGS}") string(REPLACE " " ";" SWIG_OPTIONS "${SWIG_OPTIONS}") message(STATUS "options passed to swig: ${SWIG_OPTIONS}") # Set properties before adding module set(I_FILE "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolProp.i") SET_SOURCE_FILES_PROPERTIES(${I_FILE} PROPERTIES SWIG_FLAGS "${SWIG_OPTIONS}" CPLUSPLUS ON) SWIG_ADD_MODULE(CoolProp csharp ${I_FILE} ${APP_SOURCES}) add_definitions(-DNO_ERROR_CATCHING) #disable internal error catching and allow swig to do the error catching itself if (WIN32) set_target_properties(CoolProp PROPERTIES PREFIX "") if (MSVC) modify_msvc_flags("/MT") # Note that the default is not used if ${COOLPROP_MSVC_REL} or ${COOLPROP_MSVC_DBG} is set endif() endif() if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") set_target_properties(CoolProp PROPERTIES PREFIX "lib") endif() if (UNIX) set_target_properties(CoolProp PROPERTIES PREFIX "lib") endif() add_dependencies (${app_name} generate_headers generate_examples) add_custom_command(TARGET CoolProp POST_BUILD COMMAND 7z a "${CMAKE_CURRENT_BINARY_DIR}/platform-independent.7z" "${CMAKE_CURRENT_BINARY_DIR}/*.cs" -x!Example.cs WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") #add_custom_command(TARGET CoolProp # POST_BUILD # COMMAND "${PYTHON_EXECUTABLE}" example_generator.py Csharp "${CMAKE_CURRENT_BINARY_DIR}/Example.cs" # WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/dev/scripts/examples") install (FILES "${CMAKE_CURRENT_BINARY_DIR}/Example.cs" DESTINATION Csharp) install (FILES "${CMAKE_CURRENT_BINARY_DIR}/platform-independent.7z" DESTINATION ${CMAKE_INSTALL_PREFIX}/Csharp) install (TARGETS ${app_name} DESTINATION Csharp/${CMAKE_SYSTEM_NAME}_${BITNESS}bit) enable_testing() if (DEFINED BUILD_TESTING) execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_SOURCE_DIR}/testing_root/Csharp${BITNESS}) # Copy the shared object to the folder with the executable - no idea like java.library.path in C# install (TARGETS ${app_name} DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/testing_root/Csharp${BITNESS}) endif() file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/*.cs cp_cs_path) if (${BITNESS} EQUAL "32") set(CSHARP_PLAT "-platform:x86") elseif((${BITNESS} EQUAL "64")) set(CSHARP_PLAT "-platform:x64") endif() add_test(NAME Csharptestbuild COMMAND ${CSHARP_COMPILER} -out:Example.exe ${CSHARP_PLAT} ${cp_cs_path} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/testing_root/Csharp${BITNESS}) add_test(NAME Csharptestrun COMMAND ${CSHARP_INTERPRETER} Example.exe WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/testing_root/Csharp${BITNESS}) endif() if (COOLPROP_VBDOTNET_MODULE) # Must have SWIG and C# FIND_PACKAGE(SWIG REQUIRED) INCLUDE(${SWIG_USE_FILE}) FIND_PACKAGE(Csharp REQUIRED) # Make a src directory to deal with file permissions problem with MinGW makefile file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/CoolPropVB) SET(MORE_SWIG_FLAGS -dllimport \"CoolProp\" -namespace CoolProp) SET(CMAKE_SWIG_OUTDIR CoolPropVB/CsharpClassLibrary) # Define which headers the CoolProp wrapper is dependent on SET(SWIG_MODULE_CoolProp_EXTRA_DEPS ${SWIG_DEPENDENCIES}) set(SWIG_OPTIONS "${MORE_SWIG_FLAGS}") string(REPLACE " " ";" SWIG_OPTIONS "${SWIG_OPTIONS}") message(STATUS "options passed to swig: ${SWIG_OPTIONS}") # Set properties before adding module set(I_FILE "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolProp.i") SET_PROPERTY(SOURCE ${I_FILE} PROPERTY CPLUSPLUS ON) SET_PROPERTY(SOURCE ${I_FILE} PROPERTY SWIG_FLAGS ${SWIG_OPTIONS}) SWIG_ADD_MODULE(CoolProp csharp ${I_FILE} ${APP_SOURCES}) add_definitions(-DNO_ERROR_CATCHING) #disable internal error catching and allow swig to do the error catching itself if (WIN32) set_target_properties(CoolProp PROPERTIES PREFIX "") endif() add_dependencies (${app_name} generate_headers) add_custom_command(TARGET CoolProp PRE_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/wrappers/VB.NET/CoolPropVB ${CMAKE_CURRENT_BINARY_DIR}/CoolPropVB WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") add_custom_command(TARGET CoolProp POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy $ ${CMAKE_CURRENT_BINARY_DIR}/CoolPropVB/CoolPropVB WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") add_custom_command(TARGET CoolProp POST_BUILD COMMAND ${CMAKE_COMMAND} -E remove ${CMAKE_CURRENT_BINARY_DIR}/CoolPropVB/CsharpClassLibrary/CoolPropCSHARP_wrap.cxx WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") add_custom_command(TARGET CoolProp POST_BUILD COMMAND 7z a "${CMAKE_CURRENT_BINARY_DIR}/VB.net_VS2012_example.7z" "${CMAKE_CURRENT_BINARY_DIR}/CoolPropVB" WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") install (FILES "${CMAKE_CURRENT_BINARY_DIR}/VB.net_VS2012_example.7z" DESTINATION ${CMAKE_INSTALL_PREFIX}/VB.NET) endif() if (COOLPROP_R_MODULE) IF (WIN32 AND MSVC) MESSAGE(FATAL_ERROR "Must use MinGW Makefiles generator on windows") ENDIF() # Must have SWIG FIND_PACKAGE(SWIG REQUIRED) INCLUDE(${SWIG_USE_FILE}) # Define which headers the swig wrapper is dependent on SET(SWIG_MODULE_CoolProp_EXTRA_DEPS ${SWIG_DEPENDENCIES} ) FIND_PACKAGE(R REQUIRED) include_directories(${R_INCLUDE_DIRS}) link_directories(${R_BIN_OUT}) if (NOT MSVC) set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -m${BITNESS}") set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -m${BITNESS}") endif() add_definitions(-DNO_ERROR_CATCHING) #disable internal error catching and allow swig to do the error catching itself # Set properties before adding module set(I_FILE "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolProp.i") SET_SOURCE_FILES_PROPERTIES(${I_FILE} PROPERTIES SWIG_FLAGS "${COOLPROP_SWIG_OPTIONS}" CPLUSPLUS ON) SWIG_ADD_MODULE(CoolProp r ${I_FILE} ${APP_SOURCES}) SWIG_LINK_LIBRARIES(CoolProp "${R_LIBRARY}") # No lib prefix for the shared library set_target_properties(CoolProp PROPERTIES PREFIX "") add_dependencies (${app_name} generate_headers generate_examples) #add_custom_command(TARGET CoolProp # POST_BUILD # COMMAND "${PYTHON_EXECUTABLE}" example_generator.py R "${CMAKE_CURRENT_BINARY_DIR}/Example.R" # WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/dev/scripts/examples") install (FILES "${CMAKE_CURRENT_BINARY_DIR}/Example.R" DESTINATION R) install (FILES "${CMAKE_CURRENT_BINARY_DIR}/CoolProp.R" DESTINATION R) install (TARGETS ${app_name} DESTINATION R/${CMAKE_SYSTEM_NAME}_${BITNESS}bit) enable_testing() add_test(R_test "${R_BIN_DIR}/Rscript" Example.R) endif() if (COOLPROP_JAVA_MODULE) # Must have SWIG and Java FIND_PACKAGE(SWIG REQUIRED) INCLUDE(${SWIG_USE_FILE}) find_package(Java REQUIRED) find_package(JNI) # Make a src directory to deal with file permissions problem with MinGW makefile file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/src) message(STATUS "JAVA_INCLUDE_PATH = ${JAVA_INCLUDE_PATH}") include_directories(${JAVA_INCLUDE_PATH}) include_directories(${JAVA_INCLUDE_PATH}/win32) include_directories(${JAVA_INCLUDE_PATH}/linux) set(I_FILE "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolProp.i") set(SWIG_OPTIONS "${COOLPROP_SWIG_OPTIONS}") string(REPLACE " " ";" SWIG_OPTIONS "${SWIG_OPTIONS}") SET_SOURCE_FILES_PROPERTIES(${I_FILE} PROPERTIES SWIG_FLAGS "${SWIG_OPTIONS}") SET_SOURCE_FILES_PROPERTIES(${I_FILE} PROPERTIES CPLUSPLUS ON) add_definitions(-DNO_ERROR_CATCHING) #disable internal error catching and allow swig to do the error catching itself SET(SWIG_MODULE_CoolProp_EXTRA_DEPS ${SWIG_DEPENDENCIES}) SWIG_ADD_MODULE(CoolProp java ${I_FILE} ${APP_SOURCES}) if (WIN32) set_target_properties(CoolProp PROPERTIES PREFIX "") if (MSVC) modify_msvc_flags("/MT") # Note that the default is not used if ${COOLPROP_MSVC_REL} or ${COOLPROP_MSVC_DBG} is set endif() endif() if (NOT MSVC) set_target_properties(CoolProp PROPERTIES COMPILE_FLAGS "-m${BITNESS}" LINK_FLAGS "-m${BITNESS}") endif() add_dependencies (${app_name} generate_headers generate_examples) add_custom_command(TARGET CoolProp POST_BUILD COMMAND 7z a "${CMAKE_CURRENT_BINARY_DIR}/platform-independent.7z" "${CMAKE_CURRENT_BINARY_DIR}/*.java" -x!Example.java WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}") #add_custom_command(TARGET CoolProp # POST_BUILD # COMMAND "${PYTHON_EXECUTABLE}" example_generator.py Java "${CMAKE_CURRENT_BINARY_DIR}/Example.java" # WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/dev/scripts/examples") # # Install all the generated java files install( CODE "file( GLOB _GeneratedJavaSources \"${CMAKE_CURRENT_BINARY_DIR}/*.java\" )" CODE "file( INSTALL \${_GeneratedJavaSources} DESTINATION ${CMAKE_INSTALL_PREFIX}/Java/platform-independent )" ) install (FILES "${CMAKE_CURRENT_BINARY_DIR}/Example.java" DESTINATION ${CMAKE_INSTALL_PREFIX}/Java) install (FILES "${CMAKE_CURRENT_BINARY_DIR}/platform-independent.7z" DESTINATION ${CMAKE_INSTALL_PREFIX}/Java) install (TARGETS ${app_name} DESTINATION ${CMAKE_INSTALL_PREFIX}/Java/${CMAKE_SYSTEM_NAME}_${BITNESS}bit) enable_testing() execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_SOURCE_DIR}/testing_root/Java${BITNESS}) add_test(NAME Javatestbuild COMMAND javac -d . ${CMAKE_INSTALL_PREFIX}/Java/Example.java -cp ${CMAKE_INSTALL_PREFIX}/Java/platform-independent WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/testing_root/Java${BITNESS}) add_test(NAME Javatestrun COMMAND ${Java_JAVA_EXECUTABLE} -Djava.library.path=${CMAKE_INSTALL_PREFIX}/Java/${CMAKE_SYSTEM_NAME}_${BITNESS}bit Example WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/testing_root/Java${BITNESS}) endif() # A module for Android if (COOLPROP_ANDROID_MODULE) if(WIN32 AND (NOT MINGW)) message(FATAL_ERROR "On windows, you must use the MinGW Makefiles generator ") endif() # For now, these must be changed manually set(ANDROID_MODULE_NAME "CoolProp") set(ANDROID_PACKAGE_NAME "CoolProp") # or blah.di.blah.CoolProp # Must have SWIG FIND_PACKAGE(SWIG REQUIRED) set(I_FILE "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolProp.i") list (APPEND APP_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/jni/CoolProp_wrap.cxx) string(REPLACE ";" " " APP_INCLUDE_DIRS "${APP_INCLUDE_DIRS}") string(REPLACE ";" " " APP_SOURCES "${APP_SOURCES}") file(MAKE_DIRECTORY jni) configure_file("${CMAKE_CURRENT_SOURCE_DIR}/wrappers/Android/Android.mk.template" "${CMAKE_CURRENT_BINARY_DIR}/jni/Android.mk" ) file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/Android/Application.mk" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/jni" ) string(REPLACE "." "/" ANDROID_PACKAGE_PATH "${ANDROID_PACKAGE_NAME}") file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${ANDROID_PACKAGE_PATH}") MESSAGE(STATUS "WORKING_DIRECTORY=${CMAKE_CURRENT_BINARY_DIR}") get_filename_component(NDK_BUILD_PATH "${NDK_PATH}/ndk-build" ABSOLUTE) get_filename_component(SRC_PATH "${CMAKE_CURRENT_SOURCE_DIR}/src" ABSOLUTE) get_filename_component(INCLUDE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/include" ABSOLUTE) add_custom_target(CoolProp ALL COMMAND ${NDK_BUILD_PATH} DEPENDS jni/CoolProp_wrap.cxx VERBATIM) add_custom_command(OUTPUT jni/CoolProp_wrap.cxx COMMAND ${SWIG_EXECUTABLE} -v -c++ -java -I${SRC_PATH} -I${INCLUDE_PATH} -o ${CMAKE_CURRENT_BINARY_DIR}/jni/CoolProp_wrap.cxx -package ${ANDROID_PACKAGE_NAME} -outdir ${CMAKE_CURRENT_BINARY_DIR}/${ANDROID_PACKAGE_PATH} ${I_FILE} WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" VERBATIM) add_dependencies(CoolProp generate_headers) endif() if (COOLPROP_PHP_MODULE) # Must have SWIG FIND_PACKAGE(SWIG REQUIRED) INCLUDE(${SWIG_USE_FILE}) execute_process( COMMAND php-config --includes OUTPUT_VARIABLE php_config_includes RESULT_VARIABLE php_config_failed ) if (php_config_failed) message(FATAL_ERROR "calling \"php-config --includes\" failed; message:" ${php_config_includes}) endif() string(STRIP "${php_config_includes}" php_config_includes) string(REPLACE "-I" "" PHP_INCLUDES "${php_config_includes}") SEPARATE_ARGUMENTS(PHP_INCLUDES) message(STATUS "php includes=${PHP_INCLUDES}") include_directories(${PHP_INCLUDES}) add_definitions(-DNO_ERROR_CATCHING) #disable internal error catching and allow swig to do the error catching itself set(I_FILE "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolProp.i") set(SWIG_OPTIONS "${COOLPROP_SWIG_OPTIONS}") string(REPLACE " " ";" SWIG_OPTIONS "${SWIG_OPTIONS}") SET_SOURCE_FILES_PROPERTIES(${I_FILE} PROPERTIES SWIG_FLAGS "${SWIG_OPTIONS}") SET_SOURCE_FILES_PROPERTIES(${I_FILE} PROPERTIES CPLUSPLUS ON) SET(SWIG_MODULE_CoolProp_EXTRA_DEPS ${SWIG_DEPENDENCIES}) SWIG_ADD_MODULE(CoolProp php ${I_FILE} ${APP_SOURCES}) if (WIN32) set_target_properties(CoolProp PROPERTIES PREFIX "") endif() if (NOT MSVC) set_target_properties(CoolProp PROPERTIES COMPILE_FLAGS "-m${BITNESS}" LINK_FLAGS "-m${BITNESS}") endif() add_dependencies (CoolProp generate_headers) install (FILES ${CMAKE_CURRENT_BINARY_DIR}/CoolProp.php DESTINATION ${CMAKE_INSTALL_PREFIX}/PHP/cross-platform) install (TARGETS ${app_name} DESTINATION ${CMAKE_INSTALL_PREFIX}/PHP/${CMAKE_SYSTEM_NAME}) endif() function(JOIN VALUES GLUE OUTPUT) string (REGEX REPLACE "([^\\]|^);" "\\1${GLUE}" _TMP_STR "${VALUES}") string (REGEX REPLACE "[\\](.)" "\\1" _TMP_STR "${_TMP_STR}") #fixes escaping set (${OUTPUT} "${_TMP_STR}" PARENT_SCOPE) endfunction() if (COOLPROP_PYTHON_BINARIES) if (WIN32) set(COOLPROP_PYTHON_BINARY_VERSIONS bdist_wheel --dist-dir ${CMAKE_INSTALL_PREFIX}/Python bdist_wininst --dist-dir ${CMAKE_INSTALL_PREFIX}/Python) elseif (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") set(COOLPROP_PYTHON_BINARY_VERSIONS bdist_wheel --dist-dir ${CMAKE_INSTALL_PREFIX}/Python) endif() add_custom_target(CoolProp COMMAND python setup.py ${COOLPROP_PYTHON_BINARY_VERSIONS} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/wrappers/Python ) endif() if (COOLPROP_PYTHON_PYPI) add_custom_target(CoolProp COMMAND python prepare_pypi.py --dist-dir=${CMAKE_INSTALL_PREFIX}/Python WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/wrappers/Python/pypi ) endif() if (COOLPROP_LIBREOFFICE_MODULE) IF( "${LO_PROGRAM_PATH}" STREQUAL "") message(FATAL_ERROR "You must provide the path to LibreOffice programs, something like -DLO_PROGRAM_PATH=/usr/lib/libreoffice/program") else() message(STATUS "LO_PROGRAM_PATH: ${LO_PROGRAM_PATH}") endif() IF( "${LO_SDK_PATH}" STREQUAL "") message(FATAL_ERROR "You must provide the path to LibreOffice SDK, something like -DLO_SDK_PATH=/usr/lib/libreoffice/sdk") else() message(STATUS "LO_SDK_PATH: ${LO_SDK_PATH}") endif() add_custom_target(CoolPropLibreOfficeAddin) # set paths for LibreOffice tools set(LO_IDLC "${LO_SDK_PATH}/bin/idlc") set(LO_REGMERGE "${LO_PROGRAM_PATH}/regmerge") set(COOLPROP_LIBREOFFICE_TMP_DIR "${CMAKE_CURRENT_BINARY_DIR}/LibreOffice") # set version strings for LibreOffice extension configure_file("${CMAKE_CURRENT_SOURCE_DIR}/wrappers/LibreOffice/src/description.xml.in" "${COOLPROP_LIBREOFFICE_TMP_DIR}/src/description.xml") configure_file("${CMAKE_CURRENT_SOURCE_DIR}/wrappers/LibreOffice/src/scripts/scripts.py.in" "${COOLPROP_LIBREOFFICE_TMP_DIR}/src/scripts/scripts.py") add_custom_command( TARGET CoolPropLibreOfficeAddin # copy source files to build directory COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy_directory" "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/LibreOffice/src" "${COOLPROP_LIBREOFFICE_TMP_DIR}/src" COMMAND ${CMAKE_COMMAND} ARGS "-E" "remove" "${COOLPROP_LIBREOFFICE_TMP_DIR}/src/description.xml.in" "${COOLPROP_LIBREOFFICE_TMP_DIR}/src/scripts/scripts.py.in" # rebuild the registry database file (rdb) COMMAND ${LO_IDLC} XCoolProp.idl -I. -I${LO_SDK_PATH}/idl -O. XCoolProp.idl COMMAND ${LO_REGMERGE} XCoolProp.rdb /UCR XCoolProp.urd COMMAND ${CMAKE_COMMAND} ARGS "-E" "remove" XCoolProp.urd # download and bundle latest Python pip package (py2.py3, platform independent) COMMAND pip download pip -d pythonpath COMMAND 7z x "./pythonpath/pip-*.whl" -y -opythonpath # download and bundle latest Python certifi package (py2.py3, platform independent) COMMAND pip download certifi -d pythonpath COMMAND 7z x "./pythonpath/certifi-*.whl" -y -opythonpath # add license file COMMAND ${CMAKE_COMMAND} ARGS "-E" "make_directory" "${COOLPROP_LIBREOFFICE_TMP_DIR}/src/license" COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE" "${COOLPROP_LIBREOFFICE_TMP_DIR}/src/license/." # package complete folder to extension COMMAND 7z a -tzip "../CoolProp.oxt" # copy example spreadsheet file COMMAND ${CMAKE_COMMAND} ARGS "-E" "copy" "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/LibreOffice/TestLibreOffice.ods" "${COOLPROP_LIBREOFFICE_TMP_DIR}/." WORKING_DIRECTORY ${COOLPROP_LIBREOFFICE_TMP_DIR}/src COMMENT "Building LibreOffice wrapper" VERBATIM ) endif() if (COOLPROP_JAVASCRIPT_MODULE) # cmake -DCOOLPROP_JAVASCRIPT_MODULE=ON # -DCMAKE_TOOLCHAIN_FILE=${EMSCRIPTEN}/cmake/Platform/Emscripten.cmake # ../.. # Toolchain MUST be defined in the call to CMake if(MSVC) message(FATAL_ERROR "Cannot use visual studio, use MinGW Makefiles generator on windows") endif() add_definitions( -sDISABLE_EXCEPTION_CATCHING=0) # If you want a monolithic file with no async memory loading, define EMSCRIPTEN_NO_MEMORY_INIT_FILE if(EMSCRIPTEN_NO_MEMORY_INIT_FILE) set(EMSCRIPTEN_INIT_FLAG "--memory-init-file 0") else() set(EMSCRIPTEN_INIT_FLAG "--memory-init-file 1") endif() set(CMAKE_EXE_LINKER_FLAGS "--bind ${EMSCRIPTEN_INIT_FLAG} -s ASSERTIONS=1 -s DISABLE_EXCEPTION_CATCHING=0") set(CMAKE_BUILD_TYPE Release) list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/CoolPropLib.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/emscripten_interface.cxx") include_directories(${APP_INCLUDE_DIRS}) add_executable(coolprop ${APP_SOURCES}) add_dependencies (coolprop generate_headers) SET_TARGET_PROPERTIES(coolprop PROPERTIES PREFIX "" SUFFIX .js) #install (TARGETS coolprop DESTINATION ${CMAKE_INSTALL_PREFIX}/Javascript) install (FILES "${CMAKE_CURRENT_BINARY_DIR}/coolprop.js" DESTINATION ${CMAKE_INSTALL_PREFIX}/Javascript) install (FILES "${CMAKE_CURRENT_BINARY_DIR}/coolprop.wasm" DESTINATION ${CMAKE_INSTALL_PREFIX}/Javascript) #install (FILES "${CMAKE_CURRENT_BINARY_DIR}/install_manifest.txt" DESTINATION ${CMAKE_INSTALL_PREFIX}/Javascript) install (FILES "${CMAKE_CURRENT_SOURCE_DIR}/Web/coolprop/wrappers/Javascript/index.html" DESTINATION ${CMAKE_INSTALL_PREFIX}/Javascript ) endif() if (COOLPROP_MATHEMATICA_MODULE) if (MSVC) modify_msvc_flags("/MT") # Note that the default is not used if ${COOLPROP_MSVC_REL} or ${COOLPROP_MSVC_DBG} is set endif() set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/externals/FindMathematica/CMake/Mathematica/") find_package(Mathematica COMPONENTS WolframLibrary) message(STATUS "Mathematica_WolframLibrary_FOUND=${Mathematica_WolframLibrary_FOUND}") message(STATUS "Mathematica_WolframLibrary_INCLUDE_DIR=${Mathematica_WolframLibrary_INCLUDE_DIR}") message(STATUS "Mathematica_USERBASE_DIR=${Mathematica_USERBASE_DIR}") list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/Mathematica/CoolPropMathematica.cpp") list(APPEND APP_INCLUDE_DIRS "${Mathematica_WolframLibrary_INCLUDE_DIR}") include_directories(${APP_INCLUDE_DIRS}) add_library(CoolProp SHARED ${APP_SOURCES}) add_dependencies (CoolProp generate_headers) if(MSVC) add_custom_command(TARGET ${app_name} POST_BUILD COMMAND dumpbin /EXPORTS $ > ${CMAKE_CURRENT_BINARY_DIR}/exports.txt) endif() install (FILES $ DESTINATION Mathematica/${CMAKE_SYSTEM_NAME}) install (FILES "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/Mathematica/example.nb" DESTINATION Mathematica) endif() if (COOLPROP_SMATH_MODULE) if (COOLPROP_SMATH_WORK_INPLACE) set(COOLPROP_WORK_BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR}) else() set(COOLPROP_WORK_BASE_DIR ${CMAKE_CURRENT_BINARY_DIR}) endif() set(COOLPROP_VERSION ${COOLPROP_VERSION_MAJOR}.${COOLPROP_VERSION_MINOR}.${COOLPROP_VERSION_PATCH}.0) CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/wrappers/SMath/coolprop_wrapper/Properties/AssemblyInfo.cs.template" "${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/Properties/AssemblyInfo.cs") message(STATUS "Generated ${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/Properties/AssemblyInfo.cs") FILE(WRITE "${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/config.ini" "${COOLPROP_VERSION}") message(STATUS "Generated ${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/config.ini") CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/wrappers/SMath/coolprop_wrapper/install.bat.template" "${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/install.bat") message(STATUS "Generated ${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/install.bat") CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/wrappers/SMath/coolprop_wrapper/build_zip.bat.template" "${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/build_zip.bat") message(STATUS "Generated ${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/build_zip.bat") FILE(TO_NATIVE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/wrappers/SMath/coolprop_wrapper" DOS_STYLE_SOURCE_DIR) FILE(TO_NATIVE_PATH "${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper" DOS_STYLE_TARGET_DIR) CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/wrappers/SMath/coolprop_wrapper/coolprop_wrapper.csproj.template" "${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/coolprop_wrapper.csproj") message(STATUS "Generated ${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/coolprop_wrapper.csproj") include_external_msproject( CoolPropWrapper ${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/coolprop_wrapper.csproj TYPE FAE04EC0-301F-11D3-BF4B-00C04F79EFBC PLATFORM AnyCPU) message(STATUS "C# project ${COOLPROP_WORK_BASE_DIR}/wrappers/SMath/coolprop_wrapper/coolprop_wrapper.csproj included") endif() # Use like cmake ..\CoolProp.git -DCOOLPROP_MY_MAIN=dev/coverity/main.cxx if (COOLPROP_MY_MAIN) list(APPEND APP_SOURCES "${COOLPROP_MY_MAIN}") add_executable (Main ${APP_SOURCES}) add_dependencies (Main generate_headers) if(UNIX) target_link_libraries (Main ${CMAKE_DL_LIBS}) endif() endif() if (COOLPROP_MAIN_MODULE) # Allow you to independently add back the testing CPP files if(COOLPROP_TEST) list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/Tests/Tests.cpp") list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/Tests/CoolProp-Tests.cpp") endif() list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/main.cxx") add_executable (Main ${APP_SOURCES}) add_dependencies (Main generate_headers) if(COOLPROP_TEST) set_target_properties (Main PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -DENABLE_CATCH") endif() if (COOLPROP_IWYU) find_program(iwyu_path NAMES include-what-you-use iwyu) if(NOT iwyu_path) message(FATAL_ERROR "Could not find the program include-what-you-use") endif() set_property(TARGET Main PROPERTY CXX_INCLUDE_WHAT_YOU_USE ${iwyu_path}) endif() if(UNIX) target_link_libraries (Main ${CMAKE_DL_LIBS}) endif() endif() ### COOLPROP TESTING APP ### if (COOLPROP_CATCH_MODULE) enable_testing() list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/Tests/test_main.cxx") list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/Tests/CoolProp-Tests.cpp") # CATCH TEST, compile everything with catch and set test entry point add_executable (CatchTestRunner ${APP_SOURCES}) add_dependencies (CatchTestRunner generate_headers) set_target_properties (CatchTestRunner PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -DENABLE_CATCH") if(UNIX) target_link_libraries (CatchTestRunner ${CMAKE_DL_LIBS}) endif() add_test(ProcedureTests CatchTestRunner) if (COOLPROP_IWYU) find_program(iwyu_path NAMES include-what-you-use iwyu) if(NOT iwyu_path) message(FATAL_ERROR "Could not find the program include-what-you-use") endif() set_property(TARGET CatchTestRunner PROPERTY CXX_INCLUDE_WHAT_YOU_USE ${iwyu_path}) endif() endif() if (COOLPROP_CPP_EXAMPLE_TEST) # C++ Documentation Test add_executable (docuTest.exe "Web/examples/C++/Example.cpp") add_dependencies (docuTest.exe ${app_name}) target_link_libraries (docuTest.exe ${app_name}) if(UNIX) target_link_libraries (docuTest.exe ${CMAKE_DL_LIBS}) endif() add_test(DocumentationTest docuTest.exe) endif() if (COOLPROP_SNIPPETS) LIST(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/${COOLPROP_LIBRARY_SOURCE}") # Make the static library with which the snippets will be linked add_library(${app_name} STATIC ${APP_SOURCES}) add_dependencies (${app_name} generate_headers) SET_PROPERTY(TARGET ${app_name} APPEND_STRING PROPERTY COMPILE_FLAGS " -DEXTERNC") # Collect all the snippets file(GLOB_RECURSE snippets "${CMAKE_CURRENT_SOURCE_DIR}/Web/coolprop/snippets/*.cxx") message(STATUS "snippets found = ${snippets}") foreach (snippet ${snippets}) get_filename_component(snippet_name ${snippet} NAME) get_filename_component(snippet_exe ${snippet} NAME_WE) message(STATUS "snippet_name = ${snippet_name}") add_executable (${snippet_exe} ${snippet}) add_dependencies (${snippet_exe} CoolProp) target_link_libraries (${snippet_exe} CoolProp) if(UNIX) target_link_libraries (${snippet_exe} ${CMAKE_DL_LIBS}) endif() if ( MSVC ) set_target_properties( ${snippet_exe} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin ) set_target_properties( ${snippet_exe} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_CURRENT_BINARY_DIR}/bin ) set_target_properties( ${snippet_exe} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_CURRENT_BINARY_DIR}/bin ) # etc for the other available configuration types (MinSizeRel, RelWithDebInfo) set(BIN_PATH "${CMAKE_CURRENT_BINARY_DIR}/bin") else() set(BIN_PATH "${CMAKE_CURRENT_BINARY_DIR}") endif () SET_PROPERTY(TARGET ${snippet_exe} APPEND_STRING PROPERTY COMPILE_FLAGS " -DEXTERNC") # Run it and save the output to a file with .output appended add_custom_command(TARGET ${snippet_exe} POST_BUILD COMMAND ${BIN_PATH}/${snippet_exe} > ${CMAKE_CURRENT_SOURCE_DIR}/Web/coolprop/snippets/${snippet_name}.output) endforeach() endif() if (COOLPROP_CLANG_ADDRESS_SANITIZER) SET(CMAKE_CXX_FLAGS "-fsanitize=address -g") list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/Tests/catch_always_return_success.cxx") # CATCH TEST, compile everything with catch and set test entry point add_executable (CatchTestRunner ${APP_SOURCES}) add_dependencies (CatchTestRunner generate_headers) set_target_properties (CatchTestRunner PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -DENABLE_CATCH") set(CMAKE_CXX_FLAGS "-O1") set(CMAKE_EXE_LINKER_FLAGS "-fsanitize=address -fno-omit-frame-pointer -lstdc++") if(UNIX) target_link_libraries (CatchTestRunner ${CMAKE_DL_LIBS}) endif() add_custom_command(TARGET CatchTestRunner POST_BUILD COMMAND ${CMAKE_CURRENT_BINARY_DIR}/CatchTestRunner) endif() if (COOLPROP_PROFILE) if(CMAKE_COMPILER_IS_GNUCXX) SET(CMAKE_CXX_FLAGS "-g -O2") SET(CMAKE_C_FLAGS "-g -O2") endif() endif() if (COOLPROP_COVERAGE) if(CMAKE_COMPILER_IS_GNUCXX) # See also http://stackoverflow.com/a/16536401 (detailed guide on using gcov with cmake) include(CodeCoverage) SET(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage") SET(CMAKE_C_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage") setup_target_for_coverage(CoolProp_coverage Main coverage) endif() endif() # TODO: check relevance of http://www.cmake.org/Wiki/BuildingWinDLL #include_directories("${CMAKE_CURRENT_SOURCE_DIR}/CoolProp") #FILE(GLOB coolprop_files "${CMAKE_CURRENT_SOURCE_DIR}/CoolProp/*.cpp") #add_library(coolprop STATIC ${coolprop_files})