Remaining Contribs

CMakeLists.txt

@@ -22,7 +22,6 @@ set(CPACK_RESOURCE_FILE_README ${zlib_SOURCE_DIR}/README)
 option(ZLIB_BUILD_TESTING "Enable Zlib Examples as tests" ON)
 option(ZLIB_BUILD_SHARED "Enable building zlib shared library" ON)
 option(ZLIB_BUILD_STATIC "Enable building zlib static library" ON)
-option(ZLIB_BUILD_MINIZIP "Enable building libminizip contrib library" OFF)
 option(ZLIB_INSTALL "Enable installation of zlib" ON)
 option(ZLIB_PREFIX "prefix for all types and library functions, see zconf.h.in"
        OFF)
@@ -242,7 +241,7 @@ if(ZLIB_INSTALL)
         if(ZLIB_INSTALL_COMPAT_DLL)
             install(
                 FILES $<TARGET_FILE:zlib>
-                COMPONENT Runtime
+                COMPONENT Development
                 RENAME zlib1.dll
                 DESTINATION "${CMAKE_INSTALL_BINDIR}")
         endif(ZLIB_INSTALL_COMPAT_DLL)
@@ -325,6 +324,4 @@ if(ZLIB_BUILD_TESTING)
     add_subdirectory(test)
 endif(ZLIB_BUILD_TESTING)
 
-if(ZLIB_BUILD_MINIZIP)
-    add_subdirectory(contrib/minizip/)
-endif(ZLIB_BUILD_MINIZIP)
+add_subdirectory(contrib)

contrib/CMakeLists.txt

@@ -0,0 +1,49 @@
+function(zlib_add_contrib_lib name description dir)
+    option(ZLIB_BUILD_${name} "Enable building of ${description}" OFF)
+
+    if(ZLIB_BUILD_${name})
+        if(NOT DEFINED ZLIB_${name}_BUILD_SHARED)
+            set(ZLIB_${name}_BUILD_SHARED ${ZLIB_BUILD_SHARED} CACHE BOOL "")
+        endif(NOT DEFINED ZLIB_${name}_BUILD_SHARED)
+
+        if(NOT DEFINED ZLIB_${name}_BUILD_STATIC)
+            set(ZLIB_${name}_BUILD_STATIC ${ZLIB_BUILD_STATIC} CACHE BOOL "")
+        endif(NOT DEFINED ZLIB_${name}_BUILD_STATIC)
+
+        if(NOT DEFINED ZLIB_${name}_BUILD_TESTING)
+            set(ZLIB_${name}_BUILD_TESTING ${ZLIB_BUILD_TESTING} CACHE BOOL "")
+        endif(NOT DEFINED ZLIB_${name}_BUILD_TESTING)
+
+
+        if(NOT DEFINED ZLIB_${name}_INSTALL)
+            set(ZLIB_${name}_INSTALL ${ZLIB_INSTALL} CACHE BOOL "")
+        endif(NOT DEFINED ZLIB_${name}_INSTALL)
+
+        add_subdirectory(${dir}/)
+    endif(ZLIB_BUILD_${name})
+endfunction(zlib_add_contrib_lib name description dir)
+
+function(zlib_add_contrib_feature name description dir)
+    option(ZLIB_WITH_${name}
+           "Enable build ${description}"
+           OFF)
+
+    if(ZLIB_WITH_${name})
+        add_subdirectory(${dir}/)
+    endif(ZLIB_WITH_${name})
+endfunction(zlib_add_contrib_feature name description dir)
+
+zlib_add_contrib_feature("GVMAT64"
+    "of an optimized longest_match for 32 bits x86_64"
+    gcc_gvmat64)
+
+zlib_add_contrib_feature(INFBACK9 "with support for method 9 deflate" infback9)
+zlib_add_contrib_lib(ADA "Ada bindings" ada)
+zlib_add_contrib_lib(BLAST "blast binary" blast)
+zlib_add_contrib_lib(IOSTREAM3 "IOStream C++ bindings V3" iostream3)
+zlib_add_contrib_lib(MINIZIP "minizip library" minizip)
+zlib_add_contrib_lib(PUFF "puff decompress library" puff)
+
+if(WIN32)
+    zlib_add_contrib_lib(TESTZLIB "testzlib binary" testzlib)
+endif(WIN32)

contrib/ada/CMakeLists.txt

