cmake_minimum_required(VERSION 3.12)

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)

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)

set(CMAKE_CXX_STANDARD 17)

if (COOLPROP_ASAN)

# https://stackoverflow.com/a/64294837 (CC BY-SA 4.0)

if(isMultiConfig)

if(NOT "Asan" IN_LIST CMAKE_CONFIGURATION_TYPES)

list(APPEND CMAKE_CONFIGURATION_TYPES Asan)

endif()

else()

set(allowedBuildTypes Asan Debug Release RelWithDebInfo MinSizeRel)

set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "${allowedBuildTypes}")

if(CMAKE_BUILD_TYPE AND NOT CMAKE_BUILD_TYPE IN_LIST allowedBuildTypes)

message(FATAL_ERROR "Invalid build type: ${CMAKE_BUILD_TYPE}")

endif()

endif()

set(CMAKE_C_FLAGS_ASAN

"${CMAKE_C_FLAGS_RelWithDebInfo} -fsanitize=address -fno-omit-frame-pointer" CACHE STRING

"Flags used by the C compiler for Asan build type or configuration." FORCE)

set(CMAKE_CXX_FLAGS_ASAN

"${CMAKE_CXX_FLAGS_RelWithDebInfo} -fsanitize=address -fno-omit-frame-pointer" CACHE STRING

"Flags used by the C++ compiler for Asan build type or configuration." FORCE)

set(CMAKE_EXE_LINKER_FLAGS_ASAN

"${CMAKE_EXE_LINKER_FLAGS_RelWithDebInfo} -fsanitize=address" CACHE STRING

"Linker flags to be used to create executables for Asan build type." FORCE)

set(CMAKE_SHARED_LINKER_FLAGS_ASAN

"${CMAKE_SHARED_LINKER_FLAGS_RelWithDebInfo} -fsanitize=address" CACHE STRING

"Linker lags to be used to create shared libraries for Asan build type." FORCE)

endif()

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)

set(project_name "CoolProp")

set(app_name ${project_name})

project(${project_name})

set(COOLPROP_VERSION_MAJOR 7)

set(COOLPROP_VERSION_MINOR 2)

set(COOLPROP_VERSION_PATCH 1)

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_PUBLISHER "The CoolProp developers")

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"

set(ZIPFN "${CMAKE_CURRENT_SOURCE_DIR}/dev/docker/boost_bcp_docker/boost_CoolProp.tar.xz")

set(OUTFN "${CMAKE_CURRENT_SOURCE_DIR}/boost_CoolProp/boost/version.hpp")

if (EXISTS ${ZIPFN})

if(NOT EXISTS ${OUTFN})

execute_process(COMMAND ${CMAKE_COMMAND} -E tar -xJf ${ZIPFN}

WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")

message(STATUS "Untarred boost headers")

endif()

else()

message(FATAL_ERROR "tar.xz of boost sources needed for teqp cannot be found")

endif()

include_directories("${CMAKE_CURRENT_SOURCE_DIR}/boost_CoolProp")

set(COOLPROP_ENABLED_BACKENDS

Cubics

IF97

Helmholtz

REFPROP

Incompressible

Tabular

PCSAFT)

file(GLOB APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")

list(APPEND APP_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/externals/miniz-3.0.2/miniz.c")

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()

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")

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/miniz-3.0.2")

list(APPEND APP_INCLUDE_DIRS

"${CMAKE_CURRENT_SOURCE_DIR}/externals/nlohmann-json")

list(APPEND APP_INCLUDE_DIRS

"${CMAKE_CURRENT_SOURCE_DIR}/externals/incbin")

list(APPEND APP_INCLUDE_DIRS

"${CMAKE_CURRENT_SOURCE_DIR}/dev")

list(APPEND APP_INCLUDE_DIRS

"${CMAKE_CURRENT_SOURCE_DIR}/boost_CoolProp")

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

if (MSVC)

# fmtlib requires that the utf-8 support be compiled in

# TODO: add the fmt target from fmtlib directly which does this

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /utf-8 -D_CRT_SECURE_NO_WARNINGS")

endif()

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")

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}

"${CMAKE_CURRENT_SOURCE_DIR}/dev/cmake/Modules/")

message(STATUS "Looking for Python")

find_package(Python REQUIRED COMPONENTS Interpreter)

set(PYTHON_EXECUTABLE ${Python_EXECUTABLE})

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(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()

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()

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()

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")

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})

## For arm64 builds, put the shared library in the Windows/64bit__arm64 folder

if(MSVC AND ("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "ARM64" OR "${CMAKE_VS_PLATFORM_NAME}" STREQUAL "arm64"))

set(OUTPUT_FOLDER "shared_library/${CMAKE_SYSTEM_NAME}/${BITNESS}bit__arm64")

else()

set(OUTPUT_FOLDER "shared_library/${CMAKE_SYSTEM_NAME}/${BITNESS}bit${CONVENTION}")

endif()

install(

TARGETS ${LIB_NAME}

DESTINATION ${OUTPUT_FOLDER}

)

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 $<TARGET_FILE:${LIB_NAME}> >

${CMAKE_CURRENT_BINARY_DIR}/exports.txt)

install(

FILES ${CMAKE_CURRENT_BINARY_DIR}/exports.txt

DESTINATION ${OUTPUT_FOLDER}

)

add_custom_command(

TARGET ${LIB_NAME}

POST_BUILD

COMMAND dumpbin /HEADERS $<TARGET_FILE:${LIB_NAME}> >

${CMAKE_CURRENT_BINARY_DIR}/headers.txt)

install(

FILES ${CMAKE_CURRENT_BINARY_DIR}/headers.txt

DESTINATION ${OUTPUT_FOLDER}

)

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 fPIC flag")

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()

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()

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_ARM64_DIR "${CMAKE_CURRENT_BINARY_DIR}/arm64bitDLL")

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")