CMake build script updates

.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = space
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_size = 4
+tab_width = 4

.gitignore

@@ -1,3 +1,4 @@
+build*
 *.swp
 *~
 .gdb_history

.travis.yml

@@ -105,7 +105,7 @@ before_script:
 
 script:
     - cd build
-    - cmake --build . --target unittest
+    - cmake --build . --target test
     - ctest -D ExperimentalBuild -j${JOBS}
     - ctest -D ExperimentalMemCheck -j${JOBS}
     - bash <(curl -s https://codecov.io/bash)

CMakeLists.txt

@@ -1,15 +1,23 @@
 cmake_minimum_required(VERSION 3.3)
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
 project(Seasocks VERSION 1.4.3)
 
+if(WIN32)
+    message(FATAL_ERROR "${PROJECT_NAME} does not support Windows")
+endif()
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
+option(SEASOCKS_SHARED "Build shared Seasocks library" ON)
+option(SEASOCKS_STATIC "Build static Seasocks library" ON)
 option(UNITTESTS "Build unittests." ON)
 option(COVERAGE "Build with code coverage enabled" OFF)
 option(SEASOCKS_EXAMPLE_APP "Build the example applications." ON)
 option(DEFLATE_SUPPORT "Include support for deflate (requires zlib)." ON)
 
+if (NOT SEASOCKS_SHARED AND NOT SEASOCKS_STATIC)
+    message(FATAL_ERROR "SEASOCKS_SHARED and SEASOCKS_STATIC cannot both be false.")
+endif ()
+
 if (DEFLATE_SUPPORT)
     set(DEFLATE_SUPPORT_BOOL "true")
 else ()
@@ -29,39 +37,45 @@ set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Config.h.in internal/Config.h)
-include_directories(${CMAKE_CURRENT_BINARY_DIR})
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/Config.h.in internal/Config.h @ONLY)
 add_compile_options(-Wall -Werror -Wextra -pedantic -pedantic-errors)
 if (COVERAGE)
     add_compile_options(--coverage -O0)
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+    set(CMAKE_SHARED_LINKER_FLAGS "${SHARED_EXE_LINKER_FLAGS} --coverage")
 endif ()
 
 find_package(Threads)
+find_package(PythonInterp)
 
-
-find_program(PYTHON_BIN NAMES python python3 DOC "Python executable")
-
-if (NOT PYTHON_BIN)
+if (NOT PYTHONINTERP_FOUND)
     message(SEND_ERROR "Python not found")
 else()
-    message(STATUS "Using Python: '${PYTHON_BIN}'")
+    message(STATUS "Using Python: '${PYTHON_EXECUTABLE}'")
 endif ()
 
 if (DEFLATE_SUPPORT)
     find_package(ZLIB REQUIRED)
 endif ()
 
-add_subdirectory("src")
+add_subdirectory(src)
 
 include(CMakePackageConfigHelpers)
+configure_package_config_file(cmake/SeasocksConfig.cmake.in ${PROJECT_NAME}Config.cmake
+    INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}/"
+)
 write_basic_package_version_file(
     ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
     VERSION ${PROJECT_VERSION}
     COMPATIBILITY SameMajorVersion
 )
 
 install(FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
     ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}/
 )
+install(FILES
+    LICENSE
+    DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/licenses/${PROJECT_NAME}"
+)

cmake/Config.h.in

@@ -4,7 +4,7 @@ namespace seasocks {
 
     struct Config {
         static constexpr auto version = "@PROJECT_VERSION@";
-        static constexpr bool deflateEnabled = ${DEFLATE_SUPPORT_BOOL};
+        static constexpr bool deflateEnabled = @DEFLATE_SUPPORT_BOOL@;
     };
 
 }

cmake/SeasocksConfig.cmake.in