@@ -0,0 +1,217 @@
+cmake_minimum_required(VERSION 3.12...3.31)
+
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules")
+
+project(
+    zlibAda
+    VERSION 1.0.0
+    LANGUAGES ADA
+    DESCRIPTION "A library for creating zipfiles based in zlib"
+    HOMEPAGE_URL "https://www.zlib.net")
+
+option(ZLIB_ADA_BUILD_SHARED "Enable building ada bindings shared library" ON)
+option(ZLIB_ADA_BUILD_STATIC "Enable building ada bindings static library" ON)
+option(ZLIB_ADA_BUILD_TESTING "Enable building tests for ada bindings library" ON)
+
+if(WIN32 OR CYGWIN)
+    set(zlib_Ada_static_suffix "s")
+    set(CMAKE_DEBUG_POSTFIX "d")
+endif(WIN32 OR CYGWIN)
+
+if(NOT DEFINED ZLIB_BUILD_ADA)
+    if(ZLIB_ADA_BUILD_SHARED)
+        list(APPEND REQUIRED_COMPONENTS "shared")
+    endif(ZLIB_ADA_BUILD_SHARED)
+
+    if(ZLIB_ADA_BUILD_STATIC)
+        list(APPEND REQUIRED_COMPONENTS "static")
+    endif(ZLIB_ADA_BUILD_STATIC)
+
+    find_package(ZLIB REQUIRED COMPONENTS ${REQUIRED_COMPONENTS} CONFIG)
+endif(NOT DEFINED ZLIB_BUILD_ADA)
+
+function(ZLIB_ADA_findTestEnv testName)
+    set(testEnv "PATH=")
+
+    if(MSVC OR MINGW)
+        set(separator "\\\;")
+    else()
+        set(separator ":")
+    endif()
+
+    string(APPEND testEnv "$<TARGET_FILE_DIR:ZLIB::ZLIB>${separator}")
+    string(APPEND testEnv "$ENV{PATH}")
+
+    set_tests_properties(${testName} PROPERTIES ENVIRONMENT "${testEnv}")
+endfunction(ZLIB_ADA_findTestEnv testName)
+
+if(ZLIB_ADA_BUILD_SHARED)
+    ada_add_library(zlib_ada_Ada SHARED
+        zlib-thin.adb
+        zlib.adb)
+
+    set_target_properties(zlib_ada_Ada
+        PROPERTIES OUTPUT_NAME zlib-ada)
+
+    target_link_libraries(zlib_ada_Ada
+        INTERFACE ZLIB::ZLIB)
+
+    ada_add_library(zlib_ada_streams SHARED
+        zlib-streams.adb)
+
+    target_link_libraries(zlib_ada_streams
+        PUBLIC
+            zlib_ada_Ada)
+
+    ada_find_ali(zlib_ada_streams)
+
+    if(ZLIB_ADA_BUILD_TESTING)
+        enable_testing()
+        ada_add_executable(zlib_ada_test test.adb)
+
+        target_link_libraries(zlib_ada_test
+            PRIVATE
+                zlib_ada_Ada
+                zlib_ada_streams)
+
+        ada_find_ali(zlib_ada_test)
+
+        add_test(NAME zlib_ada_ada-test COMMAND zlib_ada_test)
+        set_tests_properties(zlib_ada_ada-test PROPERTIES FIXTURES_REQUIRED zlib_ada_cleanup)
+
+        if(MSVC
+           OR MSYS
+           OR MINGW
+           OR CYGWIN)
+            zlib_ada_findtestenv(zlib_ada_ada-test)
+        endif(
+            MSVC
+            OR MSYS
+            OR MINGW
+            OR CYGWIN)
+
+        ada_add_executable(zlib_ada_buffer_demo buffer_demo.adb)
+
+        target_link_libraries(zlib_ada_buffer_demo
+            PRIVATE
+                zlib_ada_Ada)
+
+        ada_find_ali(zlib_ada_buffer_demo)
+
+        add_test(NAME zlib_ada_buffer-demo COMMAND zlib_ada_buffer_demo)
+
+        if(MSVC
+           OR MSYS
+           OR MINGW
+           OR CYGWIN)
+            zlib_ada_findtestenv(zlib_ada_buffer-demo)
+        endif(
+            MSVC
+            OR MSYS
+            OR MINGW
+            OR CYGWIN)
+
+        ada_add_executable(zlib_ada_mtest mtest.adb)
+
+        target_link_libraries(zlib_ada_mtest
+            PRIVATE
+                zlib_ada_Ada)
+
+        ada_find_ali(zlib_ada_mtest)
+
+        #Not adding test as this is an endless-loop
+
+        ada_add_executable(zlib_ada_read read.adb)
+
+        target_link_libraries(zlib_ada_read
+            PRIVATE
+                zlib_ada_Ada)
+
+        ada_find_ali(zlib_ada_read)
+
+        add_test(NAME zlib_ada_read COMMAND zlib_ada_read)
+
+        if(MSVC
+           OR MSYS
+           OR MINGW
+           OR CYGWIN)
+            zlib_ada_findtestenv(zlib_ada_read)
+        endif(
+            MSVC
+            OR MSYS
+            OR MINGW
+            OR CYGWIN)
+    endif(ZLIB_ADA_BUILD_TESTING)
+endif(ZLIB_ADA_BUILD_SHARED)
+
+if(ZLIB_ADA_BUILD_STATIC)
+    ada_add_library(zlib_ada_AdaStatic STATIC
+        zlib-thin.adb
+        zlib.adb)
+
+    target_link_libraries(zlib_ada_AdaStatic
+        INTERFACE ZLIB::ZLIBSTATIC)
+
+    set_target_properties(zlib_ada_AdaStatic
+        PROPERTIES OUTPUT_NAME zlib-ada${zlib_Ada_static_suffix})
+
+    ada_add_library(zlib_ada_streamsStatic STATIC
+        zlib-streams.adb)
+
+    target_link_libraries(zlib_ada_streamsStatic
+        PUBLIC
+            zlib_ada_AdaStatic)
+
+    ada_find_ali(zlib_ada_streamsStatic)
+
+    if(ZLIB_ADA_BUILD_TESTING)
+        enable_testing()
+        ada_add_executable(zlib_ada_testStatic test.adb)
+
+        target_link_libraries(zlib_ada_testStatic
+            PRIVATE
+                zlib_ada_AdaStatic
+                zlib_ada_streamsStatic)
+
+        ada_find_ali(zlib_ada_testStatic)
+
+        add_test(NAME zlib_ada_testStatic COMMAND zlib_ada_testStatic)
+        set_tests_properties(zlib_ada_testStatic PROPERTIES FIXTURES_REQUIRED zlib_ada_cleanup)
+
+        ada_add_executable(zlib_ada_buffer-demoStatic buffer_demo.adb)
+
+        target_link_libraries(zlib_ada_buffer-demoStatic
+            PRIVATE
+                zlib_ada_AdaStatic)
+
+        ada_find_ali(zlib_ada_buffer-demoStatic)
+
+        add_test(NAME zlib_ada_buffer-demoStatic COMMAND zlib_ada_buffer-demoStatic)
+
+        ada_add_executable(zlib_ada_mtestStatic mtest.adb)
+
+        target_link_libraries(zlib_ada_mtestStatic
+            PRIVATE
+                zlib_ada_AdaStatic)
+
+        ada_find_ali(zlib_ada_mtestStatic)
+
+        # Not adding test as this is an endless-loop
+
+        ada_add_executable(zlib_ada_readStatic read.adb)
+
+        target_link_libraries(zlib_ada_readStatic
+            PRIVATE
+                zlib_ada_AdaStatic)
+
+        ada_find_ali(zlib_ada_readStatic)
+
+        add_test(NAME zlib_ada_readStatic COMMAND zlib_ada_readStatic)
+    endif(ZLIB_ADA_BUILD_TESTING)
+endif(ZLIB_ADA_BUILD_STATIC)
+
+if(ZLIB_ADA_BUILD_TESTING)
+    add_test(NAME zlib_ada_cleanup COMMAND ${CMAKE_COMMAND} -E rm ${CMAKE_CURRENT_BINARY_DIR}/testzlib.in
+        ${CMAKE_CURRENT_BINARY_DIR}/testzlib.out ${CMAKE_CURRENT_BINARY_DIR}/testzlib.zlb)
+    set_tests_properties(zlib_ada_cleanup PROPERTIES FIXTURES_CLEANUP zlib_ada_cleanup)
+endif(ZLIB_ADA_BUILD_TESTING)

