/CMakeLists.txt

http://github.com/zeromq/libzmq · CMake · 1735 lines · 1432 code · 198 blank · 105 comment · 204 complexity · 1b319c539b8c568b2391c541ab959c3d MD5 · raw file

Large files are truncated click here to view the full file

    

  1. # CMake build script for ZeroMQ
    2. 

  2. project(ZeroMQ)
    3. 

  3. 

  4. if(${CMAKE_SYSTEM_NAME} STREQUAL Darwin)
    5. 

  5.   cmake_minimum_required(VERSION 3.0.2)
    6. 

  6. else()
    7. 

  7.   cmake_minimum_required(VERSION 2.8.12)
    8. 

  8. endif()
    9. 

  9. 

  10. include(CheckIncludeFiles)
    11. 

  11. include(CheckCCompilerFlag)
    12. 

  12. include(CheckCXXCompilerFlag)
    13. 

  13. include(CheckLibraryExists)
    14. 

  14. include(CheckCSourceCompiles)
    15. 

  15. include(CheckCSourceRuns)
    16. 

  16. include(CMakeDependentOption)
    17. 

  17. include(CheckCXXSymbolExists)
    18. 

  18. include(CheckTypeSize)
    19. 

  19. include(FindThreads)
    20. 

  20. include(GNUInstallDirs)
    21. 

  21. include(CheckTypeSize)
    22. 

  22. include(CMakePackageConfigHelpers)
    23. 

  23. 

  24. list(INSERT CMAKE_MODULE_PATH 0 "${CMAKE_CURRENT_SOURCE_DIR}")
    25. 

  25. set(ZMQ_CMAKE_MODULES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/Modules)
    26. 

  26. list(APPEND CMAKE_MODULE_PATH ${ZMQ_CMAKE_MODULES_DIR})
    27. 

  27. 

  28. include(TestZMQVersion)
    29. 

  29. include(ZMQSourceRunChecks)
    30. 

  30. include(ZMQSupportMacros)
    31. 

  31. 

  32. find_package(PkgConfig)
    33. 

  33. 

  34. option(ENABLE_ASAN "Build with address sanitizer" OFF)
    35. 

  35. if(ENABLE_ASAN)
    36. 

  36.   message(STATUS "Instrumenting with Address Sanitizer")
    37. 

  37.   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fsanitize-address-use-after-scope -fno-omit-frame-pointer")
    38. 

  38.   set(CMAKE_CXX_FLAGS
    39. 

  39.       "${CMAKE_CXX_FLAGS} -fsanitize=address -fsanitize-address-use-after-scope -fno-omit-frame-pointer")
    40. 

  40.   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address -fsanitize-address-use-after-scope")
    41. 

  41.   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address -fsanitize-address-use-after-scope")
    42. 

  42. endif()
    43. 

  43. 

  44. option(ENABLE_INTRINSICS "Build using compiler intrinsics for atomic ops" OFF)
    45. 

  45. if(ENABLE_INTRINSICS)
    46. 

  46.   message(STATUS "Using compiler intrinsics for atomic ops")
    47. 

  47.   add_definitions(-DZMQ_HAVE_ATOMIC_INTRINSICS)
    48. 

  48. endif()
    49. 

  49. 

  50. set(ZMQ_OUTPUT_BASENAME
    51. 

  51.     "zmq"
    52. 

  52.     CACHE STRING "Output zmq library base name")
    53. 

  53. 

  54. if(${CMAKE_SYSTEM_NAME} STREQUAL Darwin)
    55. 

  55.   # Find more information: https://cmake.org/Wiki/CMake_RPATH_handling
    56. 

  56. 

  57.   # Apply CMP0042: MACOSX_RPATH is enabled by default
    58. 

  58.   cmake_policy(SET CMP0042 NEW)
    59. 

  59. 

  60.   # Add an install rpath if it is not a system directory
    61. 

  61.   list(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}" isSystemDir)
    62. 

  62.   if("${isSystemDir}" STREQUAL "-1")
    63. 

  63.     set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
    64. 

  64.   endif()
    65. 

  65. 

  66.   # Add linker search paths pointing to external dependencies
    67. 

  67.   set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
    68. 

  68. endif()
    69. 

  69. 

  70. if (NOT MSVC)
    71. 

  71.   check_cxx_compiler_flag("-std=gnu++11" COMPILER_SUPPORTS_CXX11)
    72. 

  72.   if(COMPILER_SUPPORTS_CXX11)
    73. 

  73.     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")
    74. 

  74.   endif()
    75. 

  75.   check_c_compiler_flag("-std=gnu11" COMPILER_SUPPORTS_C11)
    76. 

  76.   if(COMPILER_SUPPORTS_C11)
    77. 

  77.     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu11")
    78. 

  78.   else()
    79. 

  79.     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99")
    80. 

  80.   endif()
    81. 

  81. 

  82.   # clang 6 has a warning that does not make sense on multi-platform code
    83. 

  83.   check_cxx_compiler_flag("-Wno-tautological-constant-compare" CXX_HAS_TAUT_WARNING)
    84. 

  84.   if(CXX_HAS_TAUT_WARNING)
    85. 

  85.     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-tautological-constant-compare")
    86. 

  86.   endif()
    87. 

  87.   check_c_compiler_flag("-Wno-tautological-constant-compare" CC_HAS_TAUT_WARNING)
    88. 

  88.   if(CC_HAS_TAUT_WARNING)
    89. 

  89.     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-tautological-constant-compare")
    90. 

  90.   endif()
    91. 

  91. endif()
    92. 

  92. 

  93. # Will be used to add flags to pkg-config useful when apps want to statically link
    94. 

  94. set(pkg_config_libs_private "")
    95. 

  95. set(pkg_config_names_private "")
    96. 

  96. 

  97. option(WITH_OPENPGM "Build with support for OpenPGM" OFF)
    98. 

  98. option(WITH_VMCI "Build with support for VMware VMCI socket" OFF)
    99. 

  99. 

  100. if(APPLE)
    101. 

  101.   option(ZMQ_BUILD_FRAMEWORK "Build as OS X framework" OFF)
    102. 

  102. endif()
    103. 

  103. 

  104. if(EXISTS "${CMAKE_SOURCE_DIR}/.git")
    105. 

  105.   message(STATUS "Build and install draft classes and methods")
    106. 

  106.   option(ENABLE_DRAFTS "Build and install draft classes and methods" ON)
    107. 

  107. else()
    108. 

  108.   message(STATUS "Not building draft classes and methods")
    109. 

  109.   option(ENABLE_DRAFTS "Build and install draft classes and methods" OFF)
    110. 

  110. endif()
    111. 

  111. 

  112. # Enable WebSocket transport and RadixTree
    113. 

  113. if(ENABLE_DRAFTS)
    114. 

  114.   set(ZMQ_BUILD_DRAFT_API 1)
    115. 

  115.   option(ENABLE_WS "Enable WebSocket transport" ON)
    116. 

  116.   option(ENABLE_RADIX_TREE "Use radix tree implementation to manage subscriptions" ON)
    117. 

  117. else()
    118. 

  118.   option(ENABLE_WS "Enable WebSocket transport" OFF)
    119. 

  119.   option(ENABLE_RADIX_TREE "Use radix tree implementation to manage subscriptions" OFF)
    120. 

  120. endif()
    121. 

  121. 

  122. if(ENABLE_RADIX_TREE)
    123. 

  123.   message(STATUS "Using radix tree implementation to manage subscriptions")
    124. 

  124.   set(ZMQ_USE_RADIX_TREE 1)
    125. 

  125. endif()
    126. 

  126. 

  127. if(ENABLE_WS)
    128. 

  128.   list(
    129. 

  129.     APPEND
    130. 

  130.     sources
    131. 

  131.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_address.cpp
    132. 

  132.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_connecter.cpp
    133. 

  133.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_decoder.cpp
    134. 

  134.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_encoder.cpp
    135. 

  135.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_engine.cpp
    136. 

  136.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_listener.cpp
    137. 

  137.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_address.hpp
    138. 

  138.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_connecter.hpp
    139. 

  139.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_decoder.hpp
    140. 

  140.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_encoder.hpp
    141. 

  141.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_engine.hpp
    142. 

  142.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_listener.hpp
    143. 

  143.     ${CMAKE_CURRENT_SOURCE_DIR}/src/ws_protocol.hpp)
    144. 

  144.   set(ZMQ_HAVE_WS 1)
    145. 

  145. 

  146.   message(STATUS "Enable WebSocket transport")
    147. 

  147. 

  148.   option(WITH_TLS "Use TLS for WSS support" ON)
    149. 

  149.   option(WITH_NSS "Use NSS instead of builtin sha1" OFF)
    150. 

  150. 

  151.   if(WITH_TLS)
    152. 

  152.     find_package("GnuTLS" 3.6.7)
    153. 

  153.     if(GNUTLS_FOUND)
    154. 

  154.       set(pkg_config_names_private "${pkg_config_names_private} gnutls")
    155. 

  155.       list(APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/src/wss_address.hpp
    156. 

  156.            ${CMAKE_CURRENT_SOURCE_DIR}/src/wss_address.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/wss_engine.hpp
    157. 

  157.            ${CMAKE_CURRENT_SOURCE_DIR}/src/wss_engine.cpp)
    158. 

  158. 

  159.       message(STATUS "Enable WSS transport")
    160. 

  160.       set(ZMQ_USE_GNUTLS 1)
    161. 

  161.       set(ZMQ_HAVE_WSS 1)
    162. 

  162.     else()
    163. 

  163.       message(WARNING "No WSS support, you may want to install GnuTLS and run cmake again")
    164. 

  164.     endif()
    165. 

  165.   endif()
    166. 

  166. endif()
    167. 

  167. 

  168. if(NOT ZMQ_USE_GNUTLS)
    169. 

  169.   if(WITH_NSS)
    170. 

  170.     pkg_check_modules(NSS3 "nss")
    171. 

  171.     if(NSS3_FOUND)
    172. 

  172.       set(pkg_config_names_private "${pkg_config_names_private} nss")
    173. 

  173.       message(STATUS "Using NSS")
    174. 

  174.       set(ZMQ_USE_NSS 1)
    175. 

  175.     else()
    176. 

  176.       find_package("NSS3")
    177. 

  177.       if(NSS3_FOUND)
    178. 

  178.         set(pkg_config_libs_private "${pkg_config_libs_private} -lnss3")
    179. 

  179.         message(STATUS "Using NSS")
    180. 

  180.         set(ZMQ_USE_NSS 1)
    181. 

  181.       else()
    182. 

  182.         message(WARNING "No nss installed, if you don't want builtin SHA1, install NSS or GnuTLS")
    183. 

  183.       endif()
    184. 

  184.     endif()
    185. 

  185.   endif()
    186. 

  186.   if(NOT ZMQ_USE_NSS)
    187. 

  187.     list(APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/external/sha1/sha1.c
    188. 

  188.          ${CMAKE_CURRENT_SOURCE_DIR}/external/sha1/sha1.h)
    189. 

  189.     message(STATUS "Using builtin sha1")
    190. 

  190.     set(ZMQ_USE_BUILTIN_SHA1 1)
    191. 

  191.   endif()
    192. 

  192. endif()
    193. 

  193. 

  194. if(NOT MSVC)
    195. 

  195.   option(WITH_LIBBSD "Use libbsd instead of builtin strlcpy" ON)
    196. 

  196.   if(WITH_LIBBSD)
    197. 

  197.     pkg_check_modules(LIBBSD "libbsd")
    198. 

  198.     if(LIBBSD_FOUND)
    199. 

  199.       message(STATUS "Using libbsd")
    200. 

  200.       set(pkg_config_names_private "${pkg_config_names_private} libbsd")
    201. 

  201.       set(ZMQ_HAVE_LIBBSD 1)
    202. 

  202.     endif()
    203. 

  203.   endif()
    204. 

  204.   if(NOT WITH_LIBBSD OR NOT LIBBSD_FOUND)
    205. 

  205.     check_cxx_symbol_exists(strlcpy string.h ZMQ_HAVE_STRLCPY)
    206. 

  206.   endif()
    207. 

  207. endif()
    208. 

  208. 

  209. # Select curve encryption library, defaults to tweetnacl To use libsodium instead, use --with-libsodium(must be
    210. 

  210. # installed) To disable curve, use --disable-curve
    211. 

  211. 

  212. option(WITH_LIBSODIUM "Use libsodium instead of built-in tweetnacl" ON)
    213. 

  213. option(WITH_LIBSODIUM_STATIC "Use static libsodium library" OFF)
    214. 

  214. option(ENABLE_CURVE "Enable CURVE security" ON)
    215. 

  215. 

  216. if(ENABLE_CURVE)
    217. 

  217.   if(WITH_LIBSODIUM)
    218. 

  218.     find_package("Sodium")
    219. 

  219.     if(SODIUM_FOUND)
    220. 

  220.       message(STATUS "Using libsodium for CURVE security")
    221. 

  221.       include_directories(${SODIUM_INCLUDE_DIRS})
    222. 

  222.       if(WITH_LIBSODIUM_STATIC)
    223. 

  223.         add_compile_definitions(SODIUM_STATIC)
    224. 

  224.       endif()
    225. 

  225.       set(ZMQ_USE_LIBSODIUM 1)
    226. 

  226.       set(ZMQ_HAVE_CURVE 1)
    227. 

  227.     else()
    228. 

  228.       message(
    229. 

  229.         WARNING
    230. 

  230.           "libsodium not installed, instead using builtin tweetnacl, you may want to install libsodium and run cmake again"
    231. 

  231.       )
    232. 

  232.     endif()
    233. 

  233.   endif()
    234. 

  234.   if(NOT ZMQ_HAVE_CURVE)
    235. 

  235.     message(STATUS "Using tweetnacl for CURVE security")
    236. 

  236.     list(APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/src/tweetnacl.c)
    237. 

  237.     set(ZMQ_USE_TWEETNACL 1)
    238. 

  238.     set(ZMQ_HAVE_CURVE 1)
    239. 

  239.   endif()
    240. 

  240. else()
    241. 

  241.   message(STATUS "CURVE security is disabled")
    242. 

  242. endif()
    243. 

  243. 

  244. set(SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
    245. 

  245. 

  246. option(WITH_MILITANT "Enable militant assertions" OFF)
    247. 

  247. if(WITH_MILITANT)
    248. 

  248.   add_definitions(-DZMQ_ACT_MILITANT)
    249. 

  249. endif()
    250. 

  250. 

  251. set(API_POLLER
    252. 

  252.     ""
    253. 

  253.     CACHE STRING "Choose polling system for zmq_poll(er)_*. valid values are
    254. 

  254.   poll or select [default=poll unless POLLER=select]")
    255. 

    256. 

  256. set(POLLER
    257. 

  257.     ""
    258. 

  258.     CACHE STRING "Choose polling system for I/O threads. valid values are
    259. 

  259.   kqueue, epoll, devpoll, pollset, poll or select [default=autodetect]")
    260. 

    261. 

  261. if(WIN32)
    262. 

  262.   if(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore" AND CMAKE_SYSTEM_VERSION MATCHES "^10.0")
    263. 

  263.     set(ZMQ_HAVE_WINDOWS_UWP ON)
    264. 

  264.     set(ZMQ_HAVE_IPC OFF)
    265. 

  265.     # to remove compile warninging "D9002 ignoring unknown option"
    266. 

  266.     string(REPLACE "/Zi" "" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
    267. 

  267.     set(CMAKE_CXX_FLAGS_DEBUG
    268. 

  268.         ${CMAKE_CXX_FLAGS_DEBUG}
    269. 

  269.         CACHE STRING "" FORCE)
    270. 

  270.     string(REPLACE "/Zi" "" CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
    271. 

  271.     set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
    272. 

  272.         ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}
    273. 

  273.         CACHE STRING "" FORCE)
    274. 

  274.     string(REPLACE "/Zi" "" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
    275. 

  275.   endif()
    276. 

  276.   # from https://stackoverflow.com/a/40217291/2019765
    277. 

  277.   macro(get_WIN32_WINNT version)
    278. 

  278.     if(CMAKE_SYSTEM_VERSION)
    279. 

  279.       set(ver ${CMAKE_SYSTEM_VERSION})
    280. 

  280.       string(REGEX MATCH "^([0-9]+).([0-9])" ver ${ver})
    281. 

  281.       string(REGEX MATCH "^([0-9]+)" verMajor ${ver})
    282. 

  282.       # Check for Windows 10, b/c we'll need to convert to hex 'A'.
    283. 

  283.       if("${verMajor}" MATCHES "10")
    284. 

  284.         set(verMajor "A")
    285. 

  285.         string(REGEX REPLACE "^([0-9]+)" ${verMajor} ver ${ver})
    286. 

  286.       endif("${verMajor}" MATCHES "10")
    287. 

  287.       # Remove all remaining '.' characters.
    288. 

  288.       string(REPLACE "." "" ver ${ver})
    289. 

  289.       # Prepend each digit with a zero.
    290. 

  290.       string(REGEX REPLACE "([0-9A-Z])" "0\\1" ver ${ver})
    291. 

  291.       set(${version} "0x${ver}")
    292. 

  292.     endif(CMAKE_SYSTEM_VERSION)
    293. 

  293.   endmacro(get_WIN32_WINNT)
    294. 

  294. 

  295.   get_win32_winnt(ZMQ_WIN32_WINNT_DEFAULT)
    296. 

  296.   message(STATUS "Detected _WIN32_WINNT from CMAKE_SYSTEM_VERSION: ${ZMQ_WIN32_WINNT_DEFAULT}")
    297. 

  297. 

  298.   # TODO limit _WIN32_WINNT to the actual Windows SDK version, which might be different from the default version
    299. 

  299.   # installed with Visual Studio
    300. 

  300.   if(MSVC_VERSION STREQUAL "1500" AND CMAKE_SYSTEM_VERSION VERSION_GREATER "6.0")
    301. 

  301.     set(ZMQ_WIN32_WINNT_LIMIT "0x0600")
    302. 

  302.   elseif(MSVC_VERSION STREQUAL "1600" AND CMAKE_SYSTEM_VERSION VERSION_GREATER "6.1")
    303. 

  303.     set(ZMQ_WIN32_WINNT_LIMIT "0x0601")
    304. 

  304.   elseif(MSVC_VERSION STREQUAL "1700" AND CMAKE_SYSTEM_VERSION VERSION_GREATER "6.1")
    305. 

  305.     set(ZMQ_WIN32_WINNT_LIMIT "0x0601")
    306. 

  306.   elseif(MSVC_VERSION STREQUAL "1800" AND CMAKE_SYSTEM_VERSION VERSION_GREATER "6.2")
    307. 

  307.     set(ZMQ_WIN32_WINNT_LIMIT "0x0602")
    308. 

  308.   endif()
    309. 

  309.   if(ZMQ_WIN32_WINNT_LIMIT)
    310. 

  310.     message(
    311. 

  311.       STATUS
    312. 

  312.         "Mismatch of Visual Studio Version (${MSVC_VERSION}) and CMAKE_SYSTEM_VERSION (${CMAKE_SYSTEM_VERSION}), limiting _WIN32_WINNT to ${ZMQ_WIN32_WINNT_LIMIT}, you may override this by setting ZMQ_WIN32_WINNT"
    313. 

  313.     )
    314. 

  314.     set(ZMQ_WIN32_WINNT_DEFAULT "${ZMQ_WIN32_WINNT_LIMIT}")
    315. 

  315.   endif()
    316. 

  316. 

  317.   set(ZMQ_WIN32_WINNT
    318. 

  318.       "${ZMQ_WIN32_WINNT_DEFAULT}"
    319. 

  319.       CACHE STRING "Value to set _WIN32_WINNT to for building [default=autodetect from build environment]")
    320. 

  320. 

  321.   # On Windows Vista or greater, with MSVC 2013 or greater, default to epoll (which is required on Win 10 for ipc
    322. 

  322.   # support)
    323. 

  323.   if(ZMQ_WIN32_WINNT GREATER "0x05FF"
    324. 

  324.      AND MSVC_VERSION GREATER 1799
    325. 

  325.      AND POLLER STREQUAL ""
    326. 

  326.      AND NOT ZMQ_HAVE_WINDOWS_UWP)
    327. 

  327.     set(POLLER "epoll")
    328. 

  328.   endif()
    329. 

  329. 

  330.   add_definitions(-D_WIN32_WINNT=${ZMQ_WIN32_WINNT})
    331. 

  331. endif(WIN32)
    332. 

  332. 

  333. if(NOT MSVC)
    334. 

  334.   if(POLLER STREQUAL "")
    335. 

  335.     check_cxx_symbol_exists(kqueue sys/event.h HAVE_KQUEUE)
    336. 

  336.     if(HAVE_KQUEUE)
    337. 

  337.       set(POLLER "kqueue")
    338. 

  338.     endif()
    339. 

  339.   endif()
    340. 

  340. 

  341.   if(POLLER STREQUAL "")
    342. 

  342.     check_cxx_symbol_exists(epoll_create sys/epoll.h HAVE_EPOLL)
    343. 

  343.     if(HAVE_EPOLL)
    344. 

  344.       set(POLLER "epoll")
    345. 

  345.       check_cxx_symbol_exists(epoll_create1 sys/epoll.h HAVE_EPOLL_CLOEXEC)
    346. 

  346.       if(HAVE_EPOLL_CLOEXEC)
    347. 

  347.         set(ZMQ_IOTHREAD_POLLER_USE_EPOLL_CLOEXEC 1)
    348. 

  348.       endif()
    349. 

  349.     endif()
    350. 

  350.   endif()
    351. 

  351. 

  352.   if(POLLER STREQUAL "")
    353. 

  353.     set(CMAKE_EXTRA_INCLUDE_FILES sys/devpoll.h)
    354. 

  354.     check_type_size("struct pollfd" DEVPOLL)
    355. 

  355.     set(CMAKE_EXTRA_INCLUDE_FILES)
    356. 

  356.     if(HAVE_DEVPOLL)
    357. 

  357.       set(POLLER "devpoll")
    358. 

  358.     endif()
    359. 

  359.   endif()
    360. 

  360. 

  361.   if(POLLER STREQUAL "")
    362. 

  362.     check_cxx_symbol_exists(pollset_create sys/pollset.h HAVE_POLLSET)
    363. 

  363.     if(HAVE_POLLSET)
    364. 

  364.       set(POLLER "pollset")
    365. 

  365.     endif()
    366. 

  366.   endif()
    367. 

  367. 

  368.   if(POLLER STREQUAL "")
    369. 

  369.     check_cxx_symbol_exists(poll poll.h HAVE_POLL)
    370. 

  370.     if(HAVE_POLL)
    371. 

  371.       set(POLLER "poll")
    372. 

  372.     endif()
    373. 

  373.   endif()
    374. 

  374. endif()
    375. 

  375. 

  376. if(POLLER STREQUAL "")
    377. 

  377.   if(WIN32)
    378. 

  378.     set(HAVE_SELECT 1)
    379. 

  379.   else()
    380. 

  380.     check_cxx_symbol_exists(select sys/select.h HAVE_SELECT)
    381. 

  381.   endif()
    382. 

  382.   if(HAVE_SELECT)
    383. 

  383.     set(POLLER "select")
    384. 

  384.   else()
    385. 

  385.     message(FATAL_ERROR "Could not autodetect polling method")
    386. 

  386.   endif()
    387. 

  387. endif()
    388. 

  388. 

  389. if(POLLER STREQUAL "kqueue"
    390. 

  390.    OR POLLER STREQUAL "epoll"
    391. 

  391.    OR POLLER STREQUAL "devpoll"
    392. 

  392.    OR POLLER STREQUAL "pollset"
    393. 

  393.    OR POLLER STREQUAL "poll"
    394. 

  394.    OR POLLER STREQUAL "select")
    395. 

  395.   message(STATUS "Using polling method in I/O threads: ${POLLER}")
    396. 

  396.   string(TOUPPER ${POLLER} UPPER_POLLER)
    397. 

  397.   set(ZMQ_IOTHREAD_POLLER_USE_${UPPER_POLLER} 1)
    398. 

  398. else()
    399. 

  399.   message(FATAL_ERROR "Invalid polling method")
    400. 

  400. endif()
    401. 

  401. 

  402. if(POLLER STREQUAL "epoll" AND WIN32)
    403. 

  403.   message(STATUS "Including wepoll")
    404. 

  404.   list(APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/external/wepoll/wepoll.c
    405. 

  405.        ${CMAKE_CURRENT_SOURCE_DIR}/external/wepoll/wepoll.h)
    406. 

  406. endif()
    407. 

  407. 

  408. if(API_POLLER STREQUAL "")
    409. 

  409.   if(POLLER STREQUAL "select")
    410. 

  410.     set(API_POLLER "select")
    411. 

  411.   else()
    412. 

  412.     set(API_POLLER "poll")
    413. 

  413.   endif()
    414. 

  414. endif()
    415. 

  415. 

  416. message(STATUS "Using polling method in zmq_poll(er)_* API: ${API_POLLER}")
    417. 

  417. string(TOUPPER ${API_POLLER} UPPER_API_POLLER)
    418. 

  418. set(ZMQ_POLL_BASED_ON_${UPPER_API_POLLER} 1)
    419. 

  419. 

  420. execute_process(
    421. 

  421.   COMMAND getconf LEVEL1_DCACHE_LINESIZE
    422. 

  422.   OUTPUT_VARIABLE CACHELINE_SIZE
    423. 

  423.   ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
    424. 

  424. if(CACHELINE_SIZE STREQUAL ""
    425. 

  425.    OR CACHELINE_SIZE EQUAL 0
    426. 

  426.    OR CACHELINE_SIZE EQUAL -1)
    427. 

  427.   set(ZMQ_CACHELINE_SIZE 64)
    428. 

  428. else()
    429. 

  429.   set(ZMQ_CACHELINE_SIZE ${CACHELINE_SIZE})
    430. 

  430. endif()
    431. 

  431. message(STATUS "Using ${ZMQ_CACHELINE_SIZE} bytes alignment for lock-free data structures")
    432. 

  432. 

  433. if(NOT CYGWIN)
    434. 

  434.   # TODO cannot we simply do 'if(WIN32) set(ZMQ_HAVE_WINDOWS ON)' or similar?
    435. 

  435.   check_include_files(windows.h ZMQ_HAVE_WINDOWS)
    436. 

  436. endif()
    437. 

  437. 

  438. if(NOT WIN32)
    439. 

  439.   set(ZMQ_HAVE_IPC 1)
    440. 

  440. else()
    441. 

  441.   check_include_files("winsock2.h;afunix.h" ZMQ_HAVE_IPC)
    442. 

  442. endif()
    443. 

  443. 

  444. # ##################### BEGIN condition_variable_t selection
    445. 

  445. if(NOT ZMQ_CV_IMPL)
    446. 

  446.   # prefer C++11 STL std::condition_variable implementation, if available
    447. 

  447.   check_include_files(condition_variable ZMQ_HAVE_STL_CONDITION_VARIABLE LANGUAGE CXX)
    448. 

  448. 

  449.   if(ZMQ_HAVE_STL_CONDITION_VARIABLE)
    450. 

  450.     set(ZMQ_CV_IMPL_DEFAULT "stl11")
    451. 

  451.   else()
    452. 

  452.     if(WIN32 AND NOT CMAKE_SYSTEM_VERSION VERSION_LESS "6.0")
    453. 

  453.       # Win32API CONDITION_VARIABLE is supported from Windows Vista only
    454. 

  454.       set(ZMQ_CV_IMPL_DEFAULT "win32api")
    455. 

  455.     elseif(CMAKE_USE_PTHREADS_INIT)
    456. 

  456.       set(ZMQ_CV_IMPL_DEFAULT "pthreads")
    457. 

  457.     else()
    458. 

  458.       set(ZMQ_CV_IMPL_DEFAULT "none")
    459. 

  459.     endif()
    460. 

  460.   endif()
    461. 

  461. 

  462.   # TODO a vxworks implementation also exists, but vxworks is not currently supported with cmake at all
    463. 

  463.   set(ZMQ_CV_IMPL
    464. 

  464.       "${ZMQ_CV_IMPL_DEFAULT}"
    465. 

  465.       CACHE STRING "Choose condition_variable_t implementation. Valid values are
    466. 

  466.        stl11, win32api, pthreads, none [default=autodetect]")
    467. 

  467. endif()
    468. 

  468. 

  469. message(STATUS "Using condition_variable_t implementation: ${ZMQ_CV_IMPL}")
    470. 

  470. if(ZMQ_CV_IMPL STREQUAL "stl11")
    471. 

  471.   set(ZMQ_USE_CV_IMPL_STL11 1)
    472. 

  472. elseif(ZMQ_CV_IMPL STREQUAL "win32api")
    473. 

  473.   set(ZMQ_USE_CV_IMPL_WIN32API 1)
    474. 

  474. elseif(ZMQ_CV_IMPL STREQUAL "pthreads")
    475. 

  475.   set(ZMQ_USE_CV_IMPL_PTHREADS 1)
    476. 

  476. elseif(ZMQ_CV_IMPL STREQUAL "none")
    477. 

  477.   set(ZMQ_USE_CV_IMPL_NONE 1)
    478. 

  478. else()
    479. 

  479.   message(ERROR "Unknown value for ZMQ_CV_IMPL: ${ZMQ_CV_IMPL}")
    480. 

  480. endif()
    481. 

  481. # ##################### END condition_variable_t selection
    482. 

  482. 

  483. if(NOT MSVC)
    484. 

  484.   check_include_files(ifaddrs.h ZMQ_HAVE_IFADDRS)
    485. 

  485.   check_include_files(sys/uio.h ZMQ_HAVE_UIO)
    486. 

  486.   check_include_files(sys/eventfd.h ZMQ_HAVE_EVENTFD)
    487. 

  487.   if(ZMQ_HAVE_EVENTFD AND NOT CMAKE_CROSSCOMPILING)
    488. 

  488.     zmq_check_efd_cloexec()
    489. 

  489.   endif()
    490. 

  490. endif()
    491. 

  491. 

  492. if(ZMQ_HAVE_WINDOWS)
    493. 

  493.   # Cannot use check_library_exists because the symbol is always declared as char(*)(void)
    494. 

  494.   set(CMAKE_REQUIRED_LIBRARIES "ws2_32.lib")
    495. 

  495.   check_cxx_symbol_exists(WSAStartup "winsock2.h" HAVE_WS2_32)
    496. 

  496. 

  497.   set(CMAKE_REQUIRED_LIBRARIES "rpcrt4.lib")
    498. 

  498.   check_cxx_symbol_exists(UuidCreateSequential "rpc.h" HAVE_RPCRT4)
    499. 

  499. 

  500.   set(CMAKE_REQUIRED_LIBRARIES "iphlpapi.lib")
    501. 

  501.   check_cxx_symbol_exists(GetAdaptersAddresses "winsock2.h;iphlpapi.h" HAVE_IPHLAPI)
    502. 

  502. 

  503.   set(CMAKE_REQUIRED_LIBRARIES "")
    504. 

  504.   # TODO: This not the symbol we're looking for. What is the symbol?
    505. 

  505.   check_library_exists(ws2 fopen "" HAVE_WS2)
    506. 

  506. else()
    507. 

  507.   check_cxx_symbol_exists(SO_PEERCRED sys/socket.h ZMQ_HAVE_SO_PEERCRED)
    508. 

  508.   check_cxx_symbol_exists(LOCAL_PEERCRED sys/socket.h ZMQ_HAVE_LOCAL_PEERCRED)
    509. 

  509. endif()
    510. 

  510. 

  511. if(NOT MINGW)
    512. 

  512.   find_library(RT_LIBRARY rt)
    513. 

  513.   if(RT_LIBRARY)
    514. 

  514.     set(pkg_config_libs_private "${pkg_config_libs_private} -lrt")
    515. 

  515.   endif()
    516. 

  516. endif()
    517. 

  517. 

  518. find_package(Threads)
    519. 

  519. 

  520. if(WIN32 AND NOT CYGWIN)
    521. 

  521.   if(NOT HAVE_WS2_32 AND NOT HAVE_WS2)
    522. 

  522.     message(FATAL_ERROR "Cannot link to ws2_32 or ws2")
    523. 

  523.   endif()
    524. 

  524. 

  525.   if(NOT HAVE_RPCRT4)
    526. 

  526.     message(FATAL_ERROR "Cannot link to rpcrt4")
    527. 

  527.   endif()
    528. 

  528. 

  529.   if(NOT HAVE_IPHLAPI)
    530. 

  530.     message(FATAL_ERROR "Cannot link to iphlapi")
    531. 

  531.   endif()
    532. 

  532. endif()
    533. 

  533. 

  534. if(NOT MSVC)
    535. 

  535.   set(CMAKE_REQUIRED_LIBRARIES rt)
    536. 

  536.   check_cxx_symbol_exists(clock_gettime time.h HAVE_CLOCK_GETTIME)
    537. 

  537.   set(CMAKE_REQUIRED_LIBRARIES)
    538. 

  538. 

  539.   check_cxx_symbol_exists(fork unistd.h HAVE_FORK)
    540. 

  540.   check_cxx_symbol_exists(gethrtimei sys/time.h HAVE_GETHRTIME)
    541. 

  541.   check_cxx_symbol_exists(mkdtemp stdlib.h HAVE_MKDTEMP)
    542. 

  542.   check_cxx_symbol_exists(accept4 sys/socket.h HAVE_ACCEPT4)
    543. 

  543.   check_cxx_symbol_exists(strnlen string.h HAVE_STRNLEN)
    544. 

  544. else()
    545. 

  545.   set(HAVE_STRNLEN 1)
    546. 

  546. endif()
    547. 

  547. 

  548. add_definitions(-D_REENTRANT -D_THREAD_SAFE)
    549. 

  549. add_definitions(-DZMQ_CUSTOM_PLATFORM_HPP)
    550. 

  550. 

  551. option(ENABLE_EVENTFD "Enable/disable eventfd" ZMQ_HAVE_EVENTFD)
    552. 

  552. 

  553. macro(zmq_check_cxx_flag_prepend flag)
    554. 

  554.   check_cxx_compiler_flag("${flag}" HAVE_FLAG_${flag})
    555. 

  555. 

  556.   if(HAVE_FLAG_${flag})
    557. 

  557.     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
    558. 

  558.   endif()
    559. 

  559. endmacro()
    560. 

  560. 

  561. option(ENABLE_ANALYSIS "Build with static analysis(make take very long)" OFF)
    562. 

  562. 

  563. if(MSVC)
    564. 

  564.   if(ENABLE_ANALYSIS)
    565. 

  565.     zmq_check_cxx_flag_prepend("/W4")
    566. 

  566. 

  567.     zmq_check_cxx_flag_prepend("/analyze")
    568. 

  568. 

  569.     # C++11/14/17-specific, but maybe possible via conditional defines
    570. 

  570.     zmq_check_cxx_flag_prepend("/wd26440") # Function '...' can be declared 'noexcept'
    571. 

  571.     zmq_check_cxx_flag_prepend("/wd26432") # If you define or delete any default operation in the type '...', define or
    572. 

  572.                                            # delete them all
    573. 

  573.     zmq_check_cxx_flag_prepend("/wd26439") # This kind of function may not throw. Declare it 'noexcept'
    574. 

  574.     zmq_check_cxx_flag_prepend("/wd26447") # The function is declared 'noexcept' but calls function '...' which may
    575. 

  575.                                            # throw exceptions
    576. 

  576.     zmq_check_cxx_flag_prepend("/wd26433") # Function '...' should be marked with 'override'
    577. 

  577.     zmq_check_cxx_flag_prepend("/wd26409") # Avoid calling new and delete explicitly, use std::make_unique<T> instead
    578. 

  578.     # Requires GSL
    579. 

  579.     zmq_check_cxx_flag_prepend("/wd26429") # Symbol '...' is never tested for nullness, it can be marked as not_null
    580. 

  580.     zmq_check_cxx_flag_prepend("/wd26446") # Prefer to use gsl::at()
    581. 

  581.     zmq_check_cxx_flag_prepend("/wd26481") # Don't use pointer arithmetic. Use span instead
    582. 

  582.     zmq_check_cxx_flag_prepend("/wd26472") # Don't use a static_cast for arithmetic conversions. Use brace
    583. 

  583.                                            # initialization, gsl::narrow_cast or gsl::narow
    584. 

  584.     zmq_check_cxx_flag_prepend("/wd26448") # Consider using gsl::finally if final action is intended
    585. 

  585.     zmq_check_cxx_flag_prepend("/wd26400") # Do not assign the result of an allocation or a function call with an
    586. 

  586.                                            # owner<T> return value to a raw pointer, use owner<T> instead
    587. 

  587.     zmq_check_cxx_flag_prepend("/wd26485") # Expression '...': No array to pointer decay(bounds.3)
    588. 

  588.   else()
    589. 

  589.     zmq_check_cxx_flag_prepend("/W3")
    590. 

  590.   endif()
    591. 

  591. 

  592.   if(MSVC_IDE)
    593. 

  593.     set(MSVC_TOOLSET "-${CMAKE_VS_PLATFORM_TOOLSET}")
    594. 

  594.   else()
    595. 

  595.     set(MSVC_TOOLSET "")
    596. 

  596.   endif()
    597. 

  597. else()
    598. 

  598.   zmq_check_cxx_flag_prepend("-Wall")
    599. 

  599. endif()
    600. 

  600. 

  601. if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    602. 

  602.   zmq_check_cxx_flag_prepend("-Wextra")
    603. 

  603. endif()
    604. 

  604. 

  605. option(LIBZMQ_PEDANTIC "" ON)
    606. 

  606. option(LIBZMQ_WERROR "" OFF)
    607. 

  607. 

  608. # TODO: why is -Wno-long-long defined differently than in configure.ac?
    609. 

  609. if(NOT MSVC)
    610. 

  610.   zmq_check_cxx_flag_prepend("-Wno-long-long")
    611. 

  611.   zmq_check_cxx_flag_prepend("-Wno-uninitialized")
    612. 

  612. 

  613.   if(LIBZMQ_PEDANTIC)
    614. 

  614.     zmq_check_cxx_flag_prepend("-pedantic")
    615. 

  615. 

  616.     if(${CMAKE_CXX_COMPILER_ID} MATCHES "Intel")
    617. 

  617.       zmq_check_cxx_flag_prepend("-strict-ansi")
    618. 

  618.     endif()
    619. 

  619. 

  620.     if(${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
    621. 

  621.       zmq_check_cxx_flag_prepend("-compat=5")
    622. 

  622.     endif()
    623. 

  623.   endif()
    624. 

  624. endif()
    625. 

  625. 

  626. if(LIBZMQ_WERROR)
    627. 

  627.   if(MSVC)
    628. 

  628.     zmq_check_cxx_flag_prepend("/WX")
    629. 

  629.   else()
    630. 

  630.     zmq_check_cxx_flag_prepend("-Werror")
    631. 

  631.     if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
    632. 

  632.       zmq_check_cxx_flag_prepend("-errwarn=%all")
    633. 

  633.     endif()
    634. 

  634.   endif()
    635. 

  635. endif()
    636. 

  636. 

  637. if(CMAKE_SYSTEM_PROCESSOR MATCHES "^sparc")
    638. 

  638.   zmq_check_cxx_flag_prepend("-mcpu=v9")
    639. 

  639. endif()
    640. 

  640. 

  641. if(${CMAKE_CXX_COMPILER_ID} MATCHES "SunPro")
    642. 

  642.   zmq_check_cxx_flag_prepend("-features=zla")
    643. 

  643. endif()
    644. 

  644. 

  645. if(CMAKE_SYSTEM_NAME MATCHES "SunOS"
    646. 

  646.    OR CMAKE_SYSTEM_NAME MATCHES "NetBSD"
    647. 

  647.    OR CMAKE_SYSTEM_NAME MATCHES "QNX")
    648. 

  648.   message(STATUS "Checking whether atomic operations can be used")
    649. 

  649.   check_c_source_compiles(
    650. 

  650.     "\
    651. 

  651.   #include <atomic.h> \
    652. 

  652.   \
    653. 

  653.   int main() \
    654. 

  654.   { \
    655. 

  655.     uint32_t value; \
    656. 

  656.     atomic_cas_32(&value, 0, 0); \
    657. 

  657.     return 0; \
    658. 

  658.   } \
    659. 

  659.   "
    660. 

  660.     HAVE_ATOMIC_H)
    661. 

  661. 

  662.   if(NOT HAVE_ATOMIC_H)
    663. 

  663.     set(ZMQ_FORCE_MUTEXES 1)
    664. 

  664.   endif()
    665. 

  665. endif()
    666. 

  666. 

  667. if(NOT ANDROID)
    668. 

  668.   zmq_check_noexcept()
    669. 

  669. endif()
    670. 

  670. 

  671. # -----------------------------------------------------------------------------
    672. 

  672. if(NOT CMAKE_CROSSCOMPILING AND NOT MSVC)
    673. 

  673.   zmq_check_sock_cloexec()
    674. 

  674.   zmq_check_o_cloexec()
    675. 

  675.   zmq_check_so_bindtodevice()
    676. 

  676.   zmq_check_so_keepalive()
    677. 

  677.   zmq_check_tcp_keepcnt()
    678. 

  678.   zmq_check_tcp_keepidle()
    679. 

  679.   zmq_check_tcp_keepintvl()
    680. 

  680.   zmq_check_tcp_keepalive()
    681. 

  681.   zmq_check_tcp_tipc()
    682. 

  682.   zmq_check_pthread_setname()
    683. 

  683.   zmq_check_pthread_setaffinity()
    684. 

  684.   zmq_check_getrandom()
    685. 

  685. endif()
    686. 

  686. 

  687. if(CMAKE_SYSTEM_NAME MATCHES "Linux"
    688. 

  688.    OR CMAKE_SYSTEM_NAME MATCHES "GNU/kFreeBSD"
    689. 

  689.    OR CMAKE_SYSTEM_NAME MATCHES "GNU/Hurd"
    690. 

  690.    OR CYGWIN)
    691. 

  691.   add_definitions(-D_GNU_SOURCE)
    692. 

  692. elseif(CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
    693. 

  693.   add_definitions(-D__BSD_VISIBLE)
    694. 

  694. elseif(CMAKE_SYSTEM_NAME MATCHES "NetBSD")
    695. 

  695.   add_definitions(-D_NETBSD_SOURCE)
    696. 

  696. elseif(CMAKE_SYSTEM_NAME MATCHES "OpenBSD")
    697. 

  697.   add_definitions(-D_OPENBSD_SOURCE)
    698. 

  698. elseif(CMAKE_SYSTEM_NAME MATCHES "SunOS")
    699. 

  699.   add_definitions(-D_PTHREADS)
    700. 

  700. elseif(CMAKE_SYSTEM_NAME MATCHES "HP-UX")
    701. 

  701.   add_definitions(-D_POSIX_C_SOURCE=200112L)
    702. 

  702.   zmq_check_cxx_flag_prepend(-Ae)
    703. 

  703. elseif(CMAKE_SYSTEM_NAME MATCHES "Darwin")
    704. 

  704.   add_definitions(-D_DARWIN_C_SOURCE)
    705. 

  705. endif()
    706. 

  706. 

  707. find_package(AsciiDoc)
    708. 

  708. 

  709. cmake_dependent_option(WITH_DOC "Build Reference Guide documentation(requires DocBook)" ON "ASCIIDOC_FOUND;NOT WIN32"
    710. 

  710.                        OFF) # Do not build docs on Windows due to issues with symlinks
    711. 

  711. 

  712. if(MSVC)
    713. 

  713.   if(WITH_OPENPGM)
    714. 

  714.     # set(OPENPGM_ROOT "" CACHE PATH "Location of OpenPGM")
    715. 

  715.     set(OPENPGM_VERSION_MAJOR 5)
    716. 

  716.     set(OPENPGM_VERSION_MINOR 2)
    717. 

  717.     set(OPENPGM_VERSION_MICRO 122)
    718. 

  718.     if(CMAKE_CL_64)
    719. 

  719.       find_path(
    720. 

  720.         OPENPGM_ROOT include/pgm/pgm.h
    721. 

  721.         PATHS
    722. 

  722.           "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Miru\\OpenPGM ${OPENPGM_VERSION_MAJOR}.${OPENPGM_VERSION_MINOR}.${OPENPGM_VERSION_MICRO}]"
    723. 

  723.         NO_DEFAULT_PATH)
    724. 

  724.       message(STATUS "OpenPGM x64 detected - ${OPENPGM_ROOT}")
    725. 

  725.     else()
    726. 

  726.       find_path(
    727. 

  727.         OPENPGM_ROOT include/pgm/pgm.h
    728. 

  728.         PATHS
    729. 

  729.           "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Miru\\OpenPGM ${OPENPGM_VERSION_MAJOR}.${OPENPGM_VERSION_MINOR}.${OPENPGM_VERSION_MICRO}]"
    730. 

  730.           "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Miru\\OpenPGM ${OPENPGM_VERSION_MAJOR}.${OPENPGM_VERSION_MINOR}.${OPENPGM_VERSION_MICRO}]"
    731. 

  731.           NO_DEFAULT_PATH)
    732. 

  732.       message(STATUS "OpenPGM x86 detected - ${OPENPGM_ROOT}")
    733. 

  733.     endif()
    734. 

  734.     set(OPENPGM_INCLUDE_DIRS ${OPENPGM_ROOT}/include)
    735. 

  735.     set(OPENPGM_LIBRARY_DIRS ${OPENPGM_ROOT}/lib)
    736. 

  736.     set(OPENPGM_LIBRARIES
    737. 

  737.         optimized
    738. 

  738.         libpgm${MSVC_TOOLSET}-mt-${OPENPGM_VERSION_MAJOR}_${OPENPGM_VERSION_MINOR}_${OPENPGM_VERSION_MICRO}.lib debug
    739. 

  739.         libpgm${MSVC_TOOLSET}-mt-gd-${OPENPGM_VERSION_MAJOR}_${OPENPGM_VERSION_MINOR}_${OPENPGM_VERSION_MICRO}.lib)
    740. 

  740.   endif()
    741. 

  741. else()
    742. 

  742.   if(WITH_OPENPGM)
    743. 

  743.     # message(FATAL_ERROR "WITH_OPENPGM not implemented")
    744. 

  744. 

  745.     if(NOT OPENPGM_PKGCONFIG_NAME)
    746. 

  746.       set(OPENPGM_PKGCONFIG_NAME "openpgm-5.2")
    747. 

  747.     endif()
    748. 

  748. 

  749.     set(OPENPGM_PKGCONFIG_NAME
    750. 

  750.         ${OPENPGM_PKGCONFIG_NAME}
    751. 

  751.         CACHE STRING "Name pkg-config shall use to find openpgm libraries and include paths" FORCE)
    752. 

  752. 

  753.     pkg_check_modules(OPENPGM ${OPENPGM_PKGCONFIG_NAME})
    754. 

  754. 

  755.     if(OPENPGM_FOUND)
    756. 

  756.       message(STATUS ${OPENPGM_PKGCONFIG_NAME}" found")
    757. 

  757.       set(pkg_config_names_private "${pkg_config_names_private} ${OPENPGM_PKGCONFIG_NAME}")
    758. 

  758.     else()
    759. 

  759.       message(
    760. 

  760.         FATAL_ERROR
    761. 

  761.           ${OPENPGM_PKGCONFIG_NAME}"  not found. openpgm is searchd via `pkg-config ${OPENPGM_PKGCONFIG_NAME}`. Consider providing a valid OPENPGM_PKGCONFIG_NAME"
    762. 

  762.       )
    763. 

  763.     endif()
    764. 

  764. 

  765.     # DSO symbol visibility for openpgm
    766. 

  766.     if(HAVE_FLAG_VISIBILITY_HIDDEN)
    767. 

  767. 

  768.     elseif(HAVE_FLAG_LDSCOPE_HIDDEN)
    769. 

  769. 

  770.     endif()
    771. 

  771.   endif()
    772. 

  772. endif()
    773. 

  773. 

  774. # -----------------------------------------------------------------------------
    775. 

  775. # force off-tree build
    776. 

  776. 

  777. if(${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR})
    778. 

  778.   message(
    779. 

  779.     FATAL_ERROR
    780. 

  780.       "CMake generation is not allowed within the source directory! \
    781. 

  781.     Remove the CMakeCache.txt file and try again from another folder, e.g.: \
    782. 

  782.     \
    783. 

  783.       rm CMakeCache.txt \
    784. 

  784.       mkdir cmake-make \
    785. 

  785.       cd cmake-make \
    786. 

  786.       cmake ..")
    787. 

  787. endif()
    788. 

  788. 

  789. # -----------------------------------------------------------------------------
    790. 

  790. # default to Release build
    791. 

  791. 

  792. if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
    793. 

  793.   # CMAKE_BUILD_TYPE is not used for multi-configuration generators like Visual Studio/XCode which instead use
    794. 

  794.   # CMAKE_CONFIGURATION_TYPES
    795. 

  795.   set(CMAKE_BUILD_TYPE
    796. 

  796.       Release
    797. 

  797.       CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel." FORCE)
    798. 

  798. endif()
    799. 

  799. 

  800. # -----------------------------------------------------------------------------
    801. 

  801. # output directories
    802. 

  802. 

  803. zmq_set_with_default(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${ZeroMQ_BINARY_DIR}/bin")
    804. 

  804. if(UNIX)
    805. 

  805.   set(zmq_library_directory "lib")
    806. 

  806. else()
    807. 

  807.   set(zmq_library_directory "bin")
    808. 

  808. endif()
    809. 

  809. zmq_set_with_default(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${ZeroMQ_BINARY_DIR}/${zmq_library_directory}")
    810. 

  810. zmq_set_with_default(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${ZeroMQ_BINARY_DIR}/lib")
    811. 

  811. 

  812. # -----------------------------------------------------------------------------
    813. 

  813. # platform specifics
    814. 

  814. 

  815. if(WIN32)
    816. 

  816.   # Socket limit is 16K(can be raised arbitrarily)
    817. 

  817.   add_definitions(-DFD_SETSIZE=16384)
    818. 

  818.   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
    819. 

  819.   add_definitions(-D_WINSOCK_DEPRECATED_NO_WARNINGS)
    820. 

  820. endif()
    821. 

  821. 

  822. if(MSVC)
    823. 

  823.   # Parallel make.
    824. 

  824.   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
    825. 

  825.   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP")
    826. 

  826. 

  827.   # Compile the static lib with debug information included note: we assume here that the default flags contain some /Z
    828. 

  828.   # flag
    829. 

  829.   string(REGEX REPLACE "/Z.[^:]" "/Z7 " CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
    830. 

  830.   string(REGEX REPLACE "/Z.[^:]" "/Z7 " CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
    831. 

  831. 

  832.   # Optimization flags. http://msdn.microsoft.com/en-us/magazine/cc301698.aspx
    833. 

  833.   if(NOT ${CMAKE_BUILD_TYPE} MATCHES "Debug")
    834. 

  834.     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GL")
    835. 

  835.     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LTCG")
    836. 

  836.     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /LTCG")
    837. 

  837.     set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /LTCG")
    838. 

  838.   endif()
    839. 

  839. endif()
    840. 

  840. 

  841. # -----------------------------------------------------------------------------
    842. 

  842. # source files
    843. 

  843. 

  844. set(cxx-sources
    845. 

  845.     precompiled.cpp
    846. 

  846.     address.cpp
    847. 

  847.     channel.cpp
    848. 

  848.     client.cpp
    849. 

  849.     clock.cpp
    850. 

  850.     ctx.cpp
    851. 

  851.     curve_mechanism_base.cpp
    852. 

  852.     curve_client.cpp
    853. 

  853.     curve_server.cpp
    854. 

  854.     dealer.cpp
    855. 

  855.     devpoll.cpp
    856. 

  856.     dgram.cpp
    857. 

  857.     dist.cpp
    858. 

  858.     endpoint.cpp
    859. 

  859.     epoll.cpp
    860. 

  860.     err.cpp
    861. 

  861.     fq.cpp
    862. 

  862.     io_object.cpp
    863. 

  863.     io_thread.cpp
    864. 

  864.     ip.cpp
    865. 

  865.     ipc_address.cpp
    866. 

  866.     ipc_connecter.cpp
    867. 

  867.     ipc_listener.cpp
    868. 

  868.     kqueue.cpp
    869. 

  869.     lb.cpp
    870. 

  870.     mailbox.cpp
    871. 

  871.     mailbox_safe.cpp
    872. 

  872.     mechanism.cpp
    873. 

  873.     mechanism_base.cpp
    874. 

  874.     metadata.cpp
    875. 

  875.     msg.cpp
    876. 

  876.     mtrie.cpp
    877. 

  877.     norm_engine.cpp
    878. 

  878.     object.cpp
    879. 

  879.     options.cpp
    880. 

  880.     own.cpp
    881. 

  881.     null_mechanism.cpp
    882. 

  882.     pair.cpp
    883. 

  883.     peer.cpp
    884. 

  884.     pgm_receiver.cpp
    885. 

  885.     pgm_sender.cpp
    886. 

  886.     pgm_socket.cpp
    887. 

  887.     pipe.cpp
    888. 

  888.     plain_client.cpp
    889. 

  889.     plain_server.cpp
    890. 

  890.     poll.cpp
    891. 

  891.     poller_base.cpp
    892. 

  892.     polling_util.cpp
    893. 

  893.     pollset.cpp
    894. 

  894.     proxy.cpp
    895. 

  895.     pub.cpp
    896. 

  896.     pull.cpp
    897. 

  897.     push.cpp
    898. 

  898.     random.cpp
    899. 

  899.     raw_encoder.cpp
    900. 

  900.     raw_decoder.cpp
    901. 

  901.     raw_engine.cpp
    902. 

  902.     reaper.cpp
    903. 

  903.     rep.cpp
    904. 

  904.     req.cpp
    905. 

  905.     router.cpp
    906. 

  906.     select.cpp
    907. 

  907.     server.cpp
    908. 

  908.     session_base.cpp
    909. 

  909.     signaler.cpp
    910. 

  910.     socket_base.cpp
    911. 

  911.     socks.cpp
    912. 

  912.     socks_connecter.cpp
    913. 

  913.     stream.cpp
    914. 

  914.     stream_engine_base.cpp
    915. 

  915.     sub.cpp
    916. 

  916.     tcp.cpp
    917. 

  917.     tcp_address.cpp
    918. 

  918.     tcp_connecter.cpp
    919. 

  919.     tcp_listener.cpp
    920. 

  920.     thread.cpp
    921. 

  921.     trie.cpp
    922. 

  922.     radix_tree.cpp
    923. 

  923.     v1_decoder.cpp
    924. 

  924.     v1_encoder.cpp
    925. 

  925.     v2_decoder.cpp
    926. 

  926.     v2_encoder.cpp
    927. 

  927.     v3_1_encoder.cpp
    928. 

  928.     xpub.cpp
    929. 

  929.     xsub.cpp
    930. 

  930.     zmq.cpp
    931. 

  931.     zmq_utils.cpp
    932. 

  932.     decoder_allocators.cpp
    933. 

  933.     socket_poller.cpp
    934. 

  934.     timers.cpp
    935. 

  935.     config.hpp
    936. 

  936.     radio.cpp
    937. 

  937.     dish.cpp
    938. 

  938.     udp_engine.cpp
    939. 

  939.     udp_address.cpp
    940. 

  940.     scatter.cpp
    941. 

  941.     gather.cpp
    942. 

  942.     ip_resolver.cpp
    943. 

  943.     zap_client.cpp
    944. 

  944.     zmtp_engine.cpp
    945. 

  945.     # at least for VS, the header files must also be listed
    946. 

  946.     address.hpp
    947. 

  947.     array.hpp
    948. 

  948.     atomic_counter.hpp
    949. 

  949.     atomic_ptr.hpp
    950. 

  950.     blob.hpp
    951. 

  951.     channel.hpp
    952. 

  952.     client.hpp
    953. 

  953.     clock.hpp
    954. 

  954.     command.hpp
    955. 

  955.     condition_variable.hpp
    956. 

  956.     config.hpp
    957. 

  957.     ctx.hpp
    958. 

  958.     curve_client.hpp
    959. 

  959.     curve_client_tools.hpp
    960. 

  960.     curve_mechanism_base.hpp
    961. 

  961.     curve_server.hpp
    962. 

  962.     dbuffer.hpp
    963. 

  963.     dealer.hpp
    964. 

  964.     decoder.hpp
    965. 

  965.     decoder_allocators.hpp
    966. 

  966.     devpoll.hpp
    967. 

  967.     dgram.hpp
    968. 

  968.     dish.hpp
    969. 

  969.     dist.hpp
    970. 

  970.     encoder.hpp
    971. 

  971.     endpoint.hpp
    972. 

  972.     epoll.hpp
    973. 

  973.     err.hpp
    974. 

  974.     fd.hpp
    975. 

  975.     fq.hpp
    976. 

  976.     gather.hpp
    977. 

  977.     generic_mtrie.hpp
    978. 

  978.     generic_mtrie_impl.hpp
    979. 

  979.     gssapi_client.hpp
    980. 

  980.     gssapi_mechanism_base.hpp
    981. 

  981.     gssapi_server.hpp
    982. 

  982.     i_decoder.hpp
    983. 

  983.     i_encoder.hpp
    984. 

  984.     i_engine.hpp
    985. 

  985.     i_mailbox.hpp
    986. 

  986.     i_poll_events.hpp
    987. 

  987.     io_object.hpp
    988. 

  988.     io_thread.hpp
    989. 

  989.     ip.hpp
    990. 

  990.     ipc_address.hpp
    991. 

  991.     ipc_connecter.hpp
    992. 

  992.     ipc_listener.hpp
    993. 

  993.     kqueue.hpp
    994. 

  994.     lb.hpp
    995. 

  995.     likely.hpp
    996. 

  996.     macros.hpp
    997. 

  997.     mailbox.hpp
    998. 

  998.     mailbox_safe.hpp
    999. 

  999.     mechanism.hpp
    1000. 

  1000.     mechanism_base.hpp
    1001. 

  1001.     metadata.hpp
    1002. 

  1002.     msg.hpp
    1003. 

  1003.     mtrie.hpp
    1004. 

  1004.     mutex.hpp
    1005. 

  1005.     norm_engine.hpp
    1006. 

  1006.     null_mechanism.hpp
    1007. 

  1007.     object.hpp
    1008. 

  1008.     options.hpp
    1009. 

  1009.     own.hpp
    1010. 

  1010.     pair.hpp
    1011. 

  1011.     peer.hpp
    1012. 

  1012.     pgm_receiver.hpp
    1013. 

  1013.     pgm_sender.hpp
    1014. 

  1014.     pgm_socket.hpp
    1015. 

  1015.     pipe.hpp
    1016. 

  1016.     plain_client.hpp
    1017. 

  1017.     plain_common.hpp
    1018. 

  1018.     plain_server.hpp
    1019. 

  1019.     poll.hpp
    1020. 

  1020.     poller.hpp
    1021. 

  1021.     poller_base.hpp
    1022. 

  1022.     polling_util.hpp
    1023. 

  1023.     pollset.hpp
    1024. 

  1024.     precompiled.hpp
    1025. 

  1025.     proxy.hpp
    1026. 

  1026.     pub.hpp
    1027. 

  1027.     pull.hpp
    1028. 

  1028.     push.hpp
    1029. 

  1029.     radio.hpp
    1030. 

  1030.     random.hpp
    1031. 

  1031.     raw_decoder.hpp
    1032. 

  1032.     raw_encoder.hpp
    1033. 

  1033.     raw_engine.hpp
    1034. 

  1034.     reaper.hpp
    1035. 

  1035.     rep.hpp
    1036. 

  1036.     req.hpp
    1037. 

  1037.     router.hpp
    1038. 

  1038.     scatter.hpp
    1039. 

  1039.     secure_allocator.hpp
    1040. 

  1040.     select.hpp
    1041. 

  1041.     server.hpp
    1042. 

  1042.     session_base.hpp
    1043. 

  1043.     signaler.hpp
    1044. 

  1044.     socket_base.hpp
    1045. 

  1045.     socket_poller.hpp
    1046. 

  1046.     socks.hpp
    1047. 

  1047.     socks_connecter.hpp
    1048. 

  1048.     stdint.hpp
    1049. 

  1049.     stream.hpp
    1050. 

  1050.     stream_engine_base.hpp
    1051. 

  1051.     stream_connecter_base.hpp
    1052. 

  1052.     stream_connecter_base.cpp
    1053. 

  1053.     stream_listener_base.hpp
    1054. 

  1054.     stream_listener_base.cpp
    1055. 

  1055.     sub.hpp
    1056. 

  1056.     tcp.hpp
    1057. 

  1057.     tcp_address.hpp
    1058. 

  1058.     tcp_connecter.hpp
    1059. 

  1059.     tcp_listener.hpp
    1060. 

  1060.     thread.hpp
    1061. 

  1061.     timers.hpp
    1062. 

  1062.     tipc_address.hpp
    1063. 

  1063.     tipc_connecter.hpp
    1064. 

  1064.     tipc_listener.hpp
    1065. 

  1065.     trie.hpp
    1066. 

  1066.     udp_address.hpp
    1067. 

  1067.     udp_engine.hpp
    1068. 

  1068.     v1_decoder.hpp
    1069. 

  1069.     v1_encoder.hpp
    1070. 

  1070.     v2_decoder.hpp
    1071. 

  1071.     v2_encoder.hpp
    1072. 

  1072.     v3_1_encoder.hpp
    1073. 

  1073.     v2_protocol.hpp
    1074. 

  1074.     vmci.hpp
    1075. 

  1075.     vmci_address.hpp
    1076. 

  1076.     vmci_connecter.hpp
    1077. 

  1077.     vmci_listener.hpp
    1078. 

  1078.     windows.hpp
    1079. 

  1079.     wire.hpp
    1080. 

  1080.     xpub.hpp
    1081. 

  1081.     xsub.hpp
    1082. 

  1082.     ypipe.hpp
    1083. 

  1083.     ypipe_base.hpp
    1084. 

  1084.     ypipe_conflate.hpp
    1085. 

  1085.     yqueue.hpp
    1086. 

  1086.     zap_client.hpp
    1087. 

  1087.     zmtp_engine.hpp)
    1088. 

  1088. 

  1089. if(MINGW)
    1090. 

  1090.   # Generate the right type when using -m32 or -m64
    1091. 

  1091.   macro(set_rc_arch rc_target)
    1092. 

  1092.     set(CMAKE_RC_COMPILER_INIT windres)
    1093. 

  1093.     enable_language(RC)
    1094. 

  1094.     set(CMAKE_RC_COMPILE_OBJECT
    1095. 

  1095.         "<CMAKE_RC_COMPILER> <FLAGS> -O coff --target=${rc_target} <DEFINES> -i <SOURCE> -o <OBJECT>")
    1096. 

  1096.   endmacro()
    1097. 

  1097. 

  1098.   if(NOT CMAKE_SYSTEM_PROCESSOR)
    1099. 

  1099.     set(CMAKE_SYSTEM_PROCESSOR ${CMAKE_HOST_SYSTEM_PROCESSOR})
    1100. 

  1100.   endif()
    1101. 

  1101. 

  1102.   # Also happens on x86_64 systems...what a worthless variable
    1103. 

  1103.   if(CMAKE_SYSTEM_PROCESSOR MATCHES "i386"
    1104. 

  1104.      OR CMAKE_SYSTEM_PROCESSOR MATCHES "i486"
    1105. 

  1105.      OR CMAKE_SYSTEM_PROCESSOR MATCHES "i586"
    1106. 

  1106.      OR CMAKE_SYSTEM_PROCESSOR MATCHES "i686"
    1107. 

  1107.      OR CMAKE_SYSTEM_PROCESSOR MATCHES "x86"
    1108. 

  1108.      OR CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64"
    1109. 

  1109.      OR CMAKE_SYSTEM_PROCESSOR MATCHES "amd64")
    1110. 

  1110. 

  1111.     if(CMAKE_SIZEOF_VOID_P EQUAL 8)
    1112. 

  1112.       set_rc_arch("pe-x86-64")
    1113. 

  1113.     else()
    1114. 

  1114.       set_rc_arch("pe-i386")
    1115. 

  1115.     endif()
    1116. 

  1116.   endif()
    1117. 

  1117. endif()
    1118. 

  1118. 

  1119. set(public_headers include/zmq.h include/zmq_utils.h)
    1120. 

  1120. 

  1121. set(readme-docs AUTHORS COPYING COPYING.LESSER NEWS)
    1122. 

  1122. 

  1123. # -----------------------------------------------------------------------------
    1124. 

  1124. # optional modules
    1125. 

  1125. 

  1126. if(WITH_OPENPGM)
    1127. 

  1127.   add_definitions(-DZMQ_HAVE_OPENPGM)
    1128. 

  1128.   include_directories(${OPENPGM_INCLUDE_DIRS})
    1129. 

  1129.   link_directories(${OPENPGM_LIBRARY_DIRS})
    1130. 

  1130.   set(OPTIONAL_LIBRARIES ${OPENPGM_LIBRARIES})
    1131. 

  1131. endif()
    1132. 

  1132. 

  1133. if(WITH_VMCI)
    1134. 

  1134.   add_definitions(-DZMQ_HAVE_VMCI)
    1135. 

  1135.   include_directories(${VMCI_INCLUDE_DIRS})
    1136. 

  1136.   list(APPEND cxx-sources vmci_address.cpp vmci_connecter.cpp vmci_listener.cpp vmci.cpp)
    1137. 

  1137. endif()
    1138. 

  1138. 

  1139. if(ZMQ_HAVE_TIPC)
    1140. 

  1140.   list(APPEND cxx-sources tipc_address.cpp tipc_connecter.cpp tipc_listener.cpp)
    1141. 

  1141. endif()
    1142. 

  1142. 

  1143. # -----------------------------------------------------------------------------
    1144. 

  1144. # source generators
    1145. 

  1145. 

  1146. foreach(source ${cxx-sources})
    1147. 

  1147.   list(APPEND sources ${CMAKE_CURRENT_SOURCE_DIR}/src/${source})
    1148. 

  1148. endforeach()
    1149. 

  1149. 

  1150. configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
    1151. 

  1151. 

  1152. # Delete any src/platform.hpp left by configure
    1153. 

  1153. file(REMOVE ${CMAKE_CURRENT_SOURCE_DIR}/src/platform.hpp)
    1154. 

  1154. 

  1155. configure_file(${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/platform.hpp.in ${CMAKE_CURRENT_BINARY_DIR}/platform.hpp)
    1156. 

  1156. list(APPEND sources ${CMAKE_CURRENT_BINARY_DIR}/platform.hpp)
    1157. 

  1157. 

  1158. set(prefix ${CMAKE_INSTALL_PREFIX})
    1159. 

  1159. set(exec_prefix ${prefix})
    1160. 

  1160. set(libdir ${prefix}/lib)
    1161. 

  1161. set(includedir ${prefix}/include)
    1162. 

  1162. set(VERSION ${ZMQ_VERSION_MAJOR}.${ZMQ_VERSION_MINOR}.${ZMQ_VERSION_PATCH})
    1163. 

  1163. configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/libzmq.pc.in ${CMAKE_CURRENT_BINARY_DIR}/libzmq.pc @ONLY)
    1164. 

  1164. set(zmq-pkgconfig ${CMAKE_CURRENT_BINARY_DIR}/libzmq.pc)
    1165. 

  1165. 

  1166. if(NOT ZMQ_BUILD_FRAMEWORK)
    1167. 

  1167.   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libzmq.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
    1168. 

  1168. endif()
    1169. 

  1169. 

  1170. if(MSVC)
    1171. 

  1171.   if(CMAKE_CL_64)
    1172. 

  1172.     set(nsis-template ${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/NSIS.template64.in)
    1173. 

  1173.   else()
    1174. 

  1174.     set(nsis-template ${CMAKE_CURRENT_SOURCE_DIR}/builds/cmake/NSIS.template32.in)
    1175. 

  1175.   endif()
    1176. 

  1176. 

  1177.   add_custom_command(
    1178. 

  1178.     OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/NSIS.template.in
    1179. 

  1179.     COMMAND ${CMAKE_COMMAND} ARGS -E copy ${nsis-template} ${CMAKE_CURRENT_BINARY_DIR}/NSIS.template.in
    1180. 

  1180.     DEPENDS ${nsis-template})
    1181. 

  1181. endif()
    1182. 

  1182. 

  1183. option(WITH_DOCS "Build html docs" ON)
    1184. 

  1184. if(WITH_DOCS)
    1185. 

  1185.   file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc)
    1186. 

  1186.   file(
    1187. 

  1187.     GLOB docs
    1188. 

  1188.     RELATIVE ${CMAKE_CURRENT_BINARY_DIR}/
    1189. 

  1189.     "${CMAKE_CURRENT_SOURCE_DIR}/doc/*.txt")
    1190. 

  1190.   set(html-docs)
    1191. 

  1191.   foreach(txt ${docs})
    1192. 

  1192.     string(REGEX REPLACE ".*/(.*)\\.txt" "\\1.html" html ${txt})
    1193. 

  1193.     set(src ${txt})
    1194. 

  1194.     set(dst doc/${html})
    1195. 

  1195.     if(WITH_DOC)
    1196. 

  1196.       add_custom_command(
    1197. 

  1197.         OUTPUT ${dst}
    1198. 

  1198.         COMMAND ${ASCIIDOC_EXECUTABLE} -d manpage -b xhtml11 -f ${CMAKE_CURRENT_SOURCE_DIR}/doc/asciidoc.conf
    1199. 

  1199.                 -azmq_version=${ZMQ_VERSION} -o ${dst} ${src}
    1200. 

  1200.         DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${src}
    1201. 

  1201.         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    1202. 

  1202.         COMMENT "Generating ${html}")
    1203. 

  1203.       list(APPEND html-docs ${CMAKE_CURRENT_BINARY_DIR}/${dst})
    1204. 

  1204.     endif()
    1205. 

  1205.   endforeach()
    1206. 

  1206. endif()
    1207. 

  1207. 

  1208. if(ZMQ_BUILD_FRAMEWORK)
    1209. 

  1209.   add_custom_command(
    1210. 

  1210.     TARGET libzmq
    1211. 

  1211.     POST_BUILD
    1212. 

  1212.     COMMAND ${CMAKE_COMMAND} ARGS -E make_directory
    1213. 

  1213.             "${CMAKE_LIBRARY_OUTPUT_PATH}/ZeroMQ.framework/Versions/${ZMQ_VERSION}/MacOS"
    1214. 

  1214.     COMMENT "Perf tools")
    1215. 

  1215. endif()
    1216. 

  1216. 

  1217. option(ENABLE_PRECOMPILED "Enable precompiled headers, if possible" ON)
    1218. 

  1218. if(MSVC AND ENABLE_PRECOMPILED)
    1219. 

  1219.   # default for all sources is to use precompiled headers
    1220. 

  1220.   foreach(source ${sources})
    1221. 

  1221.     # C and C++ can not use the same precompiled header
    1222. 

  1222.     if(${source} MATCHES ".cpp$" AND NOT ${source} STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}/src/precompiled.cpp")
    1223. 

  1223.       set_source_files_properties(${source} PROPERTIES COMPILE_FLAGS "/Yuprecompiled.hpp" OBJECT_DEPENDS
    1224. 

  1224.                                                                                           precompiled.hpp)
    1225. 

  1225.     endif()
    1226. 

  1226.   endforeach()
    1227. 

  1227.   # create precompiled header
    1228. 

  1228.   set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/src/precompiled.cpp
    1229. 

  1229.                               PROPERTIES COMPILE_FLAGS "/Ycprecompiled.hpp" OBJECT_OUTPUTS precompiled.hpp)
    1230. 

  1230. endif()
    1231. 

  1231. 

  1232. # -----------------------------------------------------------------------------
    1233. 

  1233. # output
    1234. 

  1234. option(BUILD_SHARED "Whether or not to build the shared object" ON)
    1235. 

  1235. option(BUILD_STATIC "Whether or not to build the static archive" ON)
    1236. 

  1236. 

  1237. if(MSVC)
    1238. 

  1238.   # Suppress linker warnings caused by #ifdef omission of file content.
    1239. 

  1239.   set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /ignore:4221")
    1240. 

  1240.   set(PDB_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
    1241. 

  1241.   set(PDB_NAME
    1242. 

  1242.       "lib${ZMQ_OUTPUT_BASENAME}${MSVC_TOOLSET}-mt-gd-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}")
    1243. 

  1243.   function(enable_vs_guideline_checker target)
    1244. 

  1244.     set_target_properties(
    1245. 

  1245.       ${target} PROPERTIES VS_GLOBAL_EnableCppCoreCheck true VS_GLOBAL_CodeAnalysisRuleSet CppCoreCheckRules.ruleset
    1246. 

  1246.                            VS_GLOBAL_RunCodeAnalysis true)
    1247. 

  1247.   endfunction()
    1248. 

  1248.   if(BUILD_SHARED)
    1249. 

  1249.     add_library(libzmq SHARED ${sources} ${public_headers} ${html-docs} ${readme-docs}
    1250. 

  1250.                               ${CMAKE_CURRENT_BINARY_DIR}/NSIS.template.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
    1251. 

  1251.     if(ENABLE_ANALYSIS)
    1252. 

  1252.       enable_vs_guideline_checker(libzmq)
    1253. 

  1253.     endif()
    1254. 

  1254.     set_target_properties(
    1255. 

  1255.       libzmq
    1256. 

  1256.       PROPERTIES PUBLIC_HEADER "${public_headers}"
    1257. 

  1257.                  RELEASE_POSTFIX "${MSVC_TOOLSET}-mt-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
    1258. 

  1258.                  RELWITHDEBINFO_POSTFIX
    1259. 

  1259.                  "${MSVC_TOOLSET}-mt-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
    1260. 

  1260.                  MINSIZEREL_POSTFIX "${MSVC_TOOLSET}-mt-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
    1261. 

  1261.                  DEBUG_POSTFIX "${MSVC_TOOLSET}-mt-gd-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
    1262. 

  1262.                  RUNTIME_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}"
    1263. 

  1263.                  COMPILE_DEFINITIONS "DLL_EXPORT"
    1264. 

  1264.                  OUTPUT_NAME "lib${ZMQ_OUTPUT_BASENAME}")
    1265. 

  1265.     if(ZMQ_HAVE_WINDOWS_UWP)
    1266. 

  1266.       set_target_properties(libzmq PROPERTIES LINK_FLAGS_DEBUG "/OPT:NOICF /OPT:NOREF")
    1267. 

  1267.     endif()
    1268. 

  1268.   endif()
    1269. 

  1269. 

  1270.   if(BUILD_STATIC)
    1271. 

  1271.     add_library(libzmq-static STATIC ${sources} ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
    1272. 

  1272.     set_target_properties(
    1273. 

  1273.       libzmq-static
    1274. 

  1274.       PROPERTIES PUBLIC_HEADER "${public_headers}"
    1275. 

  1275.                  RELEASE_POSTFIX "${MSVC_TOOLSET}-mt-s-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
    1276. 

  1276.                  RELWITHDEBINFO_POSTFIX
    1277. 

  1277.                  "${MSVC_TOOLSET}-mt-s-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
    1278. 

  1278.                  MINSIZEREL_POSTFIX
    1279. 

  1279.                  "${MSVC_TOOLSET}-mt-s-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
    1280. 

  1280.                  DEBUG_POSTFIX "${MSVC_TOOLSET}-mt-sgd-${ZMQ_VERSION_MAJOR}_${ZMQ_VERSION_MINOR}_${ZMQ_VERSION_PATCH}"
    1281. 

  1281.                  COMPILE_FLAGS "/DZMQ_STATIC"
    1282. 

  1282.                  OUTPUT_NAME "lib${ZMQ_OUTPUT_BASENAME}")
    1283. 

  1283.   endif()
    1284. 

  1284. else()
    1285. 

  1285.   # avoid building everything twice for shared + static only on *nix, as Windows needs different preprocessor defines in
    1286. 

  1286.   # static builds
    1287. 

  1287.   if(NOT MINGW)
    1288. 

  1288.     add_library(objects OBJECT ${sources})
    1289. 

  1289.     set_property(TARGET objects PROPERTY POSITION_INDEPENDENT_CODE ON)
    1290. 

  1290.     target_include_directories(
    1291. 

  1291.       objects PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    1292. 

  1292.                      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}> $<INSTALL_INTERFACE:include>)
    1293. 

  1293.   endif()
    1294. 

  1294. 

  1295.   if(BUILD_SHARED)
    1296. 

  1296.     if(MINGW)
    1297. 

  1297.       add_library(libzmq SHARED ${sources} ${public_headers} ${html-docs} ${readme-docs} ${zmq-pkgconfig}
    1298. 

  1298.                                 ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
    1299. 

  1299.     else()
    1300. 

  1300.       add_library(libzmq SHARED $<TARGET_OBJECTS:objects> ${public_headers} ${html-docs} ${readme-docs}
    1301. 

  1301.                                 ${zmq-pkgconfig} ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
    1302. 

  1302.     endif()
    1303. 

  1303.     # NOTE: the SOVERSION and VERSION MUST be the same as the one generated by libtool! It is NOT the same as the
    1304. 

  1304.     # version of the package.
    1305. 

  1305.     set_target_properties(
    1306. 

  1306.       libzmq PROPERTIES COMPILE_DEFINITIONS "DLL_EXPORT" PUBLIC_HEADER "${public_headers}" VERSION "5.2.3"
    1307. 

  1307.                         SOVERSION "5" OUTPUT_NAME "${ZMQ_OUTPUT_BASENAME}" PREFIX "lib")
    1308. 

  1308.     if(ZMQ_BUILD_FRAMEWORK)
    1309. 

  1309.       set_target_properties(
    1310. 

  1310.         libzmq
    1311. 

  1311.         PROPERTIES FRAMEWORK TRUE MACOSX_FRAMEWORK_IDENTIFIER "org.zeromq.libzmq" MACOSX_FRAMEWORK_SHORT_VERSION_STRING
    1312. 

  1312.                                                                                   ${ZMQ_VERSION}
    1313. 

  1313.                    MACOSX_FRAMEWORK_BUNDLE_VERSION ${ZMQ_VERSION})
    1314. 

  1314.       set_source_files_properties(${html-docs} PROPERTIES MACOSX_PACKAGE_LOCATION doc)
    1315. 

  1315.       set_source_files_properties(${readme-docs} PROPERTIES MACOSX_PACKAGE_LOCATION etc)
    1316. 

  1316.       set_source_files_properties(${zmq-pkgconfig} PROPERTIES MACOSX_PACKAGE_LOCATION lib/pkgconfig)
    1317. 

  1317.     endif()
    1318. 

  1318.   endif()
    1319. 

  1319. 

  1320.   if(BUILD_STATIC)
    1321. 

  1321.     if(MINGW)
    1322. 

  1322.       add_library(libzmq-static STATIC ${sources} ${public_headers} ${html-docs} ${readme-docs} ${zmq-pkgconfig}
    1323. 

  1323.                                        ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
    1324. 

  1324.     else()
    1325. 

  1325.       add_library(libzmq-static STATIC $<TARGET_OBJECTS:objects> ${public_headers} ${html-docs} ${readme-docs}
    1326. 

  1326.                                        ${zmq-pkgconfig} ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
    1327. 

  1327.     endif()
    1328. 

  1328.     if(CMAKE_SYSTEM_NAME MATCHES "QNX")
    1329. 

  1329.       target_link_libraries(libzmq-static m)
    1330. 

  1330.     endif()
    1331. 

  1331.     set_target_properties(
    1332. 

  1332.       libzmq-static PROPERTIES PUBLIC_HEADER "${public_headers}" OUTPUT_NAME "${ZMQ_OUTPUT_BASENAME}" PREFIX "lib")
    1333. 

  1333.   endif()
    1334. 

  1334. endif()
    1335. 

  1335. 

  1336. if(BUILD_STATIC)
    1337. 

  1337.   target_compile_definitions(libzmq-static PUBLIC ZMQ_STATIC)
    1338. 

  1338. endif()
    1339. 

  1339. 

  1340. list(APPEND target_outputs "")
    1341. 

  1341. 

  1342. if(BUILD_SHARED)
    1343. 

  1343.   list(APPEND target_outputs "libzmq")
    1344. 

  1344. endif()
    1345. 

  1345. 

  1346. if(BUILD_STATIC)
    1347. 

  1347.   list(APPEND target_outputs "libzmq-static")
    1348. 

  1348. endif()
    1349. 

  1349. 

  1350. foreach(target ${target_outputs})
    1351. 

  1351.   target_include_directories(
    1352. 

  1352.     ${target} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
    1353. 

  1353.                      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}> $<INSTALL_INTERFACE:include>)
    1354. 

  1354. endforeach()
    1355. 

  1355. 

  1356. if(BUILD_SHARED)
    1357. 

  1357.   target_link_libraries(libzmq ${CMAKE_THREAD_LIBS_INIT})
    1358. 

  1358.   if(GNUTLS_FOUND)
    1359. 

  1359.     target_link_libraries(libzmq ${GNUTLS_LIBRARIES})
    1360. 

  1360.   endif()
    1361. 

  1361. 

  1362.   if(NSS3_FOUND)
    1363. 

  1363.     target_link_libraries(libzmq ${NSS3_LIBRARIES})
    1364. 

  1364.   endif()
    1365. 

  1365. 

  1366.   if(LIBBSD_FOUND)
    1367. 

  1367.     target_link_libraries(libzmq ${LIBBSD_LIBRARIES})
    1368. 

  1368.   endif()
    1369. 

  1369. 

  1370.   if(SODIUM_FOUND)
    1371. 

  1371.     target_link_libraries(libzmq ${SODIUM_LIBRARIES})
    1372. 

  1372.     # On Solaris, libsodium depends on libssp
    1373. 

  1373.     if(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
    1374. 

  1374.       target_link_libraries(libzmq ssp)
    1375. 

  1375.     endif()
    1376. 

  1376.   endif()
    1377. 

  1377. 

  1378.   if(HAVE_WS2_32)
    1379. 

  1379.     target_link_libraries(libzmq ws2_32)
    1380. 

  1380.   elseif(HAVE_WS2)
    1381. 

  1381.     target_link_libraries(libzmq ws2)
    1382. 

  1382.   endif()
    1383. 

  1383. 

  1384.   if(HAVE_RPCRT4)
    1385. 

  1385.     target_link_libraries(libzmq rpcrt4)
    1386. 

  1386.   endif()
    1387. 

  1387. 

  1388.   if(HAVE_IPHLAPI)
    1389. 

  1389.     target_link_libraries(libzmq iphlpapi)
    1390. 

  1390.   endif()
    1391. 

  1391. 

  1392.   if(RT_LIBRARY)
    1393. 

  1393.     target_link_libraries(libzmq -lrt)
    1394. 

  1394.   endif()
    1395. 

  1395. endif()
    1396. 

  1396. 

  1397. if(BUILD_STATIC)
    1398. 

  1398.   target_link_libraries(libzmq-static ${CMAKE_THREAD_LIBS_INIT})
    1399. 

  1399.   if(GNUTLS_FOUND)
    1400. 

  1400.     target_link_libraries(libzmq-static ${GNUTLS_LIBRARIES})
    1401. 

  1401.   endif()
    1402. 

  1402. 

  1403.   if(LIBBSD_FOUND)
    1404. 

  1404.     target_link_libraries(libzmq-static ${LIBBSD_LIBRARIES})
    1405. 

  1405.   endif()
    1406. 

  1406. 

  1407.   if(NSS3_FOUND)
    1408. 

  1408.     target_link_libraries(libzmq-static ${NSS3_LIBRARIES})
    1409. 

  1409.   endif()
    1410. 

  1410. 

  1411.   if(SODIUM_FOUND)
    1412. 

  1412.     target_link_libraries(libzmq-static ${SODIUM_LIBRARIES})
    1413. 

  1413.     # On Solaris, libsodium depends on libssp
    1414. 

  1414.     if(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
    1415. 

  1415.       target_link_libraries(libzmq-static ssp)
    1416. 

  1416.     endif()
    1417. 

  1417.   endif()
    1418. 

  1418. 

  1419.   if(HAVE_WS2_32)
    1420. 

  1420.     target_link_libraries(libzmq-static ws2_32)
    1421. 

  1421.   elseif(HAVE_WS2)
    1422. 

  1422.     target_link_libraries(libzmq-static ws2)
    1423. 

  1423.   endif()
    1424. 

  1424. 

  1425.   if(HAVE_RPCRT4)
    1426. 

  1426.     target_link_libraries(libzmq-static rpcrt4)
    1427. 

  1427.   endif()
    1428. 

  1428. 

  1429.   if(HAVE_IPHLAPI)
    1430. 

  1430.     target_link_libraries(libzmq-static iphlpapi)
    1431. 

  1431.   endif()
    1432. 

  1432. 

  1433.   if(RT_LIBRARY)
    1434. 

  1434.     target_link_libraries(libzmq-static -lrt)
    1435. 

  1435.   endif()
    1436. 

  1436. 

  1437.   if(CMAKE_SYSTEM_NAME MATCHES "QNX")
    1438. 

  1438.     add_definitions(-DUNITY_EXCLUDE_MATH_H)
    1439. 

  1439.   endif()
    1440. 

  1440. endif()
    1441. 

  1441. 

  1442. if(BUILD_SHARED)
    1443. 

  1443.   set(perf-tools
    1444. 

  1444.       local_lat
    1445. 

  1445.       remote_lat
    1446. 

  1446.       local_thr
    1447. 

  1447.       remote_thr
    1448. 

  1448.       inproc_lat
    1449. 

  1449.       inproc_thr
    1450. 

  1450.       proxy_thr)
    1451. 

  1451. 

  1452.   if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug") # Why?
    1453. 

  1453.     option(WITH_PERF_TOOL "Build with perf-tools" ON)
    1454. 

  1454.   else()
    1455. 

  1455.     option(WITH_PERF_TOOL "Build with perf-tools" OFF)
    1456. 

  1456.   endif()
    1457. 

  1457. 

  1458.   if(WITH_PERF_TOOL)
    1459. 

  1459.     foreach(perf-tool ${perf-tools})
    1460. 

  1460.       add_executable(${perf-tool} perf/${perf-tool}.cpp)
    1461. 

  1461.       target_link_libraries(${perf-tool} libzmq)
    1462. 

  1462. 

  1463.       if(GNUTLS_FOUND)
    1464. 

  1464.         target_link_libraries(${perf-tool} ${GNUTLS_LIBRARIES})
    1465. 

  1465.       endif()
    1466. 

  1466. 

  1467.       if(LIBBSD_FOUND)
    1468. 

  1468.         target_link_libraries(${perf-tool} ${LIBBSD_LIBRARIES})
    1469. 

  1469.       endif()
    1470. 

  1470. 

  1471.       if(NSS3_FOUND)
    1472. 

  1472.         target_link_libraries(${perf-tool} ${NSS3_LIBRARIES})
    1473. 

  1473.       endif()
    1474. 

  1474. 

  1475.       if(SODIUM_FOUND)
    1476. 

  1476.         target_link_libraries(${perf-tool} ${SODIUM_LIBRARIES})
    1477. 

  1477.       endif()
    1478. 

  1478. 

  1479.       if(ZMQ_BUILD_FRAMEWORK)
    1480. 

  1480.         # Copy perf-tools binaries into Framework
    1481. 

  1481.         add_custom_command(
    1482. 

  1482.           TARGET libzmq
    1483. 

  1483.           ${perf-tool} POST_BUILD
    1484. 

  1484.           COMMAND ${CMAKE_COMMAND} ARGS -E copy "$<TARGET_FILE:${perf-tool}>"
    1485. 

  1485.                   "${LIBRARY_OUTPUT_PATH}/ZeroMQ.framework/Versions/${ZMQ_VERSION_STRING}/MacOS/${perf-tool}"
    1486. 

  1486.           VERBATIM
    1487. 

  1487.           COMMENT "Perf tools")
    1488. 

  1488.       else()
    1489. 

  1489.         install(TARGETS ${perf-tool} RUNTIME DESTINATION bin COMPONENT PerfTools)
    1490. 

  1490.       endif()
    1491. 

  1491.       if(ZMQ_HAVE_WINDOWS_UWP)
    1492. 

  1492.         set_target_properties(${perf-tool} PROPERTIES LINK_FLAGS_DEBUG "/OPT:NOICF /OPT:NOREF")
    1493. 

  1493.       endif()
    1494. 

  1494.     endforeach()
    1495. 

  1495. 

  1496.     if(BUILD_STATIC)
    1497. 

  1497.       add_executable(benchmark_radix_tree perf/benchmark_radix_tree.cpp)
    1498. 

  1498.       target_link_libraries(benchmark_radix_tree libzmq-static)
    1499. 

  1499.       target_include_directories(benchmark_radix_tree PUBLIC "${CMAKE_CURRENT_LIST_DIR}/src")
    1500. 

  1500.       if(ZMQ_HAVE_WINDOWS_UWP)
    1501. 

  1501.         set_target_properties(benchmark_radix_tree PROPERTIES LINK_FLAGS_DEBUG "/OPT:NOICF /OPT:NOREF")
    1502. 

  1502.       endif()
    1503. 

  1503.     endif()
    1504. 

  1504.   elseif(WITH_PERF_TOOL)
    1505. 

  1505.     message(FATAL_ERROR "Shared library disabled - perf-tools unavailable.")
    1506. 

  1506.   endif()
    1507. 

  1507. endif()
    1508. 

  1508. 

  1509. # -----------------------------------------------------------------------------
    1510. 

  1510. # tests
    1511. 

  1511. 

  1512. option(BUILD_TESTS "Whether or not to build the tests" ON)
    1513. 

  1513. 

  1514. set(ZMQ_BUILD_TESTS
    1515. 

  1515.     ${BUILD_TESTS}
    1516. 

  1516.     CACHE BOOL "Build the tests for ZeroMQ")
    1517. 

  1517. 

  1518. if(ZMQ_BUILD_TESTS)
    1519. 

  1519.   enable_testing() # Enable testing only works in root scope
    1520. 

  1520.   add_subdirectory(tests)
    1521. 

  1521.   if(BUILD_STATIC)
    1522. 

  1522.     add_subdirectory(unittests)
    1523. 

  1523.   else()
    1524. 

  1524.     message(WARNING "Not building unit tests, since BUILD_STATIC is not enabled")
    1525. 

  1525.   endif()
    1526. 

  1526. endif()
    1527. 

  1527. 

  1528. # -----------------------------------------------------------------------------
    1529. 

  1529. # installer
    1530. 

  1530. 

  1531. if(MSVC AND (BUILD_SHARED OR BUILD_STATIC))
    1532. 

  1532.   install(
    1533. 

  1533.     TARGETS ${target_outputs}
    1534. 

  1534.     EXPORT ${PROJECT_NAME}-targets
    1535. 

  1535.     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
    1536. 

  1536.     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
    1537. 

  1537.     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    1538. 

  1538.     PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} COMPONENT SDK)
    1539. 

  1539.   if(MSVC_IDE)
    1540. 

  1540.     install(
    1541. 

  1541.       FILES ${PDB_OUTPUT_DIRECTORY}/\${CMAKE_INSTALL_CONFIG_NAME}/${PDB_NAME}.pdb
    1542. 

  1542.       DESTINATION ${CMAKE_INSTALL_BINDIR}
    1543. 

  1543.       COMPONENT SDK
    1544. 

  1544.       OPTIONAL)
    1545. 

  1545.   else()
    1546. 

  1546.     install(
    1547. 

  1547.       FILES ${PDB_OUTPUT_DIRECTORY}/${PDB_NAME}.pdb
    1548. 

  1548.       DESTINATION ${CMAKE_INSTALL_BINDIR}
    1549. 

  1549.       COMPONENT SDK
    1550. 

  1550.       OPTIONAL)
    1551. 

  1551.   endif()
    1552. 

  1552.   if(BUILD_SHARED)
    1553. 

  1553.     install(
    1554. 

  1554.       TARGETS libzmq
    1555. 

  1555.       RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    1556. 

  1556.       PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} COMPONENT Runtime)
    1557. 

  1557.   endif()
    1558. 

  1558. elseif(BUILD_SHARED OR BUILD_STATIC)
    1559. 

  1559.   install(
    1560. 

  1560.     TARGETS ${target_outputs}
    1561. 

  1561.     EXPORT ${PROJECT_NAME}-targets
    1562. 

  1562.     RUNTIME DESTINATION ${CMAKE…
    1563.