@@ -0,0 +1,14 @@
+set(SEASOCKS_SHARED @SEASOCKS_SHARED@)
+set(SEASOCKS_STATIC @SEASOCKS_STATIC@)
+set(SEASOCKS_DEFLATE_SUPPORT @DEFLATE_SUPPORT@)
+
+if(SEASOCKS_STATIC)
+    find_package(Threads REQUIRED)
+    if(SEASOCKS_DEFLATE_SUPPORT)
+        find_package(ZLIB REQUIRED)
+    endif()
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/SeasocksTargets.cmake")
+
+@PACKAGE_INIT@

conanfile.py

@@ -0,0 +1,82 @@
+from conans import CMake, ConanFile, tools
+from conans.errors import ConanException, ConanInvalidConfiguration
+import os
+import re
+import shutil
+import textwrap
+
+
+class SeasocksConan(ConanFile):
+    name = "seasocks"
+    def set_version(self):
+        cmakelists = tools.load(os.path.join(self.recipe_folder, "CMakeLists.txt"))
+        try:
+            m = next(re.finditer(r"project\(Seasocks VERSION ([0-9.]+)\)", cmakelists))
+        except StopIteration:
+            raise ConanException("Cannot detect Seasocks version from CMakeLists.txt")
+        self.version = m.group(1)
+    topics = ("seasocks", "embeddable", "webserver",  "websockets")
+    homepage = "https://github.com/mattgodbolt/seasocks"
+    url = "https://github.com/mattgodbolt/seasocks"
+    license = "BSD-2-Clause"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared": [True, False],
+        "static": [True, False],
+        "fPIC": [True, False],
+        "with_zlib": [True, False],
+    }
+    default_options = {
+        "shared": True,
+        "static": True,
+        "fPIC": True,
+        "with_zlib": True,
+    }
+    no_copy_source = True
+    generators = "cmake", "cmake_find_package"
+
+    def export_sources(self):
+        shutil.copytree("cmake", os.path.join(self.export_sources_folder, "cmake"))
+        shutil.copytree("scripts", os.path.join(self.export_sources_folder, "scripts"))
+        shutil.copytree("src", os.path.join(self.export_sources_folder, "src"))
+        shutil.copy("CMakeLists.txt", self.export_sources_folder)
+        shutil.copy("LICENSE", self.export_sources_folder)
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+
+    def configure(self):
+        if not self.options.static:
+            del self.options.fPIC
+        if not any((self.options.shared, self.options.static)):
+            raise ConanInvalidConfiguration("Need to build a shared and/or static library")
+
+    def requirements(self):
+        if self.options.with_zlib:
+            self.requires("zlib/1.2.11")
+
+    def build(self):
+        if self.source_folder == self.build_folder:
+            raise ConanException("Cannot build in same folder as sources")
+        tools.save(os.path.join(self.build_folder, "CMakeLists.txt"), textwrap.dedent("""\
+            cmake_minimum_required(VERSION 3.0)
+            project(cmake_wrapper)
+
+            include("{install_folder}/conanbuildinfo.cmake")
+            conan_basic_setup(TARGETS)
+
+            add_subdirectory("{source_folder}" seasocks)
+        """).format(
+            source_folder=self.source_folder.replace("\\", "/"),
+            install_folder=self.install_folder.replace("\\", "/")))
+        cmake = CMake(self)
+        cmake.definitions["SEASOCKS_SHARED"] = self.options.shared
+        cmake.definitions["SEASOCKS_STATIC"] = self.options.static
+        cmake.definitions["DEFLATE_SUPPORT"] = self.options.with_zlib
+        cmake.configure(source_folder=self.build_folder)
+        cmake.build()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()

scripts/gen_embedded.py