contrib/ada/cmake/Modules/CMakeADACompiler.cmake.in

@@ -0,0 +1,23 @@
+set(CMAKE_ADA_COMPILER "@CMAKE_ADA_COMPILER@")
+set(CMAKE_ADA_COMPILER_ARG1 "@CMAKE_ADA_COMPILER_ARG1@")
+set(CMAKE_ADA_COMPILER_ID "@CMAKE_ADA_COMPILER_ID@")
+set(CMAKE_ADA_COMPILER_VERSION "@CMAKE_ADA_COMPILER_VERSION@")
+set(CMAKE_ADA_PLATFORM_ID "@CMAKE_ADA_PLATFORM_ID@")
+set(CMAKE_AR "@CMAKE_AR@")
+#set(CMAKE_RANLIB "@CMAKE_RANLIB@")
+#set(CMAKE_LINKER "@CMAKE_LINKER@")
+set(CMAKE_ADA_COMPILER_LOADED TRUE)
+set(CMAKE_ADA_COMPILER_WORKS @CMAKE_ADA_COMPILER_WORKS@)
+#set(CMAKE_ADA_ABI_COMPILED @CMAKE_ADA_ABI_COMPILED@)
+
+set(CMAKE_ADA_COMPILER_ENV_VAR "ADA")
+
+set(CMAKE_ADA_COMPILER_ID_RUN TRUE)
+set(CMAKE_ADA_SOURCE_FILE_EXTENSIONS adb;ADB)
+set(CMAKE_ADA_IGNORE_EXTENSIONS ;o;O;obj;OBJ;ali)
+
+set(CMAKE_ADA_BINDER_HELPER "@CMAKE_ADA_BINDER_HELPER@")
+set(CMAKE_ADA_COMPILER_HELPER "@CMAKE_ADA_COMPILER_HELPER@")
+set(CMAKE_ADA_EXE_LINK_HELPER "@CMAKE_ADA_EXE_LINK_HELPER@")
+set(CMAKE_ADA_SHARED_LINK_HELPER "@CMAKE_ADA_SHARED_LINK_HELPER@")
+set(CMAKE_ADA_STATIC_LINK_HELPER "@CMAKE_ADA_STATIC_LINK_HELPER@")