generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2024-12-12 18:40:27 +01:00
Code Issues Projects Releases Wiki Activity
cc4d03fa1c
libzmq/CMakeLists.txt

1403 lines
44 KiB
CMake
Raw Normal View History

First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
# CMake build script for ZeroMQ
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cmake_minimum_required (VERSION 2.8.12)
project (ZeroMQ)
cmake: Use project specific source directory instead of top level source tree Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:28:38 +02:00
list (INSERT CMAKE_MODULE_PATH 0 "${CMAKE_CURRENT_SOURCE_DIR}")
move FindSodium to builds/cmake/Modules with the rest of the CMake modules
2018-01-13 01:27:24 +01:00
set (ZMQ_CMAKE_MODULES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/Modules)
list (APPEND CMAKE_MODULE_PATH ${ZMQ_CMAKE_MODULES_DIR})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
Install relocatable dylibs (MacOS) Problem: When building libzmq with CMake, the installed libzmq.dylib has a relative install name (otool -D libzmq.dylib) on MacOS. This is a regression against building via autotools which sets an absolute install name. Effectively, the CMake built libzmq.dylib is rendered useless if installed in non-system directories and used in environments without explicit DYLD_LIBRARY_PATH mgmt. For example running any of the installed executables currently fails: $ /some_install_prefix/bin/inproc_lat dyld: Library not loaded: libzmq.5.dylib Referenced from: /some_install_prefix/bin/inproc_lat Reason: image not found Trace/BPT trap: 5 Solution: Best practice is to install relocatable dylibs. On MacOS this means setting an install name with a special prefix, e.g. @rpath/libzmq.dylib, and adding the relevant search paths to the embedded rpath list. In this patch the necessary CMake options are added to generate the desired relocatable dylibs. Find more information on: https://cmake.org/Wiki/CMake_RPATH_handling.
2018-04-25 19:06:21 +02:00
# Apply CMP0042: MACOSX_RPATH is enabled by default
cmake_policy (SET CMP0042 NEW)
include(GNUInstallDirs)
if (${CMAKE_SYSTEM_NAME} STREQUAL Darwin)
# Find more information: https://cmake.org/Wiki/CMake_RPATH_handling
# Add an install rpath if it is not a system directory
list (FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}" isSystemDir)
if ("${isSystemDir}" STREQUAL "-1")
set (CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
endif ()
# Add linker search paths pointing to external dependencies
set (CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
endif ()
Problem: need to check for C++ standard in cmake Solution: use CheckCXXCompilerFlag to check for support for -std=gnu++11
2016-02-19 22:48:43 +01:00
include(CheckCXXCompilerFlag)
CHECK_CXX_COMPILER_FLAG("-std=gnu++11" COMPILER_SUPPORTS_CXX11)
if(COMPILER_SUPPORTS_CXX11)
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")
Problem: need to check for C++ standard in cmake Solution: use CheckCXXCompilerFlag to check for support for -std=gnu++11
2016-02-19 22:48:43 +01:00
endif()
include(CheckCCompilerFlag)
CHECK_C_COMPILER_FLAG("-std=gnu11" COMPILER_SUPPORTS_C11)
if(COMPILER_SUPPORTS_C11)
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu11")
Problem: need to check for C++ standard in cmake Solution: use CheckCXXCompilerFlag to check for support for -std=gnu++11
2016-02-19 22:48:43 +01:00
endif()
cmake: Streamline integration allowing config of CMAKE_*_OUTPUT_DIRECTORY Setting EXECUTABLE_OUTPUT_PATH and LIBRARY_OUTPUT_PATH variables is deprecated
2018-06-28 21:51:43 +02:00
include (ZMQSupportMacros)
Problem: clang 6 warns about comparisons on 64 bit Solution: ignore tautological-constant-compare warnings, as they might be useless on 64 bit but they are not on 32 bit where sizeof size_t != sizeof uint64_t
2018-05-26 21:05:14 +02:00
if(NOT MSVC)
# clang 6 has a warning that does not make sense on multi-platform code
CHECK_CXX_COMPILER_FLAG("-Wno-tautological-constant-compare" CXX_HAS_TAUT_WARNING)
if(CXX_HAS_TAUT_WARNING)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-tautological-constant-compare")
endif()
CHECK_C_COMPILER_FLAG("-Wno-tautological-constant-compare" CC_HAS_TAUT_WARNING)
if(CC_HAS_TAUT_WARNING)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-tautological-constant-compare")
endif()
endif()
Problem: pkgconfig file does not support static link Solution: add dependencies, if necessary, to the .private Libs and Requires field of the pkgconfig file at build time. This way pkg-config --static --libs libzmq will correctly print dependencies if they were used to build the static libzmq.a library.
2016-09-27 19:39:07 +02:00
# Will be used to add flags to pkg-config useful when apps want to statically link
set (pkg_config_libs_private "")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
option (WITH_OPENPGM "Build with support for OpenPGM" OFF)
option (WITH_VMCI "Build with support for VMware VMCI socket" OFF)
if (APPLE)
Make OS Xframwork build optional
2017-01-27 19:30:18 +01:00
option (ZMQ_BUILD_FRAMEWORK "Build as OS X framework" OFF)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
# Select curve encryption library, defaults to tweetnacl
# To use libsodium instead, use --with-libsodium (must be installed)
# To disable curve, use --disable-curve
option (WITH_LIBSODIUM "Use libsodium instead of built-in tweetnacl" OFF)
option (ENABLE_CURVE "Enable CURVE security" ON)
if (NOT ENABLE_CURVE)
message (STATUS "CURVE security is disabled")
Problem: typo in CMakeLists.txt, can't use sodium Solution: check for WITH_LIBSODIUM configure option instead of WITH_SODIUM
2016-02-11 21:40:34 +01:00
elseif (WITH_LIBSODIUM)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
find_package (Sodium)
if (SODIUM_FOUND)
message (STATUS "Using libsodium for CURVE security")
include_directories (${SODIUM_INCLUDE_DIRS})
Problem: HAVE_LIBSODIUM macro is inconsistent Solution: use ZMQ_USE_LIBSODIUM to match ZMQ_USE_TWEETNACL
2016-03-12 15:25:41 +01:00
set (ZMQ_USE_LIBSODIUM 1)
Problem: tweetnacl sources are a mess - they have no copyright / license statement - they are in some randomish directory structure - they are a mix of postable and non-portable files - they do not conform to conditional compile environment Overall, it makes it rather more work than needed, in build scripts. Solution: clean up tweetnacl sauce. - merged code into single tweetnacl.c and .h - standard copyright header, DJB to AUTHORS - moved into src/ along with all other source files - all system and conditional compilation hidden in these files - thus, they can be compiled and packaged in all cases - ZMQ_USE_TWEETNACL is set when we're using built-in tweetnacl - HAVE_LIBSODIUM is set when we're using external libsodium
2016-02-11 18:06:07 +01:00
set (ZMQ_HAVE_CURVE 1)
Problem: pkg-config Requires.private is broken Solution: use only Libs.private to avoid breaking application builds. Even though Requires.private are supposed to be parsed only if pkg-config is called with --static, the --cflags parameter is enough to trigger the parsing, causing build failures for applications that do not (and should not) depend on libzmq's dependencies.
2016-09-28 00:08:40 +02:00
set (pkg_config_libs_private "${pkg_config_libs_private} -lsodium")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
else ()
message (FATAL_ERROR
"libsodium is not installed. Install it, then run CMake again")
endif ()
else ()
message (STATUS "Using tweetnacl for CURVE security")
Problem: tweetnacl sources are a mess - they have no copyright / license statement - they are in some randomish directory structure - they are a mix of postable and non-portable files - they do not conform to conditional compile environment Overall, it makes it rather more work than needed, in build scripts. Solution: clean up tweetnacl sauce. - merged code into single tweetnacl.c and .h - standard copyright header, DJB to AUTHORS - moved into src/ along with all other source files - all system and conditional compilation hidden in these files - thus, they can be compiled and packaged in all cases - ZMQ_USE_TWEETNACL is set when we're using built-in tweetnacl - HAVE_LIBSODIUM is set when we're using external libsodium
2016-02-11 18:06:07 +01:00
list (APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/src/tweetnacl.c)
set (ZMQ_USE_TWEETNACL 1)
set (ZMQ_HAVE_CURVE 1)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Problem: no support for DRAFT API in build systems Solution: add support for --enable-drafts/ENABLE_DRAFTS=ON in Autools and CMake.
2016-05-02 20:44:35 +02:00
set(SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
if (EXISTS "${SOURCE_DIR}/.git")
OPTION (ENABLE_DRAFTS "Build and install draft classes and methods" ON)
else ()
OPTION (ENABLE_DRAFTS "Build and install draft classes and methods" OFF)
endif ()
IF (ENABLE_DRAFTS)
ADD_DEFINITIONS (-DZMQ_BUILD_DRAFT_API)
set (pkg_config_defines "-DZMQ_BUILD_DRAFT_API=1")
ELSE (ENABLE_DRAFTS)
set (pkg_config_defines "")
ENDIF (ENABLE_DRAFTS)
Problem: No CMake option to set ZMQ_ACT_MILITANT Solution: Add CMake option called WITH_MILITANT so that it aligns with the Autotools build infrastructure; enabling this option defines ZMQ_ACT_MILITANT, which enables assertions should malformed requests make their way into zmq_setsockopt(3) or zmq_getsockopt(3).
2016-05-06 21:50:56 +02:00
option (WITH_MILITANT "Enable militant assertions" OFF)
if (WITH_MILITANT)
add_definitions(-DZMQ_ACT_MILITANT)
endif()
Problem: API poller cannot be set independently from I/O thread poller, poll I/O thread poller broken on Windows Solution: change platform definitions to separate API poller from I/O thread poller, disallow configuring poll I/O thread poller on Windows
2018-05-22 15:57:20 +02:00
set (API_POLLER "" CACHE STRING "Choose polling system for zmq_poll(er)_*. valid values are
poll or select [default=poll unless POLLER=select]")
set (POLLER "" CACHE STRING "Choose polling system for I/O threads. valid values are
move the `pollset` to the position between `devpoll` and `poll`
2016-09-21 05:24:26 +02:00
kqueue, epoll, devpoll, pollset, poll or select [default=autodetect]")
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
include (CheckFunctionExists)
include (CheckTypeSize)
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (NOT MSVC)
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES sys/event.h)
check_function_exists (kqueue HAVE_KQUEUE)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_KQUEUE)
set (POLLER "kqueue")
endif()
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES sys/epoll.h)
check_function_exists (epoll_create HAVE_EPOLL)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_EPOLL)
set (POLLER "epoll")
check_function_exists (epoll_create1 HAVE_EPOLL_CLOEXEC)
if (HAVE_EPOLL_CLOEXEC)
set (ZMQ_IOTHREAD_POLLER_USE_EPOLL_CLOEXEC 1)
endif ()
Problem: epoll leaks socket on fork+exec Solution: if available, use epoll_create1 with EPOLL_CLOEXEC flag to make the process close the socket on fork+exec
2016-12-26 18:01:36 +01:00
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES sys/devpoll.h)
check_type_size ("struct pollfd" DEVPOLL)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_DEVPOLL)
set (POLLER "devpoll")
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES sys/pollset.h)
check_function_exists (pollset_create HAVE_POLLSET)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_POLLSET)
set (POLLER "pollset")
endif()
endif ()
move the `pollset` to the position between `devpoll` and `poll`
2016-09-21 05:24:26 +02:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (POLLER STREQUAL "")
set (CMAKE_REQUIRED_INCLUDES poll.h)
check_function_exists (poll HAVE_POLL)
set (CMAKE_REQUIRED_INCLUDES)
if (HAVE_POLL)
set (POLLER "poll")
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
endif()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (POLLER STREQUAL "")
if (WIN32)
set (CMAKE_REQUIRED_INCLUDES winsock2.h)
set (HAVE_SELECT 1)
else ()
set (CMAKE_REQUIRED_INCLUDES sys/select.h)
check_function_exists (select HAVE_SELECT)
set (CMAKE_REQUIRED_INCLUDES)
endif ()
if (HAVE_SELECT)
set (POLLER "select")
else ()
message (FATAL_ERROR
"Could not autodetect polling method")
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (POLLER STREQUAL "kqueue"
OR POLLER STREQUAL "epoll"
OR POLLER STREQUAL "devpoll"
move the `pollset` to the position between `devpoll` and `poll`
2016-09-21 05:24:26 +02:00
OR POLLER STREQUAL "pollset"
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
OR POLLER STREQUAL "poll"
OR POLLER STREQUAL "select")
Problem: API poller cannot be set independently from I/O thread poller, poll I/O thread poller broken on Windows Solution: change platform definitions to separate API poller from I/O thread poller, disallow configuring poll I/O thread poller on Windows
2018-05-22 15:57:20 +02:00
message (STATUS "Using polling method in I/O threads: ${POLLER}")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
string (TOUPPER ${POLLER} UPPER_POLLER)
Problem: API poller cannot be set independently from I/O thread poller, poll I/O thread poller broken on Windows Solution: change platform definitions to separate API poller from I/O thread poller, disallow configuring poll I/O thread poller on Windows
2018-05-22 15:57:20 +02:00
set (ZMQ_IOTHREAD_POLLER_USE_${UPPER_POLLER} 1)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
else ()
message (FATAL_ERROR "Invalid polling method")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: epoll not supported under Windows Solution: Use wepoll on Windows
2018-05-23 11:50:42 +02:00
if (POLLER STREQUAL "epoll" AND WIN32)
message (STATUS "Including wepoll")
list (APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/external/wepoll/wepoll.c ${CMAKE_CURRENT_SOURCE_DIR}/external/wepoll/wepoll.h)
endif()
Problem: API poller cannot be set independently from I/O thread poller, poll I/O thread poller broken on Windows Solution: change platform definitions to separate API poller from I/O thread poller, disallow configuring poll I/O thread poller on Windows
2018-05-22 15:57:20 +02:00
if (API_POLLER STREQUAL "")
if (POLLER STREQUAL "select")
set (API_POLLER "select")
else()
set (API_POLLER "poll")
endif()
endif()
message (STATUS "Using polling method in zmq_poll(er)_* API: ${API_POLLER}")
string (TOUPPER ${API_POLLER} UPPER_API_POLLER)
set (ZMQ_POLL_BASED_ON_${UPPER_API_POLLER} 1)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
include (TestZMQVersion)
cmake: Disable runtime checks while cross compiling Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:32:29 +02:00
if (NOT CMAKE_CROSSCOMPILING)
include (ZMQSourceRunChecks)
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
include (CheckIncludeFiles)
include (CheckLibraryExists)
include (CheckCCompilerFlag)
include (CheckCXXCompilerFlag)
include (CheckCSourceCompiles)
include (CheckCSourceRuns)
include (CMakeDependentOption)
include (CheckCXXSymbolExists)
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
include (CheckSymbolExists)
replace check_library and check_include with find_file and find_library
2015-02-06 16:42:23 +01:00
Problem: cygwin build defines ZMQ_HAVE_WINDOWS Solution: do not check for windows.h on cygwin
2018-05-24 15:12:57 +02:00
if (NOT CYGWIN)
# TODO cannot we simply do 'if (WIN32) set(ZMQ_HAVE_WINDOWS ON)' or similar?
check_include_files (windows.h ZMQ_HAVE_WINDOWS)
endif()
Problem: CMake evaluation fails with Mingw-w64 Solution: we can use 'CMAKE_SYSTEM_VERSION' instead of '${CMAKE_SYSTEM_VERSION}' for the 'if' clauses. CMake fails to evaluate condition when CMAKE_SYSTEM_VERSION is empty, which can happen with a default installation of Mingw-w64 in Linux.
2017-06-14 15:55:29 +02:00
if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore" AND CMAKE_SYSTEM_VERSION STREQUAL "10.0")
Problem: no windows UWP support * add define for windows/UWP * prevent issue with COM references * gettickcount not available on uwp * add compiler definitions * add convenitnece cmake file * brute force uwp compilation * fix compiler version * cosmetics
2017-04-04 10:50:33 +02:00
SET(ZMQ_HAVE_WINDOWS_UWP ON)
ADD_DEFINITIONS(-D_WIN32_WINNT=_WIN32_WINNT_WIN10)
endif()
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (NOT MSVC)
check_include_files (ifaddrs.h ZMQ_HAVE_IFADDRS)
check_include_files (sys/uio.h ZMQ_HAVE_UIO)
check_include_files (sys/eventfd.h ZMQ_HAVE_EVENTFD)
if (ZMQ_HAVE_EVENTFD AND NOT CMAKE_CROSSCOMPILING)
zmq_check_efd_cloexec ()
endif ()
endif()
Enable building IPC filtering with cmake.
2013-12-06 19:55:44 +01:00
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
if (ZMQ_HAVE_WINDOWS)
# Cannot use check_library_exists because the symbol is always declared as char(*)(void)
set(CMAKE_REQUIRED_LIBRARIES "ws2_32.lib")
Problem: certain windows header files are actually lowercase Solution: change case of `WinSock2.h Iphlpapi.h Rpc.h` to match the files on disk. This is only noticeable when cross-compiling from a case-sensitive system so wouldn't get picked up in MSVC or mingw builds running on a windows machine. MSDN uses capitalised versions in prose and lowercase in code examples: https://msdn.microsoft.com/en-us/library/windows/desktop/ms737629(v=vs.85).aspx Fixes #2978, the missing library message is a little misleading.
2018-03-12 10:19:27 +01:00
check_symbol_exists (WSAStartup "winsock2.h" HAVE_WS2_32)
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
set(CMAKE_REQUIRED_LIBRARIES "rpcrt4.lib")
Problem: certain windows header files are actually lowercase Solution: change case of `WinSock2.h Iphlpapi.h Rpc.h` to match the files on disk. This is only noticeable when cross-compiling from a case-sensitive system so wouldn't get picked up in MSVC or mingw builds running on a windows machine. MSDN uses capitalised versions in prose and lowercase in code examples: https://msdn.microsoft.com/en-us/library/windows/desktop/ms737629(v=vs.85).aspx Fixes #2978, the missing library message is a little misleading.
2018-03-12 10:19:27 +01:00
check_symbol_exists (UuidCreateSequential "rpc.h" HAVE_RPCRT4)
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
set(CMAKE_REQUIRED_LIBRARIES "iphlpapi.lib")
Problem: certain windows header files are actually lowercase Solution: change case of `WinSock2.h Iphlpapi.h Rpc.h` to match the files on disk. This is only noticeable when cross-compiling from a case-sensitive system so wouldn't get picked up in MSVC or mingw builds running on a windows machine. MSDN uses capitalised versions in prose and lowercase in code examples: https://msdn.microsoft.com/en-us/library/windows/desktop/ms737629(v=vs.85).aspx Fixes #2978, the missing library message is a little misleading.
2018-03-12 10:19:27 +01:00
check_symbol_exists (GetAdaptersAddresses "winsock2.h;iphlpapi.h" HAVE_IPHLAPI)
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
set(CMAKE_REQUIRED_LIBRARIES "")
# TODO: This not the symbol we're looking for. What is the symbol?
check_library_exists (ws2 fopen "" HAVE_WS2)
else()
check_cxx_symbol_exists (SO_PEERCRED sys/socket.h ZMQ_HAVE_SO_PEERCRED)
check_cxx_symbol_exists (LOCAL_PEERCRED sys/socket.h ZMQ_HAVE_LOCAL_PEERCRED)
endif()
Fix cmake not linking librt to perf-tools
2013-01-23 20:31:02 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
find_library (RT_LIBRARY rt)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
find_package (Threads)
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WIN32 AND NOT CYGWIN)
if (NOT HAVE_WS2_32 AND NOT HAVE_WS2)
message (FATAL_ERROR "Cannot link to ws2_32 or ws2")
endif ()
if (NOT HAVE_RPCRT4)
message (FATAL_ERROR "Cannot link to rpcrt4")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT HAVE_IPHLAPI)
message (FATAL_ERROR "Cannot link to iphlapi")
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (NOT MSVC)
set (CMAKE_REQUIRED_LIBRARIES rt)
check_function_exists (clock_gettime HAVE_CLOCK_GETTIME)
set (CMAKE_REQUIRED_LIBRARIES)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
set (CMAKE_REQUIRED_INCLUDES unistd.h)
check_function_exists (fork HAVE_FORK)
set (CMAKE_REQUIRED_INCLUDES)
fix test_fork * was problem on debian/wheezy
2014-03-17 21:09:10 +01:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
set (CMAKE_REQUIRED_INCLUDES sys/time.h)
check_function_exists (gethrtime HAVE_GETHRTIME)
set (CMAKE_REQUIRED_INCLUDES)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
set (CMAKE_REQUIRED_INCLUDES stdlib.h)
check_function_exists (mkdtemp HAVE_MKDTEMP)
set (CMAKE_REQUIRED_INCLUDES)
Problem: mkdtemp not available on all platforms Solution: check for availability in autoconf and cmake, and if not available fall back to random file name rather than random directory.
2016-04-10 23:45:35 +02:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
set (CMAKE_REQUIRED_INCLUDES sys/socket.h)
check_function_exists (accept4 HAVE_ACCEPT4)
set (CMAKE_REQUIRED_INCLUDES)
endif()
Problem: accept4 not available on all platforms Solution: check for availability in CMake and autoconf before using it
2017-11-17 19:40:53 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
add_definitions (-D_REENTRANT -D_THREAD_SAFE)
Problem: gyp does not build tests Solution: it's a lot of work to define the tests in project.gyp so I did this using gsl to generate the JSON, from a small XML list of the test cases. To keep this, and the hundreds of .mk files, away from the root directory, I've moved the gyp files into builds/gyp, where you would run them. It all seems to work now. Next up, OS/X and Windows :)
2016-02-12 11:31:38 +01:00
add_definitions (-DZMQ_CUSTOM_PLATFORM_HPP)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
option (ENABLE_EVENTFD "Enable/disable eventfd" ZMQ_HAVE_EVENTFD)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
macro (zmq_check_cxx_flag_prepend flag)
check_cxx_compiler_flag ("${flag}" HAVE_FLAG_${flag})
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (HAVE_FLAG_${flag})
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
endif ()
endmacro ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: No static analysis under Windows Solution: Enable VS static analyzer and core guideline checks
2018-05-16 09:12:26 +02:00
OPTION (ENABLE_ANALYSIS "Build with static analysis (make take very long)" OFF)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
Problem: No static analysis under Windows Solution: Enable VS static analyzer and core guideline checks
2018-05-16 09:12:26 +02:00
if (ENABLE_ANALYSIS)
zmq_check_cxx_flag_prepend ("/W4")
zmq_check_cxx_flag_prepend ("/analyze")
# C++11/14/17-specific, but maybe possible via conditional defines
zmq_check_cxx_flag_prepend ("/wd26440") # Function '...' can be declared 'noexcept'
zmq_check_cxx_flag_prepend ("/wd26432") # If you define or delete any default operation in the type '...', define or delete them all
zmq_check_cxx_flag_prepend ("/wd26439") # This kind of function may not throw. Declare it 'noexcept'
zmq_check_cxx_flag_prepend ("/wd26447") # The function is declared 'noexcept' but calls function '...' which may throw exceptions
zmq_check_cxx_flag_prepend ("/wd26433") # Function '...' should be marked with 'override'
zmq_check_cxx_flag_prepend ("/wd26409") # Avoid calling new and delete explicitly, use std::make_unique<T> instead
# Requires GSL
zmq_check_cxx_flag_prepend ("/wd26429") # Symbol '...' is never tested for nullness, it can be marked as not_null
zmq_check_cxx_flag_prepend ("/wd26446") # Prefer to use gsl::at()
zmq_check_cxx_flag_prepend ("/wd26481") # Don't use pointer arithmetic. Use span instead
zmq_check_cxx_flag_prepend ("/wd26472") # Don't use a static_cast for arithmetic conversions. Use brace initialization, gsl::narrow_cast or gsl::narow
zmq_check_cxx_flag_prepend ("/wd26448") # Consider using gsl::finally if final action is intended
zmq_check_cxx_flag_prepend ("/wd26400") # Do not assign the result of an allocation or a function call with an owner<T> return value to a raw pointer, use owner<T> instead
zmq_check_cxx_flag_prepend ("/wd26485") # Expression '...': No array to pointer decay (bounds.3)
else()
zmq_check_cxx_flag_prepend ("/W3")
endif()
CMAKE_VS_PLATFORM_TOOLSET may not be set. E.g. for nmake.
2015-12-18 15:50:41 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC_IDE)
set (MSVC_TOOLSET "-${CMAKE_VS_PLATFORM_TOOLSET}")
else ()
set (MSVC_TOOLSET "")
endif ()
else ()
zmq_check_cxx_flag_prepend ("-Wall")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
zmq_check_cxx_flag_prepend ("-Wextra")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
option (LIBZMQ_PEDANTIC "" ON)
option (LIBZMQ_WERROR "" OFF)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
# TODO: why is -Wno-long-long defined differently than in configure.ac?
if (NOT MSVC)
zmq_check_cxx_flag_prepend ("-Wno-long-long")
zmq_check_cxx_flag_prepend ("-Wno-uninitialized")
Fix unused argument warnings
2013-01-01 09:26:31 +01:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (LIBZMQ_PEDANTIC)
zmq_check_cxx_flag_prepend ("-pedantic")
Fix unused argument warnings
2013-01-01 09:26:31 +01:00
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (${CMAKE_CXX_COMPILER_ID} MATCHES "Intel")
zmq_check_cxx_flag_prepend ("-strict-ansi")
endif ()
if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
zmq_check_cxx_flag_prepend ("-compat=5")
endif ()
endif ()
endif()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (LIBZMQ_WERROR)
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if(MSVC)
zmq_check_cxx_flag_prepend ("/WX")
else()
zmq_check_cxx_flag_prepend ("-Werror")
if (NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
zmq_check_cxx_flag_prepend ("-errwarn=%all")
endif()
endif()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_SYSTEM_PROCESSOR MATCHES "^sparc")
zmq_check_cxx_flag_prepend ("-mcpu=v9")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
zmq_check_cxx_flag_prepend ("-features=zla")
endif ()
Fix cmake build with sun studio
2013-01-01 11:22:05 +01:00
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_SYSTEM_NAME MATCHES "SunOS" OR CMAKE_SYSTEM_NAME MATCHES "NetBSD")
message (STATUS "Checking whether atomic operations can be used")
check_c_source_compiles (
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
"
#include <atomic.h>
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
int main ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
{
uint32_t value;
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
atomic_cas_32 (&value, 0, 0);
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
return 0;
}
"
HAVE_ATOMIC_H)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT HAVE_ATOMIC_H)
set (ZMQ_FORCE_MUTEXES 1)
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: no check if noexcept is supported by compiler Solution: add compile check
2018-05-30 22:03:19 +02:00
zmq_check_noexcept ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
#-----------------------------------------------------------------------------
Problem: cmake run is very slow with MSVC Solution: skip tests than can never succeed with MSVC
2018-05-23 16:47:13 +02:00
if (NOT CMAKE_CROSSCOMPILING AND NOT MSVC)
cmake: Disable runtime checks while cross compiling Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:32:29 +02:00
zmq_check_sock_cloexec ()
Problem: tweetnacl leaks file descriptor on fork+exec Solution: open with O_CLOEXEC if available or set FD_CLOEXEC if not
2017-07-28 00:29:33 +02:00
zmq_check_o_cloexec ()
Add socket option BINDTODEVICE Linux now supports Virtual Routing and Forwarding (VRF) as per: https://www.kernel.org/doc/Documentation/networking/vrf.txt In order for an application to bind or connect to a socket with an address in a VRF, they need to first bind the socket to the VRF device: setsockopt(sd, SOL_SOCKET, SO_BINDTODEVICE, dev, strlen(dev)+1); Note "dev" is the VRF device, eg. VRF "blue", rather than an interface enslaved to the VRF. Add a new socket option, ZMQ_BINDTODEVICE, to bind a socket to a device. In general, if a socket is bound to a device, eg. an interface, only packets received from that particular device are processed by the socket. If device is a VRF device, then subsequent binds/connects to that socket use addresses in the VRF routing table.
2017-07-28 15:35:09 +02:00
zmq_check_so_bindtodevice ()
cmake: Disable runtime checks while cross compiling Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:32:29 +02:00
zmq_check_so_keepalive ()
zmq_check_tcp_keepcnt ()
zmq_check_tcp_keepidle ()
zmq_check_tcp_keepintvl ()
zmq_check_tcp_keepalive ()
zmq_check_tcp_tipc ()
zmq_check_pthread_setname ()
Background threads enhancements (#2778) * Background thread scheduling - add ZMQ_THREAD_AFFINITY ctx option; set all thread scheduling options from the context of the secondary thread instead of using the main process thread context! - change ZMQ_THREAD_PRIORITY to support setting NICE of the background thread when using SCHED_OTHER
2017-10-16 13:29:03 +02:00
zmq_check_pthread_setaffinity ()
Problem: reading from /dev/urandom is clunky Solution: if available use the getrandom function as it doesn't require any synchronization, state or cleanup
2017-07-27 22:37:12 +02:00
zmq_check_getrandom ()
cmake: Disable runtime checks while cross compiling Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:32:29 +02:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if ( CMAKE_SYSTEM_NAME MATCHES "Linux"
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
OR CMAKE_SYSTEM_NAME MATCHES "GNU/kFreeBSD"
OR CMAKE_SYSTEM_NAME MATCHES "GNU/Hurd"
OR CYGWIN)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
add_definitions (-D_GNU_SOURCE)
elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
add_definitions (-D__BSD_VISIBLE)
elseif (CMAKE_SYSTEM_NAME MATCHES "NetBSD")
add_definitions (-D_NETBSD_SOURCE)
elseif (CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
add_definitions (-D_OPENBSD_SOURCE)
elseif (CMAKE_SYSTEM_NAME MATCHES "SunOS")
add_definitions (-D_PTHREADS)
elseif (CMAKE_SYSTEM_NAME MATCHES "HP-UX")
add_definitions (-D_POSIX_C_SOURCE=200112L)
zmq_check_cxx_flag_prepend (-Ae)
elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
add_definitions (-D_DARWIN_C_SOURCE)
endif ()
set (CMAKE_PYTHON_VERSION 2.7 2.6 2.5 2.4)
find_package (PythonInterp)
find_package (AsciiDoc)
cmake_dependent_option (WITH_DOC "Build Reference Guide documentation (requires DocBook)" ON
Problem: Broken documentation build Solution: The CMAKE module PythonInterp sets the variable PYTHONINTERP_FOUND and not PYTHON_FOUND if it finds a python interpreter.
2016-08-28 12:57:28 +02:00
"PYTHONINTERP_FOUND;ASCIIDOC_FOUND" OFF)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
if (WITH_OPENPGM)
# set (OPENPGM_ROOT "" CACHE PATH "Location of OpenPGM")
set (OPENPGM_VERSION_MAJOR 5)
set (OPENPGM_VERSION_MINOR 2)
set (OPENPGM_VERSION_MICRO 122)
if (CMAKE_CL_64)
find_path (OPENPGM_ROOT include/pgm/pgm.h
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
PATHS
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Miru\\OpenPGM ${OPENPGM_VERSION_MAJOR}.${OPENPGM_VERSION_MINOR}.${OPENPGM_VERSION_MICRO}]"
NO_DEFAULT_PATH
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
)
message (STATUS "OpenPGM x64 detected - ${OPENPGM_ROOT}")
else ()
find_path (OPENPGM_ROOT include/pgm/pgm.h
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
PATHS
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Miru\\OpenPGM ${OPENPGM_VERSION_MAJOR}.${OPENPGM_VERSION_MINOR}.${OPENPGM_VERSION_MICRO}]"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Miru\\OpenPGM ${OPENPGM_VERSION_MAJOR}.${OPENPGM_VERSION_MINOR}.${OPENPGM_VERSION_MICRO}]"
NO_DEFAULT_PATH
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
)
message (STATUS "OpenPGM x86 detected - ${OPENPGM_ROOT}")
endif (CMAKE_CL_64)
set (OPENPGM_INCLUDE_DIRS ${OPENPGM_ROOT}/include)
set (OPENPGM_LIBRARY_DIRS ${OPENPGM_ROOT}/lib)
set (OPENPGM_LIBRARIES
CMAKE_VS_PLATFORM_TOOLSET may not be set. E.g. for nmake.
2015-12-18 15:50:41 +01:00
optimized libpgm${MSVC_TOOLSET}-mt-${OPENPGM_VERSION_MAJOR}_${OPENPGM_VERSION_MINOR}_${OPENPGM_VERSION_MICRO}.lib
debug libpgm${MSVC_TOOLSET}-mt-gd-${OPENPGM_VERSION_MAJOR}_${OPENPGM_VERSION_MINOR}_${OPENPGM_VERSION_MICRO}.lib)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
else ()
if (WITH_OPENPGM)
Problem: CMake build rejects to build with openpgm enabled Solution: add optional lookup for openpgm via pkg-config
2016-11-01 12:31:40 +01:00
# message (FATAL_ERROR "WITH_OPENPGM not implemented")
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
Problem: CMake build rejects to build with openpgm enabled Solution: add optional lookup for openpgm via pkg-config
2016-11-01 12:31:40 +01:00
if (NOT OPENPGM_PKGCONFIG_NAME)
SET (OPENPGM_PKGCONFIG_NAME "openpgm-5.2")
endif(NOT OPENPGM_PKGCONFIG_NAME)
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
SET (OPENPGM_PKGCONFIG_NAME ${OPENPGM_PKGCONFIG_NAME} CACHE STRING
Problem: CMake build rejects to build with openpgm enabled Solution: add optional lookup for openpgm via pkg-config
2016-11-01 12:31:40 +01:00
"Name pkg-config shall use to find openpgm libraries and include paths"
FORCE )
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
Problem: CMake build rejects to build with openpgm enabled Solution: add optional lookup for openpgm via pkg-config
2016-11-01 12:31:40 +01:00
find_package(PkgConfig)
pkg_check_modules (OPENPGM ${OPENPGM_PKGCONFIG_NAME})
if (OPENPGM_FOUND)
message (STATUS ${OPENPGM_PKGCONFIG_NAME}" found")
else ()
message (FATAL_ERROR
${OPENPGM_PKGCONFIG_NAME}" not found. openpgm is searchd via `pkg-config ${OPENPGM_PKGCONFIG_NAME}`. Consider providing a valid OPENPGM_PKGCONFIG_NAME")
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
# DSO symbol visibility for openpgm
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (HAVE_FLAG_VISIBILITY_HIDDEN)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
elseif (HAVE_FLAG_LDSCOPE_HIDDEN)
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
endif ()
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# force off-tree build
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR})
message (FATAL_ERROR "CMake generation is not allowed within the source directory!
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Remove the CMakeCache.txt file and try again from another folder, e.g.:
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
rm CMakeCache.txt
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
mkdir cmake-make
cd cmake-make
cmake ..
")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# default to Release build
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-Set signaler_port to 0 which allows the OS to find a free port, rather than crashing if 5905 is in use (https://github.com/zeromq/libzmq/issues/1542) -Added config.hpp to the source list so it shows up in generated projects -Remove CMAKE_BUILD_TYPE setting for generators that don't use it
2015-08-21 05:45:59 +02:00
# CMAKE_BUILD_TYPE is not used for multi-configuration generators like Visual Studio/XCode
# which instead use CMAKE_CONFIGURATION_TYPES
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CMAKE_BUILD_TYPE Release CACHE STRING
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
"Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
FORCE)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
cmake: Streamline integration allowing config of CMAKE_*_OUTPUT_DIRECTORY Setting EXECUTABLE_OUTPUT_PATH and LIBRARY_OUTPUT_PATH variables is deprecated
2018-06-28 21:51:43 +02:00
#-----------------------------------------------------------------------------
# output directories
zmq_set_with_default(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${ZeroMQ_BINARY_DIR}/bin")
if(UNIX)
set(zmq_library_directory "lib")
else()
set(zmq_library_directory "bin")
endif()
zmq_set_with_default(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${ZeroMQ_BINARY_DIR}/${zmq_library_directory}")
zmq_set_with_default(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${ZeroMQ_BINARY_DIR}/lib")
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# platform specifics
mutualize win32 flags
2015-03-11 10:10:23 +01:00
if (WIN32)
Problem: socket limit is still 4K on Windows Solution: fix in CMakeLists.txt (already fixed in builds/msvc)
2016-02-12 16:30:55 +01:00
# Socket limit is 16K (can be raised arbitrarily)
add_definitions (-DFD_SETSIZE=16384)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
add_definitions (-D_CRT_SECURE_NO_WARNINGS)
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
mutualize win32 flags
2015-03-11 10:10:23 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
# Parallel make.
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
Problem: CMake parallel build not enabled for C files Solution: set the equivalent flag
2018-04-29 21:52:33 +02:00
set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP")
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
CMake: Linker PDB install rule does not work when Visual Studio generators are used (#3040) * Fixes issues with the PDB install rule for VS solutions * Fix for compile PDB and linker PDB under Windows
2018-04-04 11:48:36 +02:00
# Compile the static lib with debug information included
string (REGEX REPLACE "/Z." "/Z7" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
# Optimization flags.
# http://msdn.microsoft.com/en-us/magazine/cc301698.aspx
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT ${CMAKE_BUILD_TYPE} MATCHES "Debug")
set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GL")
set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LTCG")
set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /LTCG")
set (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /LTCG")
endif ()
endif ()
Enable parallel make and LTO by default.
2012-10-12 20:18:04 +02:00
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# source files
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (cxx-sources
Windows cmake build fixed
2017-01-06 10:52:20 +01:00
precompiled.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
address.cpp
fix jenkins build
2015-02-02 15:42:50 +01:00
client.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
clock.cpp
ctx.cpp
Problem: code duplication between curve_client_t and curve_server_t decode and encode Solution: extracted common base class curve_mechanism_base_t
2017-08-18 11:34:22 +02:00
curve_mechanism_base.cpp
Implement ZMTP/3.0 CURVE handshake
2013-06-18 23:38:24 +02:00
curve_client.cpp
curve_server.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
dealer.cpp
devpoll.cpp
Added dgram.cpp to CMakeLists.txt sources
2016-05-13 04:06:45 +02:00
dgram.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
dist.cpp
epoll.cpp
err.cpp
fq.cpp
io_object.cpp
io_thread.cpp
ip.cpp
ipc_address.cpp
ipc_connecter.cpp
ipc_listener.cpp
kqueue.cpp
lb.cpp
mailbox.cpp
thread safety - supporting windows
2015-02-12 15:56:14 +01:00
mailbox_safe.cpp
Port tests to windows and add to cmake build.
2013-08-17 14:43:45 +02:00
mechanism.cpp
Problem: code duplication between curve_client_t and curve_server_t decode and encode Solution: extracted common base class curve_mechanism_base_t
2017-08-18 11:34:22 +02:00
mechanism_base.cpp
add metadata
2014-05-01 21:35:53 +02:00
metadata.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
msg.cpp
mtrie.cpp
object.cpp
options.cpp
own.cpp
Port tests to windows and add to cmake build.
2013-08-17 14:43:45 +02:00
null_mechanism.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
pair.cpp
pgm_receiver.cpp
pgm_sender.cpp
pgm_socket.cpp
pipe.cpp
Update cmake for split of plain_mechanism
2014-05-12 09:51:13 +02:00
plain_client.cpp
plain_server.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
poll.cpp
poller_base.cpp
Problem: polling utilities not at a reusable location Solution: move to separate header
2018-06-01 16:10:19 +02:00
polling_util.cpp
replace tabs with space
2016-09-21 05:28:32 +02:00
pollset.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
proxy.cpp
pub.cpp
pull.cpp
push.cpp
random.cpp
raw_encoder.cpp
raw_decoder.cpp
reaper.cpp
rep.cpp
req.cpp
router.cpp
select.cpp
fix jenkins build
2015-02-02 15:42:50 +01:00
server.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
session_base.cpp
signaler.cpp
socket_base.cpp
Fix windows build
2014-06-23 14:10:43 +02:00
socks.cpp
socks_connecter.cpp
Fix cmake build Fix build on windows, uint isn't a standard type, unsigned int is.
2013-07-01 12:52:39 +02:00
stream.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
stream_engine.cpp
sub.cpp
tcp.cpp
tcp_address.cpp
tcp_connecter.cpp
tcp_listener.cpp
thread.cpp
trie.cpp
v1_decoder.cpp
v1_encoder.cpp
Updated CMake building to work after encoder/decoder changes.
2013-03-13 20:10:00 +01:00
v2_decoder.cpp
v2_encoder.cpp
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
xpub.cpp
xsub.cpp
zmq.cpp
"zero-copy" raw_decoder A memcpy is eliminated when receiving data on a ZMQ_STREAM socket. Instead of receiving into a static buffer and then copying the data into the buffer malloced in msg_t::init_size, the raw_decoder allocates the memory for together with the reference-counter and creates a msg_t object on top of that memory. This saves the memcpy operation. For small messages, data is still copied and the receive buffer is reused.
2015-06-14 19:00:52 +02:00
zmq_utils.cpp
-Set signaler_port to 0 which allows the OS to find a free port, rather than crashing if 5905 is in use (https://github.com/zeromq/libzmq/issues/1542) -Added config.hpp to the source list so it shows up in generated projects -Remove CMAKE_BUILD_TYPE setting for generators that don't use it
2015-08-21 05:45:59 +02:00
decoder_allocators.cpp
port zpoller to libzmq as zmq_poller
2015-10-18 20:07:23 +02:00
socket_poller.cpp
add timers API to libzmq
2015-12-18 11:12:18 +01:00
timers.cpp
radio-dish pattern
2016-01-27 17:19:14 +01:00
config.hpp
radio.cpp
make udp support for radio-dish
2016-01-29 20:17:11 +01:00
dish.cpp
udp_engine.cpp
Scatter-Gather socket types
2016-04-21 12:23:44 +02:00
udp_address.cpp
scatter.cpp
Problem: ZAP client code is duplicated in all mechanisms Solution: created a zap_client_t class, extracted first function send_zap_request from curve_server_t
2017-08-16 10:03:11 +02:00
gather.cpp
Problem: address parsing code is tied to the TCP code Solution: Factor the code into a different file with a well defined API and add unit tests.
2018-04-30 16:56:17 +02:00
ip_resolver.cpp
Problem: header files not included in VS project files Solution: add to list of sources
2018-02-13 08:56:13 +01:00
zap_client.cpp
# at least for VS, the header files must also be listed
address.hpp
array.hpp
atomic_counter.hpp
atomic_ptr.hpp
blob.hpp
client.hpp
clock.hpp
command.hpp
condition_variable.hpp
config.hpp
ctx.hpp
curve_client.hpp
curve_client_tools.hpp
curve_mechanism_base.hpp
curve_server.hpp
dbuffer.hpp
dealer.hpp
decoder.hpp
decoder_allocators.hpp
devpoll.hpp
dgram.hpp
dish.hpp
dist.hpp
encoder.hpp
epoll.hpp
err.hpp
fd.hpp
fq.hpp
gather.hpp
Problem: no unittests for mtrie Solution: made mtrie generic (to remove complex dependency on pipe_t), and added some unit tests
2018-02-15 13:09:04 +01:00
generic_mtrie.hpp
generic_mtrie_impl.hpp
Problem: header files not included in VS project files Solution: add to list of sources
2018-02-13 08:56:13 +01:00
gssapi_client.hpp
gssapi_mechanism_base.hpp
gssapi_server.hpp
i_decoder.hpp
i_encoder.hpp
i_engine.hpp
i_mailbox.hpp
i_poll_events.hpp
io_object.hpp
io_thread.hpp
ip.hpp
ipc_address.hpp
ipc_connecter.hpp
ipc_listener.hpp
kqueue.hpp
lb.hpp
likely.hpp
macros.hpp
mailbox.hpp
mailbox_safe.hpp
mechanism.hpp
mechanism_base.hpp
metadata.hpp
msg.hpp
mtrie.hpp
mutex.hpp
norm_engine.hpp
null_mechanism.hpp
object.hpp
options.hpp
own.hpp
pair.hpp
pgm_receiver.hpp
pgm_sender.hpp
pgm_socket.hpp
pipe.hpp
plain_client.hpp
Problem: magic numbers and data duplication in plain_*.cpp Solution: extract constants / move to plain_common.hpp
2018-05-28 16:41:44 +02:00
plain_common.hpp
Problem: header files not included in VS project files Solution: add to list of sources
2018-02-13 08:56:13 +01:00
plain_server.hpp
poll.hpp
poller.hpp
poller_base.hpp
Problem: polling utilities not at a reusable location Solution: move to separate header
2018-06-01 16:10:19 +02:00
polling_util.hpp
Problem: header files not included in VS project files Solution: add to list of sources
2018-02-13 08:56:13 +01:00
pollset.hpp
precompiled.hpp
proxy.hpp
pub.hpp
pull.hpp
push.hpp
radio.hpp
random.hpp
raw_decoder.hpp
raw_encoder.hpp
reaper.hpp
rep.hpp
req.hpp
router.hpp
scatter.hpp
select.hpp
server.hpp
session_base.hpp
signaler.hpp
socket_base.hpp
socket_poller.hpp
socks.hpp
socks_connecter.hpp
stdint.hpp
stream.hpp
stream_engine.hpp
sub.hpp
tcp.hpp
tcp_address.hpp
tcp_connecter.hpp
tcp_listener.hpp
thread.hpp
timers.hpp
tipc_address.hpp
tipc_connecter.hpp
tipc_listener.hpp
trie.hpp
udp_address.hpp
udp_engine.hpp
v1_decoder.hpp
v1_encoder.hpp
v2_decoder.hpp
v2_encoder.hpp
v2_protocol.hpp
vmci.hpp
vmci_address.hpp
vmci_connecter.hpp
vmci_listener.hpp
windows.hpp
wire.hpp
xpub.hpp
xsub.hpp
ypipe.hpp
ypipe_base.hpp
ypipe_conflate.hpp
yqueue.hpp
zap_client.hpp
)
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MINGW)
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
# Generate the right type when using -m32 or -m64
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
macro (set_rc_arch rc_target)
set (CMAKE_RC_COMPILER_INIT windres)
enable_language (RC)
set (CMAKE_RC_COMPILE_OBJECT
Fix issue #969
2014-04-13 15:25:22 +02:00
"<CMAKE_RC_COMPILER> <FLAGS> -O coff --target=${rc_target} <DEFINES> -i <SOURCE> -o <OBJECT>")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endmacro ()
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT CMAKE_SYSTEM_PROCESSOR)
set (CMAKE_SYSTEM_PROCESSOR ${CMAKE_HOST_SYSTEM_PROCESSOR})
fix use of CMAKE_SYSTEM_PROCESSOR
2013-10-23 20:22:20 +02:00
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if ( CMAKE_SYSTEM_PROCESSOR MATCHES "i386"
fix use of CMAKE_SYSTEM_PROCESSOR
2013-10-23 20:22:20 +02:00
OR CMAKE_SYSTEM_PROCESSOR MATCHES "i486"
OR CMAKE_SYSTEM_PROCESSOR MATCHES "i586"
OR CMAKE_SYSTEM_PROCESSOR MATCHES "i686"
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
# This also happens on x86_64 systems...what a worthless variable
fix use of CMAKE_SYSTEM_PROCESSOR
2013-10-23 20:22:20 +02:00
OR CMAKE_SYSTEM_PROCESSOR MATCHES "x86"
OR CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64"
OR CMAKE_SYSTEM_PROCESSOR MATCHES "amd64")
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_SIZEOF_VOID_P EQUAL 8)
set_rc_arch ("pe-x86-64")
else ()
set_rc_arch ("pe-i386")
endif ()
endif ()
endif ()
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Deprecate zmq_utils.h instead of removing it, which breaks downstream builds.
2016-02-18 10:27:21 +01:00
set (public_headers include/zmq.h
include/zmq_utils.h)
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (readme-docs AUTHORS
Fix MinGW32 build Fix link errors when using -m32 with MinGW
2013-01-02 03:04:19 +01:00
COPYING
COPYING.LESSER
README file moved to GitHub format and extension, drop from packaging and default to NEWS file for popup.
2013-07-14 19:26:55 +02:00
NEWS)
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# optional modules
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WITH_OPENPGM)
add_definitions (-DZMQ_HAVE_OPENPGM)
include_directories (${OPENPGM_INCLUDE_DIRS})
link_directories (${OPENPGM_LIBRARY_DIRS})
set (OPTIONAL_LIBRARIES ${OPENPGM_LIBRARIES})
endif (WITH_OPENPGM)
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WITH_VMCI)
add_definitions (-DZMQ_HAVE_VMCI)
include_directories (${VMCI_INCLUDE_DIRS})
list (APPEND cxx-sources vmci_address.cpp vmci_connecter.cpp vmci_listener.cpp vmci.cpp)
endif (WITH_VMCI)
Add the VMCI transport. VMCI transport allows fast communication between the Host and a virtual machine, between virtual machines on the same host, and within a virtual machine (like IPC). It requires VMware to be installed on the host and Guest Additions to be installed on a guest.
2015-12-07 13:19:45 +01:00
Problem: CMake does not check for TIPC support Solution: add macro in ZMQSourceRunChecks.cmake and optionally include the TIPC sources if the support is available. More importantly, only run the TIPC tests if the support is there.
2016-04-21 12:33:20 +02:00
if (ZMQ_HAVE_TIPC)
add_definitions (-DZMQ_HAVE_TIPC)
Problem: ZMQ_HAVE_TIPC option for CMake is broken Solution: Fix it - there was a typo in the source list variable; it should be 'cpp-sources' and not 'cpp-source'.
2016-05-04 17:12:27 +02:00
list (APPEND cxx-sources tipc_address.cpp tipc_connecter.cpp tipc_listener.cpp)
Problem: CMake does not check for TIPC support Solution: add macro in ZMQSourceRunChecks.cmake and optionally include the TIPC sources if the support is available. More importantly, only run the TIPC tests if the support is there.
2016-04-21 12:33:20 +02:00
endif (ZMQ_HAVE_TIPC)
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# source generators
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
foreach (source ${cxx-sources})
list (APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/src/${source})
endforeach ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: CMake rebuilds everything twice Solution: build all the objects separately before the link step, to avoid rebuilding when doing both static and shared builds
2017-11-18 14:46:49 +01:00
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/src/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
tweetnacl integration
2014-05-01 21:24:20 +02:00
Problem: cmake fails with #error None of the ZMQ_USE_* macros defined This happens if you first configure with autotools, and then run cmake. The problem is that the compiler finds the old src/platform.hpp before looking for the one generated by CMake. Further, there are a set of macros that configure passes via the command line, yet CMake passes via platform.hpp. (HAVE_xxx for pollers, at least.) This means you can't do a CMake build using the autotools platform.hpp. Solution: remove any src/platform.hpp when running cmake. This is a workaround. I'll fix the inconsistent macros separately.
2016-02-11 13:38:02 +01:00
# Delete any src/platform.hpp left by configure
file (REMOVE ${CMAKE_CURRENT_SOURCE_DIR}/src/platform.hpp)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/platform.hpp.in ${CMAKE_CURRENT_BINARY_DIR}/platform.hpp)
list (APPEND sources ${CMAKE_CURRENT_BINARY_DIR}/platform.hpp)
Fix NSIS installer errors, MinGW build. The CPack NSIS installer was in a state where it would always give a useless error. I think it was using stuff intended for running cpack separately from cmake.
2013-01-01 08:25:15 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/src/libzmq.pc.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/libzmq.pc @ONLY)
set (zmq-pkgconfig ${CMAKE_CURRENT_BINARY_DIR}/libzmq.pc)
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT ZMQ_BUILD_FRAMEWORK)
install (FILES ${CMAKE_CURRENT_BINARY_DIR}/libzmq.pc DESTINATION lib/pkgconfig)
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
if (CMAKE_CL_64)
set (nsis-template ${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/NSIS.template64.in)
else ()
set (nsis-template ${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/NSIS.template32.in)
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
add_custom_command (
Fix random 3 space tabs
2013-01-01 12:53:56 +01:00
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/NSIS.template.in
COMMAND ${CMAKE_COMMAND}
ARGS -E
copy
${nsis-template}
${CMAKE_CURRENT_BINARY_DIR}/NSIS.template.in
DEPENDS ${nsis-template})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
file (MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc)
file (GLOB docs RELATIVE ${CMAKE_CURRENT_BINARY_DIR}/ "${CMAKE_CURRENT_SOURCE_DIR}/doc/*.txt")
set (html-docs)
foreach (txt ${docs})
Problem: Documentation still has .txt suffix Solution: The regular expression replacement expected a non-existing space at the beginning of the input files.
2016-08-28 13:00:09 +02:00
string (REGEX REPLACE ".*/(.*)\\.txt" "\\1.html" html ${txt})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (src ${txt})
set (dst doc/${html})
if (WITH_DOC)
Fix WITH_DOC
2017-04-28 09:06:45 +02:00
add_custom_command (
OUTPUT ${dst}
COMMAND ${ASCIIDOC_EXECUTABLE}
-d manpage
-b xhtml11
-f ${CMAKE_CURRENT_SOURCE_DIR}/doc/asciidoc.conf
-azmq_version=${ZMQ_VERSION}
-o ${dst}
${src}
DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${src}
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
COMMENT "Generating ${html}")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
list (APPEND html-docs ${CMAKE_CURRENT_BINARY_DIR}/${dst})
endif ()
endforeach ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (ZMQ_BUILD_FRAMEWORK)
add_custom_command (
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
TARGET libzmq
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E make_directory "${CMAKE_LIBRARY_OUTPUT_PATH}/ZeroMQ.framework/Versions/${ZMQ_VERSION}/MacOS"
COMMENT "Perf tools")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
if (MSVC)
# default for all sources is to use precompiled headers
Problem: epoll not supported under Windows Solution: Use wepoll on Windows
2018-05-23 11:50:42 +02:00
foreach(source ${sources})
# C and C++ can not use the same precompiled header
if (${soruce} MATCHES ".cpp$" AND NOT ${source} STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}/src/precompiled.cpp")
Fix precompiled
2017-05-17 18:50:01 +02:00
set_source_files_properties(${source}
PROPERTIES
COMPILE_FLAGS "/Yuprecompiled.hpp"
OBJECT_DEPENDS precompiled.hpp
)
endif()
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
endforeach()
# create precompiled header
set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/src/precompiled.cpp
PROPERTIES
COMPILE_FLAGS "/Ycprecompiled.hpp"
Fix precompiled
2017-05-17 18:50:01 +02:00
OBJECT_OUTPUTS precompiled.hpp
Problem: CMakelist missing support for Windows Precompiled headers Solution: Add precompiled flags to CMakeList.txt for faster compiles + bonus - removed compilation warning on Windows by adding add_definitions (-D_WINSOCK_DEPRECATED_NO_WARNINGS)
2016-03-06 13:23:26 +01:00
)
endif ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
#-----------------------------------------------------------------------------
# output
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
option(BUILD_SHARED "Whether or not to build the shared object" ON)
option(BUILD_STATIC "Whether or not to build the static archive" ON)
list(APPEND target_outputs "")
if (BUILD_SHARED)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
list(APPEND target_outputs "libzmq")
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif()
if (BUILD_STATIC)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
list(APPEND target_outputs "libzmq-static")
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
Suppress linker warning 4221 for MSVC Some #define switches cause the body of entire files to be omitted. This causes a linker warning on Visual Studio 2017, for example warning LNK4221: This object file does not define any previously undefined public symbols, so it will not be used by any link operation that consumes this library Since this is warning us about something that shouldn't be earth-shattering news, we add a linker flag to suppress this warning on MSVC builds.
2017-05-20 20:22:29 +02:00
# Suppress linker warnings caused by #ifdef omission
# of file content.
set( CMAKE_STATIC_LINKER_FLAGS /ignore:4221 )
CMake: Linker PDB install rule does not work when Visual Studio generators are used (#3040) * Fixes issues with the PDB install rule for VS solutions * Fix for compile PDB and linker PDB under Windows
2018-04-04 11:48:36 +02:00
set (PDB_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
set (PDB_NAME "libzmq${MSVC_TOOLSET}-mt-gd-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}")
Problem: No static analysis under Windows Solution: Enable VS static analyzer and core guideline checks
2018-05-16 09:12:26 +02:00
function(enable_vs_guideline_checker target)
set_target_properties(${target} PROPERTIES
VS_GLOBAL_EnableCppCoreCheck true
VS_GLOBAL_CodeAnalysisRuleSet CppCoreCheckRules.ruleset
VS_GLOBAL_RunCodeAnalysis true)
endfunction()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (BUILD_SHARED)
Problem: static build broken on Win + CMake Solution: revert the objects optimisation, and go back to building everything twice on Windows, as the static builds needs different preprocessor definitions from the shared one, so the objects have to be rebuilt. Keep the optimisation for all the other platforms. Fixes #2858
2017-12-10 18:41:02 +01:00
add_library (libzmq SHARED ${sources} ${public_headers} ${html-docs} ${readme-docs} ${CMAKE_CURRENT_BINARY_DIR}/NSIS.template.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
Problem: No static analysis under Windows Solution: Enable VS static analyzer and core guideline checks
2018-05-16 09:12:26 +02:00
if(ENABLE_ANALYSIS)
enable_vs_guideline_checker (libzmq)
endif()
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
set_target_properties (libzmq PROPERTIES
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
PUBLIC_HEADER "${public_headers}"
RELEASE_POSTFIX "${MSVC_TOOLSET}-mt-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
RELWITHDEBINFO_POSTFIX "${MSVC_TOOLSET}-mt-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
Ensure correct cmake target suffix for all builds This updates the cmake set_target_properperties usage, so that the suffix is specified for the MinSizeRel build type.
2016-11-16 16:28:18 +01:00
MINSIZEREL_POSTFIX "${MSVC_TOOLSET}-mt-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
DEBUG_POSTFIX "${MSVC_TOOLSET}-mt-gd-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
cmake: Fix .dll file location in the build tree This commit ensures that the variable CMAKE_*_OUTPUT_DIRECTORY are considered when creating the library.
2018-06-30 07:27:08 +02:00
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
COMPILE_DEFINITIONS "DLL_EXPORT"
OUTPUT_NAME "libzmq")
endif()
Fix CMake tests on Windows (#2872) * Changed CMake tests to use check_symbol_exists in network-related libraries on win32 instead of check_library_exists
2018-01-09 18:15:24 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (BUILD_STATIC)
Problem: static build broken on Win + CMake Solution: revert the objects optimisation, and go back to building everything twice on Windows, as the static builds needs different preprocessor definitions from the shared one, so the objects have to be rebuilt. Keep the optimisation for all the other platforms. Fixes #2858
2017-12-10 18:41:02 +01:00
add_library (libzmq-static STATIC ${sources} ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
set_target_properties (libzmq-static PROPERTIES
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
PUBLIC_HEADER "${public_headers}"
RELEASE_POSTFIX "${MSVC_TOOLSET}-mt-s-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
RELWITHDEBINFO_POSTFIX "${MSVC_TOOLSET}-mt-s-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
Ensure correct cmake target suffix for all builds This updates the cmake set_target_properperties usage, so that the suffix is specified for the MinSizeRel build type.
2016-11-16 16:28:18 +01:00
MINSIZEREL_POSTFIX "${MSVC_TOOLSET}-mt-s-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
DEBUG_POSTFIX "${MSVC_TOOLSET}-mt-sgd-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
COMPILE_FLAGS "/DZMQ_STATIC"
OUTPUT_NAME "libzmq")
endif()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
else ()
Problem: static build broken on Win + CMake Solution: revert the objects optimisation, and go back to building everything twice on Windows, as the static builds needs different preprocessor definitions from the shared one, so the objects have to be rebuilt. Keep the optimisation for all the other platforms. Fixes #2858
2017-12-10 18:41:02 +01:00
# avoid building everything twice for shared + static
# only on *nix, as Windows needs different preprocessor defines in static builds
Problem: mingw static/shared builds have different preprocessor defines Solution: remove objects optimisation in library build (similar to #2860) and set PUBLIC compile definitions on all static builds instead of MSVC only.
2018-03-12 10:20:02 +01:00
if (NOT MINGW)
add_library (objects OBJECT ${sources})
set_property(TARGET objects PROPERTY POSITION_INDEPENDENT_CODE ON)
target_include_directories (objects
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
$<INSTALL_INTERFACE:include>
)
endif ()
Problem: static build broken on Win + CMake Solution: revert the objects optimisation, and go back to building everything twice on Windows, as the static builds needs different preprocessor definitions from the shared one, so the objects have to be rebuilt. Keep the optimisation for all the other platforms. Fixes #2858
2017-12-10 18:41:02 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (BUILD_SHARED)
Problem: mingw static/shared builds have different preprocessor defines Solution: remove objects optimisation in library build (similar to #2860) and set PUBLIC compile definitions on all static builds instead of MSVC only.
2018-03-12 10:20:02 +01:00
if (MINGW)
add_library (libzmq SHARED ${sources} ${public_headers} ${html-docs} ${readme-docs} ${zmq-pkgconfig} ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
else ()
add_library (libzmq SHARED $<TARGET_OBJECTS:objects> ${public_headers} ${html-docs} ${readme-docs} ${zmq-pkgconfig} ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
endif ()
[cmake] fix SOVERSION
2018-01-13 09:31:04 +01:00
# NOTE: the SOVERSION and VERSION MUST be the same as the one generated by libtool! It is NOT the same as the version of the package.
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
set_target_properties (libzmq PROPERTIES
set soversion without ZMQ_BUILD_FRAMEWORK
2015-03-11 10:15:40 +01:00
COMPILE_DEFINITIONS "DLL_EXPORT"
PUBLIC_HEADER "${public_headers}"
Problem: 4.2.5 is out, we need to restore API changes and 4.3.x Solution: revert the revert! Revert "Problem: regression in 4.2.3 went unnoticed, want to release 4.2.5" This reverts commit 5f17e26fa4c60c3de0282d1b6ad1e8b7037ed57a.
2018-03-23 20:28:26 +01:00
VERSION "5.1.6"
[cmake] fix SOVERSION
2018-01-13 09:31:04 +01:00
SOVERSION "5"
Fix windows compilation
2017-04-05 18:46:48 +02:00
OUTPUT_NAME "zmq"
PREFIX "lib")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (ZMQ_BUILD_FRAMEWORK)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
set_target_properties (libzmq PROPERTIES
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
FRAMEWORK TRUE
MACOSX_FRAMEWORK_IDENTIFIER "org.zeromq.libzmq"
MACOSX_FRAMEWORK_SHORT_VERSION_STRING ${ZMQ_VERSION}
set soversion without ZMQ_BUILD_FRAMEWORK
2015-03-11 10:15:40 +01:00
MACOSX_FRAMEWORK_BUNDLE_VERSION ${ZMQ_VERSION})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set_source_files_properties (${html-docs} PROPERTIES
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
MACOSX_PACKAGE_LOCATION doc)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set_source_files_properties (${readme-docs} PROPERTIES
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
MACOSX_PACKAGE_LOCATION etc)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set_source_files_properties (${zmq-pkgconfig} PROPERTIES
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
MACOSX_PACKAGE_LOCATION lib/pkgconfig)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif()
if (BUILD_STATIC)
Problem: mingw static/shared builds have different preprocessor defines Solution: remove objects optimisation in library build (similar to #2860) and set PUBLIC compile definitions on all static builds instead of MSVC only.
2018-03-12 10:20:02 +01:00
if (MINGW)
add_library (libzmq-static STATIC ${sources} ${public_headers} ${html-docs} ${readme-docs} ${zmq-pkgconfig} ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
else ()
add_library (libzmq-static STATIC $<TARGET_OBJECTS:objects> ${public_headers} ${html-docs} ${readme-docs} ${zmq-pkgconfig} ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
endif ()
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
set_target_properties (libzmq-static PROPERTIES
Add static compilation on CMake
2014-07-02 21:51:34 +02:00
PUBLIC_HEADER "${public_headers}"
Fix windows compilation
2017-04-05 18:46:48 +02:00
OUTPUT_NAME "zmq"
PREFIX "lib")
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif()
Problem: static build broken on Win + CMake Solution: revert the objects optimisation, and go back to building everything twice on Windows, as the static builds needs different preprocessor definitions from the shared one, so the objects have to be rebuilt. Keep the optimisation for all the other platforms. Fixes #2858
2017-12-10 18:41:02 +01:00
Problem: mingw static/shared builds have different preprocessor defines Solution: remove objects optimisation in library build (similar to #2860) and set PUBLIC compile definitions on all static builds instead of MSVC only.
2018-03-12 10:20:02 +01:00
endif ()
if (BUILD_STATIC)
target_compile_definitions(libzmq-static
PUBLIC ZMQ_STATIC
Problem: static build broken on Win + CMake Solution: revert the objects optimisation, and go back to building everything twice on Windows, as the static builds needs different preprocessor definitions from the shared one, so the objects have to be rebuilt. Keep the optimisation for all the other platforms. Fixes #2858
2017-12-10 18:41:02 +01:00
)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: static build broken on Win + CMake Solution: revert the objects optimisation, and go back to building everything twice on Windows, as the static builds needs different preprocessor definitions from the shared one, so the objects have to be rebuilt. Keep the optimisation for all the other platforms. Fixes #2858
2017-12-10 18:41:02 +01:00
foreach (target ${target_outputs})
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
target_include_directories (${target}
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
$<INSTALL_INTERFACE:include>
)
endforeach()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (BUILD_SHARED)
linkage is now homogeneous for both targets libzmq and libzmq-static all calls to target_link_libraries are now at the same location
2018-01-15 00:36:02 +01:00
target_link_libraries (libzmq ${OPTIONAL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
CMake: Linker PDB install rule does not work when Visual Studio generators are used (#3040) * Fixes issues with the PDB install rule for VS solutions * Fix for compile PDB and linker PDB under Windows
2018-04-04 11:48:36 +02:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (SODIUM_FOUND)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq ${SODIUM_LIBRARIES})
linkage is now homogeneous for both targets libzmq and libzmq-static all calls to target_link_libraries are now at the same location
2018-01-15 00:36:02 +01:00
# On Solaris, libsodium depends on libssp
if (${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
target_link_libraries (libzmq ssp)
endif ()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
CMake: Linker PDB install rule does not work when Visual Studio generators are used (#3040) * Fixes issues with the PDB install rule for VS solutions * Fix for compile PDB and linker PDB under Windows
2018-04-04 11:48:36 +02:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (HAVE_WS2_32)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq ws2_32)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
elseif (HAVE_WS2)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq ws2)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (HAVE_RPCRT4)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq rpcrt4)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
add linking to librt under cmake build - fixes missing symbol The libzmq library itself uses clock_gettime and should link w/ -lrt on linux. Caught this issue on on Ubuntu 12.04 LTS.
2014-02-24 20:07:28 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (HAVE_IPHLAPI)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
target_link_libraries (libzmq iphlpapi)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (RT_LIBRARY)
removing hard-coded path of librt
2018-01-10 21:07:25 +01:00
target_link_libraries (libzmq -lrt)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Make CMake option for perf-tools This allow disable making perf-tools in Release build type Signed-off-by: Anton Sergeev <Anton.Sergeev@elecard.ru>
2015-05-06 17:25:26 +02:00
linkage is now homogeneous for both targets libzmq and libzmq-static all calls to target_link_libraries are now at the same location
2018-01-15 00:36:02 +01:00
if (BUILD_STATIC)
target_link_libraries (libzmq-static ${OPTIONAL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
CMake: Linker PDB install rule does not work when Visual Studio generators are used (#3040) * Fixes issues with the PDB install rule for VS solutions * Fix for compile PDB and linker PDB under Windows
2018-04-04 11:48:36 +02:00
linkage is now homogeneous for both targets libzmq and libzmq-static all calls to target_link_libraries are now at the same location
2018-01-15 00:36:02 +01:00
if (SODIUM_FOUND)
target_link_libraries (libzmq-static ${SODIUM_LIBRARIES})
# On Solaris, libsodium depends on libssp
if (${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
target_link_libraries (libzmq-static ssp)
endif ()
endif ()
CMake: Linker PDB install rule does not work when Visual Studio generators are used (#3040) * Fixes issues with the PDB install rule for VS solutions * Fix for compile PDB and linker PDB under Windows
2018-04-04 11:48:36 +02:00
linkage is now homogeneous for both targets libzmq and libzmq-static all calls to target_link_libraries are now at the same location
2018-01-15 00:36:02 +01:00
if (HAVE_WS2_32)
target_link_libraries (libzmq-static ws2_32)
elseif (HAVE_WS2)
target_link_libraries (libzmq-static ws2)
endif ()
if (HAVE_RPCRT4)
target_link_libraries (libzmq-static rpcrt4)
endif ()
if (HAVE_IPHLAPI)
target_link_libraries (libzmq-static iphlpapi)
endif ()
if (RT_LIBRARY)
target_link_libraries (libzmq-static -lrt)
endif ()
endif ()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (BUILD_SHARED)
set (perf-tools local_lat
remote_lat
local_thr
remote_thr
inproc_lat
inproc_thr)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug") # Why?
option (WITH_PERF_TOOL "Build with perf-tools" ON)
else ()
option (WITH_PERF_TOOL "Build with perf-tools" OFF)
endif ()
Fix cmake not linking librt to perf-tools
2013-01-23 20:31:02 +01:00
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (WITH_PERF_TOOL)
foreach (perf-tool ${perf-tools})
add_executable (${perf-tool} perf/${perf-tool}.cpp)
linkage is now homogeneous for both targets libzmq and libzmq-static all calls to target_link_libraries are now at the same location
2018-01-15 00:36:02 +01:00
target_link_libraries (${perf-tool} libzmq)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
if (ZMQ_BUILD_FRAMEWORK)
# Copy perf-tools binaries into Framework
add_custom_command (
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
TARGET libzmq ${perf-tool}
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
POST_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy "$<TARGET_FILE:${perf-tool}>" "${LIBRARY_OUTPUT_PATH}/ZeroMQ.framework/Versions/${ZMQ_VERSION_STRING}/MacOS/${perf-tool}"
VERBATIM
COMMENT "Perf tools")
else ()
install (TARGETS ${perf-tool}
RUNTIME DESTINATION bin
COMPONENT PerfTools)
endif ()
endforeach ()
endif ()
elseif (WITH_PERF_TOOL)
message(FATAL_ERROR "Shared library disabled - perf-tools unavailable.")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Added ZMQ_BUILD_TESTS to CMakeLists.txt to allow turning off tests. Useful when building ZMQ as a git submodule.
2014-02-07 17:50:45 +01:00
#-----------------------------------------------------------------------------
# tests
Add cmake build option for disabling tests This adds a new cmake build option called BUILD_TESTS, that can be used to enable/disable building of the tests. This is enabled by default.
2018-02-14 13:58:58 +01:00
option(BUILD_TESTS "Whether or not to build the tests" ON)
set (ZMQ_BUILD_TESTS ${BUILD_TESTS} CACHE BOOL "Build the tests for ZeroMQ")
Added ZMQ_BUILD_TESTS to CMakeLists.txt to allow turning off tests. Useful when building ZMQ as a git submodule.
2014-02-07 17:50:45 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (ZMQ_BUILD_TESTS)
enable_testing () # Enable testing only works in root scope
ADD_SUBDIRECTORY (tests)
Problem: no unit tests Solution: set up initial unit tests
2018-02-08 17:48:15 +01:00
if (BUILD_STATIC)
add_subdirectory (unittests)
else ()
message (WARNING "Not building unit tests, since BUILD_STATIC is not enabled")
endif ()
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Add support for extending ZAP request address with IPC peer credentials. Another take on LIBZMQ-568 to allow filtering IPC connections, this time using ZAP. This change is backward compatible. If the ZMQ_ZAP_IPC_CREDS option is set, the user, group, and process IDs of the peer process are appended to the address (separated by colons) of a ZAP request; otherwise, nothing changes. See LIBZMQ-568 and zmq_setsockopt documentation for more information.
2013-12-06 23:28:44 +01:00
Bring along CMake patchset from zeromq3-x for adding minor version to Windows labeling.
2012-11-09 14:48:59 +01:00
#-----------------------------------------------------------------------------
# installer
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC)
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
install (TARGETS ${target_outputs}
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
EXPORT ${PROJECT_NAME}-targets
cmake install config file
2017-01-06 22:41:29 +01:00
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
Fixes missing IMPORTED_LOCATION in import-target
2018-03-12 13:38:46 +01:00
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
cmake install config file
2017-01-06 22:41:29 +01:00
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
COMPONENT SDK)
CMake: Linker PDB install rule does not work when Visual Studio generators are used (#3040) * Fixes issues with the PDB install rule for VS solutions * Fix for compile PDB and linker PDB under Windows
2018-04-04 11:48:36 +02:00
if (MSVC_IDE)
install (FILES ${PDB_OUTPUT_DIRECTORY}/\${CMAKE_INSTALL_CONFIG_NAME}/${PDB_NAME}.pdb DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT SDK OPTIONAL)
else()
install (FILES ${PDB_OUTPUT_DIRECTORY}/${PDB_NAME}.pdb DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT SDK OPTIONAL)
endif()
if (BUILD_SHARED)
Targets broken by some parts of f7d1c159d4f96686ce994319280c1bd3a2eab994
2017-04-24 15:57:14 +02:00
install (TARGETS libzmq
cmake install config file
2017-01-06 22:41:29 +01:00
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
COMPONENT Runtime)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
else ()
Add CMake Build Output Options Add two new options to CMakeLists.txt: `BUILD_SHARED` - Whether or not to build the shared object (Default: ON) `BUILD_STATIC` - Whether or not to build the static archive (Default: ON)
2017-04-18 00:26:04 +02:00
install (TARGETS ${target_outputs}
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
EXPORT ${PROJECT_NAME}-targets
cmake install config file
2017-01-06 22:41:29 +01:00
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
FRAMEWORK DESTINATION "Library/Frameworks"
cmake install config file
2017-01-06 22:41:29 +01:00
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
# install (FILES ${public_headers}
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# DESTINATION include
# COMPONENT SDK)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
#if (NOT ZMQ_BUILD_FRAMEWORK)
# file (GLOB private_headers "${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp")
# install (FILES ${sources} ${private_headers} DESTINATION src/zmq
do not install sources
2015-03-11 09:50:39 +01:00
# COMPONENT SourceCode)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
#endif ()
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
foreach (readme ${readme-docs})
configure_file (${CMAKE_CURRENT_SOURCE_DIR}/${readme} ${CMAKE_CURRENT_BINARY_DIR}/${readme}.txt)
First pass at getting cmake build to work with non-Windows systems. Make doc building option dependent on asciidoc being installed Fix MSVC build requiring cygwin. Don't use try_run to get the version
2012-12-31 23:52:32 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (NOT ZMQ_BUILD_FRAMEWORK)
CPack option and .txt files installation dir
2017-01-06 14:29:56 +01:00
install (FILES ${CMAKE_CURRENT_BINARY_DIR}/${readme}.txt DESTINATION share/zmq)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
endforeach ()
added artificacts for windows and openpgm build
2012-10-11 12:31:30 +02:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WITH_DOC)
if (NOT ZMQ_BUILD_FRAMEWORK)
install (FILES ${html-docs} DESTINATION doc/zmq COMPONENT RefGuide)
endif ()
endif ()
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
cmake install config file
2017-01-06 22:41:29 +01:00
include(CMakePackageConfigHelpers)
Problem: WIN32 CMAKECONFIG_INSTALL_DIR is broken Solution: set it to CMake instead of a subfolder of share. See cmake find_package documentation for further info.
2017-12-06 21:41:55 +01:00
if (WIN32)
set(ZEROMQ_CMAKECONFIG_INSTALL_DIR "CMake" CACHE STRING "install path for ZeroMQConfig.cmake")
else()
# GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
set(ZEROMQ_CMAKECONFIG_INSTALL_DIR "share/cmake/${PROJECT_NAME}" CACHE STRING "install path for ZeroMQConfig.cmake")
endif()
cmake install config file
2017-01-06 22:41:29 +01:00
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
if (NOT CMAKE_VERSION VERSION_LESS 3.0)
export(EXPORT ${PROJECT_NAME}-targets
FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake")
endif()
move cmake ZeroMQConfig.cmake.in to builds/cmake
2018-01-12 23:17:15 +01:00
configure_package_config_file(builds/cmake/${PROJECT_NAME}Config.cmake.in
cmake install config file
2017-01-06 22:41:29 +01:00
"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
INSTALL_DESTINATION ${ZEROMQ_CMAKECONFIG_INSTALL_DIR})
write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
VERSION ${ZMQ_VERSION_MAJOR}.${ZMQ_VERSION_MINOR}.${ZMQ_VERSION_PATCH}
COMPATIBILITY AnyNewerVersion)
cmake: Export targets to package config Signed-off-by: Stefan Herbrechtsmeier <stefan.herbrechtsmeier@weidmueller.com>
2017-04-04 10:34:28 +02:00
install(EXPORT ${PROJECT_NAME}-targets
FILE ${PROJECT_NAME}Targets.cmake
DESTINATION ${ZEROMQ_CMAKECONFIG_INSTALL_DIR})
cmake install config file
2017-01-06 22:41:29 +01:00
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
DESTINATION ${ZEROMQ_CMAKECONFIG_INSTALL_DIR})
CPack option and .txt files installation dir
2017-01-06 14:29:56 +01:00
option(ENABLE_CPACK "Enables cpack rules" ON)
if (MSVC AND ENABLE_CPACK)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
include (InstallRequiredSystemLibraries)
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (CMAKE_CL_64)
set (arch_name "x64")
else ()
set (arch_name "x86")
endif ()
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CPACK_NSIS_DISPLAY_NAME "ZeroMQ ${ZMQ_VERSION_MAJOR}.${ZMQ_VERSION_MINOR}.${ZMQ_VERSION_PATCH} (${arch_name})")
set (CPACK_PACKAGE_FILE_NAME "ZeroMQ-${ZMQ_VERSION_MAJOR}.${ZMQ_VERSION_MINOR}.${ZMQ_VERSION_PATCH}-${arch_name}")
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# TODO: I think this part was intended to be used when running cpack
# separately from cmake but I don't know how that works.
#
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
# macro (add_crt_version version)
# set (rel_dir "${CMAKE_CURRENT_BINARY_DIR}/build/${arch_name}/${version};ZeroMQ;ALL;/")
# set (debug_dir "${CMAKE_CURRENT_BINARY_DIR}/debug/${arch_name}/${version};ZeroMQ;ALL;/")
# if (EXISTS ${rel_dir})
# list (APPEND CPACK_INSTALL_CMAKE_PROJECTS ${rel_dir})
# endif ()
# if (EXISTS ${debug_dir})
# list (APPEND CPACK_INSTALL_CMAKE_PROJECTS ${rel_dir})
# endmacro ()
# endmacro ()
# add_crt_version (v110)
# add_crt_version (v100)
# add_crt_version (v90)
Problem: cmake broken under Windows Solution: fix CMAKE_MODULES_PATH
2018-02-02 13:52:51 +01:00
list (APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_BINARY_DIR})
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (CPACK_GENERATOR "NSIS")
set (CPACK_PACKAGE_NAME "ZeroMQ")
set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "ZeroMQ lightweight messaging kernel")
set (CPACK_PACKAGE_VENDOR "Miru")
set (CPACK_NSIS_CONTACT "Steven McCoy <Steven.McCoy@miru.hk>")
set (CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_BINARY_DIR}\\\\COPYING.txt")
# set (CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_BINARY_DIR}\\\\README.txt")
# set (CPACK_RESOURCE_FILE_WELCOME "${CMAKE_CURRENT_BINARY_DIR}\\\\WELCOME.txt")
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# There is a bug in NSI that does not handle full unix paths properly. Make
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
# sure there is at least one set of four (4) backslashes.
set (CPACK_NSIS_MUI_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\installer.ico")
set (CPACK_NSIS_MUI_UNIICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\installer.ico")
set (CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\branding.bmp")
set (CPACK_NSIS_COMPRESSOR "/SOLID lzma")
set (CPACK_PACKAGE_VERSION ${ZMQ_VERSION})
set (CPACK_PACKAGE_VERSION_MAJOR ${ZMQ_VERSION_MAJOR})
set (CPACK_PACKAGE_VERSION_MINOR ${ZMQ_VERSION_MINOR})
set (CPACK_PACKAGE_VERSION_PATCH ${ZMQ_VERSION_PATCH})
# set (CPACK_PACKAGE_INSTALL_DIRECTORY "ZMQ Install Directory")
# set (CPACK_TEMPORARY_DIRECTORY "ZMQ Temporary CPack Directory")
include (CPack)
cpack_add_component_group (Development
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ software development kit"
EXPANDED)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_component (PerfTools
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ performance tools"
INSTALL_TYPES FullInstall DevInstall)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_component (SourceCode
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ source code"
DISABLED
INSTALL_TYPES FullInstall)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_component (SDK
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ headers and libraries"
INSTALL_TYPES FullInstall DevInstall
GROUP Development)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (WITH_DOC)
cpack_add_component (RefGuide
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ reference guide"
INSTALL_TYPES FullInstall DevInstall
GROUP Development)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
cpack_add_component (Runtime
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "ZeroMQ runtime files"
REQUIRED
INSTALL_TYPES FullInstall DevInstall MinInstall)
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_install_type (FullInstall
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "Full install, including source code")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_install_type (DevInstall
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "Developer install, headers and libraries")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
cpack_add_install_type (MinInstall
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
DISPLAY_NAME "Minimal install, runtime only")
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
endif ()
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# Export this for library to help build this as a sub-project
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
set (ZEROMQ_LIBRARY libzmq CACHE STRING "ZeroMQ library")
Revert "Bzimmerman cmake"
2015-02-12 20:29:09 +01:00
# Workaround for MSVS10 to avoid the Dialog Hell
# FIXME: This could be removed with future version of CMake.
Problem: use of libsodium vs. tweetnacl is confused It's unclear which we need and in the source code, conditional code treats tweetnacl as a subclass of libsodium, which is inaccurate. Solution: redesign the configure/cmake API for this: * tweetnacl is present by default and cannot be enabled * libsodium can be enabled using --with-libsodium, which replaces the built-in tweetnacl * CURVE encryption can be disabled entirely using --enable-curve=no The macros we define in platform.hpp are: ZMQ_HAVE_CURVE 1 // When CURVE is enabled HAVE_LIBSODIUM 1 // When we are using libsodium HAVE_TWEETNACL 1 // When we're using tweetnacl (default) As of this patch, the default build of libzmq always has CURVE security, and always uses tweetnacl.
2016-02-11 13:32:01 +01:00
if (MSVC_VERSION EQUAL 1600)
set (ZMQ_SLN_FILENAME "${CMAKE_CURRENT_BINARY_DIR}/ZeroMQ.sln")
if (EXISTS "${ZMQ_SLN_FILENAME}")
file (APPEND "${ZMQ_SLN_FILENAME}" "\n# This should be regenerated!\n")
endif ()
endif ()
Problem: clang-format not run on CI Solution: add clang-format to cmake, and add another travis-ci build type
2018-02-01 14:18:02 +01:00
include(ClangFormat)
Reference in New Issue Copy Permalink