@@ -26,8 +26,7 @@
 }\n
 """
 
-MAX_SLICE = 70
-
+MAX_SLICE = 16
 
 def as_byte(data):
     if sys.version_info < (3,):
@@ -45,11 +44,12 @@ def parse_arguments():
 
 def create_file_byte(name, file_bytes):
     output = []
-    output.append('    const char %s[] = {' % name)
+    output.append('    const char %s[%d] = {\n' % (name, len(file_bytes) + 1))
 
     for start in range(0, len(file_bytes), MAX_SLICE):
-        output.append('' + "".join(["'\\x%02x'," % as_byte(x) for x in file_bytes[start:start+MAX_SLICE]]) + "\n")
-    output.append('0};\n')
+        output.append("        " + "".join("'\\x{:02x}',".format(as_byte(x)) for x in file_bytes[start:start+MAX_SLICE]) + "\n")
+    output.append('        0x00,\n')
+    output.append('    };\n')
     return ''.join(output)
 
 

src/CMakeLists.txt

@@ -1,14 +1,30 @@
 
-add_subdirectory("main/c")
-add_subdirectory("main/web")
+add_subdirectory(main/c)
+add_subdirectory(main/web)
+
+macro(add_seasocks_executable _name)
+    add_library(${_name}_objs OBJECT ${ARGN})
+    target_link_libraries(${_name}_objs PRIVATE seasocks_headers)
+    if (TARGET seasocks)
+        add_executable(${_name} $<TARGET_OBJECTS:${_name}_objs>)
+        target_link_libraries(${_name} PRIVATE seasocks)
+    endif ()
+    if (TARGET seasocks_so)
+        add_executable(${_name}_so $<TARGET_OBJECTS:${_name}_objs>)
+        target_link_libraries(${_name}_so PRIVATE seasocks_so)
+    endif ()
+endmacro()
+
+macro(seasocks_link_libraries _name)
+    target_link_libraries(${_name}_objs ${ARGN})
+endmacro()
 
 if (SEASOCKS_EXAMPLE_APP)
-  add_subdirectory("app/c")
+  add_subdirectory(app/c)
 endif ()
 
 if (UNITTESTS)
     find_program(CMAKE_MEMORYCHECK_COMMAND valgrind)
     enable_testing()
-    add_subdirectory("test/c")
+    add_subdirectory(test/c)
 endif ()
-

src/app/c/CMakeLists.txt

@@ -1,6 +1,5 @@
-macro(add_app _NAME)
-    add_executable(${_NAME} ${_NAME}.cpp)
-    target_link_libraries(${_NAME} seasocks "${ZLIB_LIBRARIES}")
+macro(add_app NAME)
+    add_seasocks_executable(${NAME} ${NAME}.cpp)
 endmacro()
 
 add_app(ph_test)
@@ -12,14 +11,21 @@ add_app(ws_test_poll)
 add_app(async_test)
 add_app(streaming_test)
 
-add_custom_command(TARGET ws_test POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_directory
-        ${PROJECT_SOURCE_DIR}/src/ws_test_web $<TARGET_FILE_DIR:ws_test>/src/ws_test_web)
+function(copy_directory_post_build TARGET SUBDIRECTORY)
+    set(name)
+    if (TARGET ${TARGET})
+        set(name ${TARGET})
+    elseif(TARGET ${TARGET}_so)
+        set(name ${TARGET}_so)
+    endif()
+    if (name)
+        add_custom_command(TARGET ${name} POST_BUILD
+            COMMAND "${CMAKE_COMMAND}" -E copy_directory
+                "${PROJECT_SOURCE_DIR}/${SUBDIRECTORY}" "$<TARGET_FILE_DIR:${name}>/${SUBDIRECTORY}"
+        )
+    endif ()
+endfunction()
 
-add_custom_command(TARGET async_test POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_directory
-        ${PROJECT_SOURCE_DIR}/src/async_test_web $<TARGET_FILE_DIR:async_test>/src/async_test_web)
-
-add_custom_command(TARGET ws_chatroom POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_directory
-        ${PROJECT_SOURCE_DIR}/src/ws_chatroom_web $<TARGET_FILE_DIR:ws_chatroom>/src/ws_chatroom_web)
+copy_directory_post_build(ws_test src/ws_test_web)
+copy_directory_post_build(async_test src/async_test_web)
+copy_directory_post_build(ws_chatroom src/ws_chatroom_web)