diff --git a/CMakeLists.txt b/CMakeLists.txt index aa7359121..66dd72818 100644 --- a/CMakeLists.txt +++ b/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 $ - 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) diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt new file mode 100644 index 000000000..8ec3bbd94 --- /dev/null +++ b/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) diff --git a/contrib/ada/CMakeLists.txt b/contrib/ada/CMakeLists.txt new file mode 100644 index 000000000..8922200cd --- /dev/null +++ b/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 "$${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) diff --git a/contrib/ada/cmake/Modules/CMakeADACompiler.cmake.in b/contrib/ada/cmake/Modules/CMakeADACompiler.cmake.in new file mode 100644 index 000000000..a3a4086b5 --- /dev/null +++ b/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@") diff --git a/contrib/ada/cmake/Modules/CMakeADAInformation.cmake b/contrib/ada/cmake/Modules/CMakeADAInformation.cmake new file mode 100644 index 000000000..923788f4d --- /dev/null +++ b/contrib/ada/cmake/Modules/CMakeADAInformation.cmake @@ -0,0 +1,133 @@ +include(CMakeLanguageInformation) + +set(CMAKE_ADA_OUTPUT_EXTENSION .o) +set(CMAKE_ADA_OUTPUT_EXTENSION_REPLACE TRUE) + +if(CMAKE_USER_MAKE_RULES_OVERRIDE) + include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}") +endif(CMAKE_USER_MAKE_RULES_OVERRIDE) + + +if(CMAKE_USER_MAKE_RULES_OVERRIDE_ADA) + include(${CMAKE_USER_MAKE_RULES_OVERRIDE_ADA} RESULT_VARIABLE _override) + set(CMAKE_USER_MAKE_RULES_OVERRIDE_ADA "${_override}") +endif(CMAKE_USER_MAKE_RULES_OVERRIDE_ADA) + +set(CMAKE_ADA_FLAGS_INIT "$ENV{ADAFLAGS} ${CMAKE_ADA_FLAGS_INIT}") + +string(APPEND CMAKE_ADA_FLAGS_INIT " ") +string(APPEND CMAKE_ADA_FLAGS_DEBUG_INIT " -g") +string(APPEND CMAKE_ADA_FLAGS_MINSIZEREL_INIT " -Os") +string(APPEND CMAKE_ADA_FLAGS_RELEASE_INIT " -O3") +string(APPEND CMAKE_ADA_FLAGS_RELWITHDEBINFO_INIT " -O2 -g") + +cmake_initialize_per_config_variable(CMAKE_ADA_FLAGS "Flags used by the Ada compiler") + +if(CMAKE_ADA_STANDARD_LIBRARIES_INIT) + set(CMAKE_ADA_STANDARD_LIBRARIES + "${CMAKE_ADA_STANDARD_LIBRARIES_INIT}" + CACHE + STRING "Libraries linked by default with all Ada applications.") + mark_as_advanced(CMAKE_ADA_STANDARD_LIBRARIES) +endif(CMAKE_ADA_STANDARD_LIBRARIES_INIT) + +if(NOT CMAKE_ADA_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_ADA_COMPILER_LAUNCHER}) + set(CMAKE_ADA_COMPILER_LAUNCHER + "$ENV{CMAKE_ADA_COMPILER_LAUNCHER}" + CACHE + STRING "Compiler launcher for Ada.") +endif(NOT CMAKE_ADA_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_ADA_COMPILER_LAUNCHER}) + +if(NOT CMAKE_ADA_LINKER_LAUNCHER AND DEFINED ENV{CMAKE_ADA_LINKER_LAUNCHER}) + set(CMAKE_ADA_LINKER_LAUNCHER + "$ENV{CMAKE_ADA_LINKER_LAUNCHER}" + CACHE + STRING "Linker launcher for Ada.") +endif(NOT CMAKE_ADA_LINKER_LAUNCHER AND DEFINED ENV{CMAKE_ADA_LINKER_LAUNCHER}) + +include(CMakeCommonLanguageInclude) +_cmake_common_language_platform_flags(ADA) + +if(NOT CMAKE_ADA_CREATE_SHARED_LIBRARY) + set(CMAKE_ADA_CREATE_SHARED_LIBRARY + "${CMAKE_ADA_BINDER_HELPER} FLAGS " + "${CMAKE_ADA_SHARED_LINK_HELPER} ") +endif(NOT CMAKE_ADA_CREATE_SHARED_LIBRARY) + +if(NOT CMAKE_ADA_CREATE_STATIC_LIBRARY) + set(CMAKE_ADA_CREATE_STATIC_LIBRARY + "${CMAKE_ADA_STATIC_LINK_HELPER} ${CMAKE_AR} ") +endif(NOT CMAKE_ADA_CREATE_STATIC_LIBRARY) + +if(NOT CMAKE_ADA_COMPILE_OBJECT) + set(CMAKE_ADA_COMPILE_OBJECT + "${CMAKE_ADA_COMPILER_HELPER} ") +endif(NOT CMAKE_ADA_COMPILE_OBJECT) + +if(NOT CMAKE_ADA_LINK_EXECUTABLE) + set(CMAKE_ADA_LINK_EXECUTABLE + "${CMAKE_ADA_BINDER_HELPER} FLAGS " + "${CMAKE_ADA_EXE_LINK_HELPER} OBJ LIBS ") +endif(NOT CMAKE_ADA_LINK_EXECUTABLE) + +function(ada_add_executable) + if(ARGC GREATER 1) + math(EXPR last_index "${ARGC} - 1") + foreach(source RANGE 1 ${last_index}) + list(APPEND SOURCES ${ARGV${source}}) + string(REPLACE ".adb" "" ali "${ARGV${source}}") + set(clean_file "CMakeFiles/${ARGV0}.dir/${ali}.ali") + list(APPEND CLEAN_FILES ${clean_file}) + list(APPEND CLEAN_FILES b~${ali}.adb) + list(APPEND CLEAN_FILES b~${ali}.ads) + list(APPEND CLEAN_FILES b~${ali}.ali) + list(APPEND CLEAN_FILES b~${ali}.o) + endforeach(source RANGE 1 ${ARGC}) + + add_executable(${ARGV0} ${ARGV1} ${SOURCES}) + + set_target_properties(${ARGV0} + PROPERTIES + ADDITIONAL_CLEAN_FILES "${CLEAN_FILES}") + endif(ARGC GREATER 1) +endfunction(ada_add_executable) + +function(ada_add_library) + if(ARGC GREATER 2) + math(EXPR last_index "${ARGC} - 1") + foreach(source RANGE 2 ${last_index}) + list(APPEND SOURCES ${ARGV${source}}) + string(REPLACE ".adb" "" ali "${ARGV${source}}") + set(clean_file "CMakeFiles/${ARGV0}.dir/${ali}.ali") + list(APPEND CLEAN_FILES ${clean_file}) + list(APPEND CLEAN_FILES b~${ali}.adb) + list(APPEND CLEAN_FILES b~${ali}.ads) + list(APPEND CLEAN_FILES b~${ali}.ali) + list(APPEND CLEAN_FILES b~${ali}.o) + endforeach(source RANGE 2 ${ARGC}) + + add_library(${ARGV0} ${ARGV1} ${SOURCES}) + + set_target_properties(${ARGV0} + PROPERTIES + ADDITIONAL_CLEAN_FILES "${CLEAN_FILES};dummylib.adb;dummylib.ali;dummylib.o" + ALI_FLAG "-aO${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${ARGV0}.dir/") + endif(ARGC GREATER 2) +endfunction(ada_add_library) + +function(ada_find_ali) + get_target_property(link_libs ${ARGV0} LINK_LIBRARIES) + + foreach(lib IN LISTS link_libs) + get_target_property(ali ${lib} ALI_FLAG) + string(APPEND FLAGS ${ali} " ") + unset(ali) + endforeach(lib IN LISTS link_libs) + + set_target_properties(${ARGV0} + PROPERTIES + LINK_FLAGS ${FLAGS}) +endfunction(ada_find_ali) + +set(CMAKE_ADA_INFORMATION_LOADED TRUE) diff --git a/contrib/ada/cmake/Modules/CMakeDetermineADACompiler.cmake b/contrib/ada/cmake/Modules/CMakeDetermineADACompiler.cmake new file mode 100644 index 000000000..1562a6c9c --- /dev/null +++ b/contrib/ada/cmake/Modules/CMakeDetermineADACompiler.cmake @@ -0,0 +1,33 @@ +include(${CMAKE_ROOT}/Modules/CMakeDetermineCompiler.cmake) + +# Load system-specific compiler preferences for this language. +include(Platform/${CMAKE_SYSTEM_NAME}-Determine-Ada OPTIONAL) +include(Platform/${CMAKE_SYSTEM_NAME}-Ada OPTIONAL) + +if(NOT CMAKE_ADA_COMPILER_NAMES) + set(CMAKE_ADA_COMPILER_NAMES gnat) + + foreach(ver RANGE 11 99) + list(APPEND CMAKE_ADA_COMPILER_NAMES gnat-${ver}) + endforeach(ver RANGE 11 99) +endif(NOT CMAKE_ADA_COMPILER_NAMES) + +if(NOT CMAKE_ADA_COMPILER) + set(CMAKE_ADA_COMPILER_INIT NOTFOUND) + _cmake_find_compiler(ADA) +else(NOT CMAKE_REAL_ADA_COMPILER) + _cmake_find_compiler_path(ADA) +endif(NOT CMAKE_ADA_COMPILER) + +mark_as_advanced(CMAKE_ADA_COMPILER) +set(CMAKE_ADA_COMPILER_ID "GNU") +set(CMAKE_ADA_BINDER_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/binder_helper.cmake") +set(CMAKE_ADA_COMPILER_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/compile_helper.cmake") +set(CMAKE_ADA_EXE_LINK_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/exe_link_helper.cmake") +set(CMAKE_ADA_SHARED_LINK_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/shared_link_helper.cmake") +set(CMAKE_ADA_STATIC_LINK_HELPER "${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/static_link_helper.cmake") + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/CMakeADACompiler.cmake.in + ${CMAKE_PLATFORM_INFO_DIR}/CMakeADACompiler.cmake + @ONLY) diff --git a/contrib/ada/cmake/Modules/CMakeTestADACompiler.cmake b/contrib/ada/cmake/Modules/CMakeTestADACompiler.cmake new file mode 100644 index 000000000..889c93c06 --- /dev/null +++ b/contrib/ada/cmake/Modules/CMakeTestADACompiler.cmake @@ -0,0 +1,46 @@ +include(CMakeTestCompilerCommon) +unset(CMAKE_ADA_COMPILER_WORKS CACHE) + +if(NOT CMAKE_ADA_COMPILER_WORKS) + PrintTestCompilerStatus("ADA" "") + set(_ADA_TEST_FILE "${CMAKE_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/CMakeTmp/main.adb") + + file(WRITE ${_ADA_TEST_FILE} + "with Ada.Text_IO; use Ada.Text_IO;\n" + "\n" + "procedure main is\n" + "begin\n" + "Put_Line(\"Hello, World!\");\n" + "end Main;\n") + + try_compile(CMAKE_ADA_COMPILER_WORKS ${CMAKE_BINARY_DIR} + ${_ADA_TEST_FILE} + OUTPUT_VARIABLE __CMAKE_ADA_COMPILER_OUTPUT) + + set(CMAKE_ADA_COMPILER_WORKS ${CMAKE_ADA_COMPILER_WORKS}) + unset(CMAKE_ADA_COMPILER_WORKS CACHE) + set(ADA_TEST_WAS_RUN TRUE) +endif(NOT CMAKE_ADA_COMPILER_WORKS) + +if(NOT CMAKE_ADA_COMPILER_WORKS) + PrintTestCompilerStatus("ADA" " -- broken") + + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log + "Determining if the Ada compiler works failed with " + "the following output:\n${__CMAKE_ADA_COMPILER_OUTPUT}\n\n") + + message(FATAL_ERROR "The Ada compiler \"${CMAKE_ADA_COMPILER}\" " + "is not able to compile a simple test program.\nIt fails " + "with the following output:\n ${__CMAKE_ADA_COMPILER_OUTPUT}\n\n" + "CMake will not be able to correctly generate this project.") +else(NOT CMAKE_ADA_COMPILER_WORKS) + if(ADA_TEST_WAS_RUN) + PrintTestCompilerStatus("ADA" " -- works") + + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log + "Determining if the Ada compiler works passed with " + "the following output:\n${__CMAKE_ADA_COMPILER_OUTPUT}\n\n") + endif(ADA_TEST_WAS_RUN) +endif(NOT CMAKE_ADA_COMPILER_WORKS) + +unset(__CMAKE_ADA_COMPILER_OUTPUT) diff --git a/contrib/ada/cmake/binder_helper.cmake b/contrib/ada/cmake/binder_helper.cmake new file mode 100644 index 000000000..87b320266 --- /dev/null +++ b/contrib/ada/cmake/binder_helper.cmake @@ -0,0 +1,47 @@ +#CMAKE_ARGV0 = /path/to/cmake +#CMAKE_ARGV1 = -P +#CMAKE_ARGV2 = path/to/this/file +#CMAKE_ARGV3 = binder +#CMAKE_ARGV4 = ali + +if(NOT CMAKE_ARGV3) + message(FATAL_ERROR "binder not set") +endif(NOT CMAKE_ARGV3) + +string(REPLACE ".o" ".ali" ALI ${CMAKE_ARGV4}) + +set (REACHED_FLAGS FALSE) +#iterate over additional objects, only the main one is needed +foreach(arg RANGE 5 ${CMAKE_ARGC}) + if(CMAKE_ARGV${arg} STREQUAL FLAGS) + set(REACHED_FLAGS TRUE) + continue() + endif(CMAKE_ARGV${arg} STREQUAL FLAGS) + + string(SUBSTRING "${CMAKE_ARGV${arg}}" 0 2 start) + + if(start STREQUAL "-O") + continue() + endif(start STREQUAL "-O") + + if(REACHED_FLAGS) + list(APPEND FLAGS ${CMAKE_ARGV${arg}}) + endif(REACHED_FLAGS) +endforeach(arg RANGE 5 CMAKE_ARGC) + +#first see if there is a main function +execute_process(COMMAND ${CMAKE_ARGV3} bind ${ALI} ${FLAGS} + RESULT_VARIABLE MAIN_RESULT + OUTPUT_VARIABLE dont_care + ERROR_VARIABLE ERROR) + +if(MAIN_RESULT) + execute_process(COMMAND ${CMAKE_ARGV3} bind -n ${ALI} ${FLAGS} + RESULT_VARIABLE RESULT + OUTPUT_VARIABLE dont_care + ERROR_VARIABLE ERROR) +endif(MAIN_RESULT) + +if(RESULT) + message(FATAL_ERROR ${RESULT} ${ERROR}) +endif(RESULT) diff --git a/contrib/ada/cmake/compile_helper.cmake b/contrib/ada/cmake/compile_helper.cmake new file mode 100644 index 000000000..fe4821e31 --- /dev/null +++ b/contrib/ada/cmake/compile_helper.cmake @@ -0,0 +1,32 @@ +#CMAKE_ARGV0 = /path/to/cmake +#CMAKE_ARGV1 = -P +#CMAKE_ARGV2 = path/to/this/file +#CMAKE_ARGV3 = compiler +#CMAKE_ARGV4 = OBJECT-DIR +#CMAKE_ARGV5 = source-file + +if(NOT CMAKE_ARGV3) + message(FATAL_ERROR "compiler not set") +endif(NOT CMAKE_ARGV3) + +if(NOT CMAKE_ARGV4) + message(FATAL_ERROR "object dir not set") +endif(NOT CMAKE_ARGV4) + +if(NOT CMAKE_ARGV5) + message(FATAL_ERROR "source not set") +endif(NOT CMAKE_ARGV5) + +foreach(arg RANGE 6 ${CMAKE_ARGC}) + list(APPEND FLAGS "${CMAKE_ARGV${arg}}") +endforeach(arg RANGE 6 ${CMAKE_ARGC}) + +execute_process(COMMAND ${CMAKE_ARGV3} compile ${FLAGS} ${CMAKE_ARGV5} + WORKING_DIRECTORY ${CMAKE_ARGV4} + RESULT_VARIABLE RESULT + OUTPUT_VARIABLE dont_care + ERROR_VARIABLE ERROR) + +if(RESULT) + message(FATAL_ERROR ${RESULT} ${ERROR}) +endif(RESULT) diff --git a/contrib/ada/cmake/exe_link_helper.cmake b/contrib/ada/cmake/exe_link_helper.cmake new file mode 100644 index 000000000..793789096 --- /dev/null +++ b/contrib/ada/cmake/exe_link_helper.cmake @@ -0,0 +1,53 @@ +#CMAKE_ARGV0 = /path/to/cmake +#CMAKE_ARGV1 = -P +#CMAKE_ARGV2 = path/to/this/file +#CMAKE_ARGV3 = linker +#CMAKE_ARGV4 = output-name +#CMAKE_ARGV5...CMAKE_AGVN = OBJECTS +#CMAKE_ARGVN+1 = LIBS +#CMAKE_ARGVN+2...CMAKE_ARGVM libraries + +if(NOT CMAKE_ARGV3) + message(FATAL_ERROR "linker not set") +endif(NOT CMAKE_ARGV3) + +set(REACHED_LIBS FALSE) +set(REACHED_OBJ FALSE) +foreach(arg RANGE 5 ${CMAKE_ARGC}) + if(CMAKE_ARGV${arg} STREQUAL LIBS) + set(REACHED_LIBS TRUE) + set(REACHED_OBJ FALSE) + continue() + endif(CMAKE_ARGV${arg} STREQUAL LIBS) + + if(CMAKE_ARGV${arg} STREQUAL OBJ) + set(REACHED_LIBS FALSE) + set(REACHED_OBJ TRUE) + continue() + endif(CMAKE_ARGV${arg} STREQUAL OBJ) + + if(CMAKE_ARGC EQUAL arg) + continue() + endif(CMAKE_ARGC EQUAL arg) + + if(REACHED_LIBS) + list(APPEND LIBS "${CMAKE_ARGV${arg}}") + elseif(REACHED_OBJ AND NOT ALI) + string(REPLACE ".o" ".ali" ALI "${CMAKE_ARGV${arg}}") + else(REACHED_LIBS) + string(SUBSTRING "${CMAKE_ARGV${arg}}" 0 3 start) + + if(NOT start STREQUAL -aO) + list(APPEND FLAGS "${CMAKE_ARGV${arg}}") + endif(NOT start STREQUAL -aO) + endif(REACHED_LIBS) +endforeach(arg RANGE 5 ${CMAKE_ARGC}) + +execute_process(COMMAND ${CMAKE_ARGV3} link ${ALI} -o ${CMAKE_ARGV4} ${FLAGS} ${OTHER_OBJECTS} ${LIBS} + RESULT_VARIABLE RESULT + OUTPUT_VARIABLE dont_care + ERROR_VARIABLE ERROR) + +if(RESULT) + message(FATAL_ERROR ${RESULT} ${ERROR}) +endif(RESULT) diff --git a/contrib/ada/cmake/shared_link_helper.cmake b/contrib/ada/cmake/shared_link_helper.cmake new file mode 100644 index 000000000..baea9a1ad --- /dev/null +++ b/contrib/ada/cmake/shared_link_helper.cmake @@ -0,0 +1,52 @@ +#CMAKE_ARGV0 = /path/to/cmake +#CMAKE_ARGV1 = -P +#CMAKE_ARGV2 = path/to/this/file +#CMAKE_ARGV3 = linker +#CMAKE_ARGV4 = output-name +#CMAKE_ARGV5...CMAKE_AGVN = OBJECTS +#CMAKE_ARGVN+1 = LIBS +#CMAKE_ARGVN+2...CMAKE_ARGVM libraries + +if(NOT CMAKE_ARGV3) + message(FATAL_ERROR "linker not set") +endif(NOT CMAKE_ARGV3) + +set(REACHED_FILES FALSE) +foreach(arg RANGE 5 ${CMAKE_ARGC}) + if(CMAKE_ARGV${arg} STREQUAL "LIBS") + set(REACHED_FILES TRUE) + continue() + endif(CMAKE_ARGV${arg} STREQUAL "LIBS") + + if(CMAKE_ARGC EQUAL arg) + continue() + endif(CMAKE_ARGC EQUAL arg) + + if(REACHED_LIBS) + list(APPEND LIBS "${CMAKE_ARGV${arg}} ") + else(REACHED_LIBS) + list(APPEND OBJECT_FILES "${CMAKE_ARGV${arg}}") + endif(REACHED_LIBS) +endforeach(arg RANGE 5 ${CMAKE_ARGC}) + +file(WRITE dummylib.adb + "procedure dummylib is\n" + "begin\n" + " null;\n" + "end;\n") + +execute_process(COMMAND ${CMAKE_ARGV3} compile -fPIC dummylib.adb + OUTPUT_VARIABLE dont_care + ERROR_VARIABLE ERROR) +execute_process(COMMAND ${CMAKE_ARGV3} bind -n dummylib.ali + OUTPUT_VARIABLE dont_care + ERROR_VARIABLE ERROR) + +execute_process(COMMAND ${CMAKE_ARGV3} link -shared dummylib.ali -o ${CMAKE_ARGV4} ${OBJECT_FILES} ${LIBS} + RESULT_VARIABLE RESULT + OUTPUT_VARIABLE dont_care + ERROR_VARIABLE ERROR) + +if(RESULT) + message(FATAL_ERROR ${RESULT} ${ERROR}) +endif(RESULT) diff --git a/contrib/ada/cmake/static_link_helper.cmake b/contrib/ada/cmake/static_link_helper.cmake new file mode 100644 index 000000000..eb3ff2bbf --- /dev/null +++ b/contrib/ada/cmake/static_link_helper.cmake @@ -0,0 +1,25 @@ +#CMAKE_ARGV0 = /path/to/cmake +#CMAKE_ARGV1 = -P +#CMAKE_ARGV2 = path/to/this/file +#CMAKE_ARGV3 = path/to/ar +#CMAKE_ARGV4 = output-name +#CMAKE_ARGV5...CMAKE_AGVN = OBJECTS + +if(NOT CMAKE_ARGV3) + message(FATAL_ERROR "linker not set") +endif(NOT CMAKE_ARGV3) + +foreach(arg RANGE 5 ${CMAKE_ARGC}) + if(NOT CMAKE_ARGC EQUAL arg) + list(APPEND OBJECT_FILES "${CMAKE_ARGV${arg}}") + endif(NOT CMAKE_ARGC EQUAL arg) +endforeach(arg RANGE 6 ${CMAKE_ARGC}) + +execute_process(COMMAND ${CMAKE_ARGV3} rcs ${CMAKE_ARGV4} ${OBJECT_FILES} + RESULT_VARIABLE RESULT + OUTPUT_VARIABLE dont_care + ERROR_VARIABLE ERROR) + +if(RESULT) + message(FATAL_ERROR ${RESULT} ${ERROR}) +endif(RESULT) diff --git a/contrib/blast/CMakeLists.txt b/contrib/blast/CMakeLists.txt new file mode 100644 index 000000000..9b20fdada --- /dev/null +++ b/contrib/blast/CMakeLists.txt @@ -0,0 +1,166 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + blast + VERSION 1.3.0 + LANGUAGES C + DESCRIPTION "A library for creating zipfiles based in zlib" + HOMEPAGE_URL "https://www.zlib.net") + +option(ZLIB_BLAST_BUILD_SHARED "Enable building blast shared library" ON) +option(ZLIB_BLAST_BUILD_STATIC "Enable building blast static library" ON) +option(ZLIB_BLAST_BUILD_TESTING "Enable building tests for blast" ON) +option(ZLIB_BLAST_INSTALL "Enable installation of blast" ON) + +include(GNUInstallDirs) +include(CMakePackageConfigHelpers) + +if(WIN32 OR CYGWIN) + set(zlibblast_static_suffix "s") + set(CMAKE_DEBUG_POSTFIX "d") + set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) +endif(WIN32 OR CYGWIN) + +function(blast_findTestEnv testName) + set(testEnv "PATH=") + + if(MSVC OR MINGW) + set(separator "\\\;") + else() + set(separator ":") + endif() + + string(APPEND testEnv "$${separator}") + string(APPEND testEnv "$ENV{PATH}") + + set_tests_properties(${testName} PROPERTIES ENVIRONMENT "${testEnv}") +endfunction(blast_findTestEnv testName) + +if(ZLIB_BLAST_BUILD_SHARED) + add_library(zlib_blast_blast SHARED + blast.c + blast.h) + + add_library(BLAST::BLAST ALIAS zlib_blast_blast) + + if(NOT CYGWIN) + set_target_properties(zlib_blast_blast + PROPERTIES + SOVERSION ${blast_VERSION_MAJOR} + VERSION ${blast_VERSION}) + endif(NOT CYGWIN) + + set_target_properties(zlib_blast_blast + PROPERTIES + EXPORT_NAME BLAST + OUTPUT_NAME blast) + + if(ZLIB_BLAST_BUILD_TESTING) + enable_testing() + add_executable(zlib_blast_blast-test blast-test.c) + target_link_libraries(zlib_blast_blast-test PRIVATE zlib_blast_blast) + + add_test(NAME zlib_blast_blast-test + COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/tester.cmake + "$" + "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_BINARY_DIR}") + + if(MSVC + OR MSYS + OR MINGW + OR CYGWIN) + blast_findtestenv(zlib_blast_blast-test) + endif( + MSVC + OR MSYS + OR MINGW + OR CYGWIN) + endif(ZLIB_BLAST_BUILD_TESTING) +endif(ZLIB_BLAST_BUILD_SHARED) + +if(ZLIB_BLAST_BUILD_STATIC) + add_library(zlib_blast_blastStatic STATIC + blast.c + blast.h) + + add_library(BLAST::BLASTSTATIC ALIAS zlib_blast_blastStatic) + + set_target_properties(zlib_blast_blastStatic + PROPERTIES + EXPORT_NAME BLASTSTATIC + OUTPUT_NAME blast${zlibblast_static_suffix}) + + if(ZLIB_BLAST_BUILD_TESTING) + enable_testing() + add_executable(zlib_blast_testStatic blast-test.c) + target_link_libraries(zlib_blast_testStatic + PRIVATE zlib_blast_blastStatic) + + add_test(NAME zlib_blast_testStatic + COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/tester.cmake + "$" + "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_BINARY_DIR}") + endif(ZLIB_BLAST_BUILD_TESTING) +endif(ZLIB_BLAST_BUILD_STATIC) + +if(ZLIB_BLAST_BUILD_TESTING) + add_subdirectory(test) +endif(ZLIB_BLAST_BUILD_TESTING) + +if(ZLIB_BLAST_INSTALL) + if(ZLIB_BLAST_BUILD_SHARED) + install( + TARGETS zlib_blast_blast + COMPONENT Runtime + EXPORT zlibBlastSharedExport + RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}") + install( + EXPORT zlibBlastSharedExport + FILE blast-shared.cmake + NAMESPACE BLAST:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/blast) + + if(MSVC) + install( + FILES $ + COMPONENT Development + DESTINATION ${CMAKE_INSTALL_BINDIR} + CONFIGURATIONS Debug OR RelWithDebInfo + OPTIONAL) + endif(MSVC) + endif(ZLIB_BLAST_BUILD_SHARED) + + if(ZLIB_BLAST_BUILD_STATIC) + install( + TARGETS zlib_blast_blastStatic + COMPONENT Development + EXPORT zlibBlastStaticExport + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}") + install( + EXPORT zlibBlastStaticExport + FILE blast-static.cmake + NAMESPACE BLAST:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/blast) + endif(ZLIB_BLAST_BUILD_STATIC) + + configure_package_config_file( + ${blast_SOURCE_DIR}/blastConfig.cmake.in + ${blast_BINARY_DIR}/blastConfig.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/blast) + + write_basic_package_version_file( + "${blast_BINARY_DIR}/blastConfigVersion.cmake" + VERSION "${blast_VERSION}" + COMPATIBILITY AnyNewerVersion) + + install(FILES ${blast_BINARY_DIR}/blastConfig.cmake + ${blast_BINARY_DIR}/blastConfigVersion.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/blast) + install( + FILES blast.h + COMPONENT Development + DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") +endif(ZLIB_BLAST_INSTALL) diff --git a/contrib/blast/Makefile b/contrib/blast/Makefile index 9be80bafe..f64848b36 100644 --- a/contrib/blast/Makefile +++ b/contrib/blast/Makefile @@ -1,8 +1,14 @@ -blast: blast.c blast.h - cc -DTEST -o blast blast.c +all: test -test: blast - blast < test.pk | cmp - test.txt +libblast.so: blast.c blast.h + cc -o libblast.so -shared blast.c + +blast-test: libblast.so + cc -o blast-test.o -c blast-test.c + cc -o blast-test blast-test.o libblast.so + +test: blast-test + LD_LIBRARY_PATH=./ ./blast-test < test.pk | cmp - test.txt clean: - rm -f blast blast.o + rm -f libblast.so blast-test blast-test.o diff --git a/contrib/blast/blast-test.c b/contrib/blast/blast-test.c new file mode 100644 index 000000000..471dfd6d8 --- /dev/null +++ b/contrib/blast/blast-test.c @@ -0,0 +1,42 @@ +#include "blast.h" /* prototype for blast() */ + +/* Example of how to use blast() */ +#include +#include + +#define CHUNK 16384 + +local unsigned inf(void *how, unsigned char **buf) +{ + static unsigned char hold[CHUNK]; + + *buf = hold; + return fread(hold, 1, CHUNK, (FILE *)how); +} + +local int outf(void *how, unsigned char *buf, unsigned len) +{ + return fwrite(buf, 1, len, (FILE *)how) != len; +} + +/* Decompress a PKWare Compression Library stream from stdin to stdout */ +int main(void) +{ + int ret; + unsigned left; + + /* decompress to stdout */ + left = 0; + ret = blast(inf, stdin, outf, stdout, &left, NULL); + if (ret != 0) + fprintf(stderr, "blast error: %d\n", ret); + + /* count any leftover bytes */ + while (getchar() != EOF) + left++; + if (left) + fprintf(stderr, "blast warning: %u unused bytes of input\n", left); + + /* return blast() error code */ + return ret; +} diff --git a/contrib/blast/blast.c b/contrib/blast/blast.c index e6e659073..3f6963f89 100644 --- a/contrib/blast/blast.c +++ b/contrib/blast/blast.c @@ -33,7 +33,6 @@ #include /* for setjmp(), longjmp(), and jmp_buf */ #include "blast.h" /* prototype for blast() */ -#define local static /* for local function definitions */ #define MAXBITS 13 /* maximum code length */ #define MAXWIN 4096 /* maximum window size */ @@ -421,46 +420,3 @@ int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow, err = 1; return err; } - -#ifdef TEST -/* Example of how to use blast() */ -#include -#include - -#define CHUNK 16384 - -local unsigned inf(void *how, unsigned char **buf) -{ - static unsigned char hold[CHUNK]; - - *buf = hold; - return fread(hold, 1, CHUNK, (FILE *)how); -} - -local int outf(void *how, unsigned char *buf, unsigned len) -{ - return fwrite(buf, 1, len, (FILE *)how) != len; -} - -/* Decompress a PKWare Compression Library stream from stdin to stdout */ -int main(void) -{ - int ret; - unsigned left; - - /* decompress to stdout */ - left = 0; - ret = blast(inf, stdin, outf, stdout, &left, NULL); - if (ret != 0) - fprintf(stderr, "blast error: %d\n", ret); - - /* count any leftover bytes */ - while (getchar() != EOF) - left++; - if (left) - fprintf(stderr, "blast warning: %u unused bytes of input\n", left); - - /* return blast() error code */ - return ret; -} -#endif diff --git a/contrib/blast/blast.h b/contrib/blast/blast.h index ef8544c53..c5ef7ab5e 100644 --- a/contrib/blast/blast.h +++ b/contrib/blast/blast.h @@ -21,6 +21,7 @@ Mark Adler madler@alumni.caltech.edu */ +#define local static /* for local function definitions */ /* * blast() decompresses the PKWare Data Compression Library (DCL) compressed diff --git a/contrib/blast/blastConfig.cmake.in b/contrib/blast/blastConfig.cmake.in new file mode 100644 index 000000000..5909ac4f5 --- /dev/null +++ b/contrib/blast/blastConfig.cmake.in @@ -0,0 +1,18 @@ +@PACKAGE_INIT@ + +set(_blast_supported_components "shared" "static") + +if(blast_FIND_COMPONENTS) + foreach(_comp ${blast_FIND_COMPONENTS}) + if(NOT _comp IN_LIST _blast_supported_components) + set(blast_FOUND False) + set(blast_NOT_FOUND_MESSAGE "Unsupported component: ${_comp}") + endif(NOT _comp IN_LIST _blast_supported_components) + + include("${CMAKE_CURRENT_LIST_DIR}/blast-${_comp}.cmake") + endforeach(_comp ${blast_FIND_COMPONENTS}) +else(blast_FIND_COMPONENTS) + foreach(_component_config IN LISTS _blast_supported_components) + include("${CMAKE_CURRENT_LIST_DIR}/blast-${_component_config}.cmake") + endforeach(_component_config IN LISTS _blast_supported_components) +endif(blast_FIND_COMPONENTS) diff --git a/contrib/blast/test/CMakeLists.txt b/contrib/blast/test/CMakeLists.txt new file mode 100644 index 000000000..3940c1cc6 --- /dev/null +++ b/contrib/blast/test/CMakeLists.txt @@ -0,0 +1,193 @@ +# if we are built from with zlib, use this path's) +if(DEFINED ZLIB_BUILD_BLAST) + set(WORK_DIR ${zlib_BINARY_DIR}) + set(inst_setup zlib_install) +else(DEFINED ZLIB_BUILD_BLAST) + set(WORK_DIR ${blast_BINARY_DIR}) + set(inst_setup zlib_blast_install) + set(ZLIB_ARG "-DZLIB_DIR=${ZLIB_DIR}") + + add_test( + NAME zlib_blast_install + COMMAND ${CMAKE_COMMAND} --install ${blast_BINARY_DIR} --prefix + ${CMAKE_CURRENT_BINARY_DIR}/test_install --config $ + WORKING_DIRECTORY ${blast_BINARY_DIR}) + + set_tests_properties(zlib_blast_install + PROPERTIES + FIXTURES_SETUP zlib_blast_install) +endif(DEFINED ZLIB_BUILD_BLAST) + +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test) +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test) +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/find_package_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test/CMakeLists.txt @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/add_subdirectory_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test/CMakeLists.txt @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/add_subdirectory_exclude_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test/CMakeLists.txt + @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/find_package_no_components_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test/CMakeLists.txt + @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/find_package_wrong_components_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test/CMakeLists.txt + @ONLY) + +# CMAKE_GENERATOR_PLATFORM doesn't work in the if +set(GENERATOR ${CMAKE_GENERATOR_PLATFORM}) + +if(GENERATOR) + set(PLATFORM "-A ${GENERATOR}") +endif(GENERATOR) + +# +# findpackage_test +# +add_test( + NAME zlib_blast_find_package_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_test_build + -DCMAKE_BUILD_TYPE=$ + -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_test) + +add_test( + NAME zlib_blast_find_package_build + COMMAND ${CMAKE_COMMAND} --build . --config $ + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test_build) + +set_tests_properties( + zlib_blast_find_package_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + FIXTURES_SETUP blast_fp_config) + +set_tests_properties(zlib_blast_find_package_build + PROPERTIES + FIXTURES_REQUIRED blast_fp_config) + +# +# add_subdirectory_test +# +add_test( + NAME zlib_blast_add_subdirectory_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test_build + -DCMAKE_BUILD_TYPE=$ + -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test) + +add_test( + NAME zlib_blast_add_subdirectory_build + COMMAND ${CMAKE_COMMAND} --build . --config $ + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test_build) + +set_tests_properties( + zlib_blast_add_subdirectory_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + FIXTURES_SETUP blast_as_config) + +set_tests_properties(zlib_blast_add_subdirectory_build + PROPERTIES + FIXTURES_REQUIRED blast_as_config) + +# +# add_subdirectory_exclude_test +# +add_test( + NAME zlib_blast_add_subdirectory_exclude_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test_build + -DCMAKE_BUILD_TYPE=$ + -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test) + +add_test( + NAME zlib_blast_add_subdirectory_exclude_build + COMMAND ${CMAKE_COMMAND} --build . --config $ + WORKING_DIRECTORY + ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test_build) + +set_tests_properties(zlib_blast_add_subdirectory_exclude_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + FIXTURES_SETUP blast_asx_config) + +set_tests_properties(zlib_blast_add_subdirectory_exclude_build + PROPERTIES + FIXTURES_REQUIRED blast_asx_config) + +# +# findpackage_no_components_test +# +add_test( + NAME zlib_blast_find_package_no_components_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test_build + -DCMAKE_BUILD_TYPE=$ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test) + +set_tests_properties( + zlib_blast_find_package_no_components_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup}) + +if(NOT ZLIB_BLAST_BUILD_SHARED OR NOT ZLIB_BLAST_BUILD_STATIC) + set_tests_properties(zlib_blast_find_package_no_components_configure + PROPERTIES + WILL_FAIL TRUE) +endif(NOT ZLIB_BLAST_BUILD_SHARED OR NOT ZLIB_BLAST_BUILD_STATIC) + +# +# findpackage_no_components_test +# +add_test( + NAME zlib_blast_find_package_wrong_components_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test_build + -DCMAKE_BUILD_TYPE=$ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test) + +set_tests_properties(zlib_blast_find_package_wrong_components_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + WILL_FAIL TRUE) + diff --git a/contrib/blast/test/add_subdirectory_exclude_test.cmake.in b/contrib/blast/test/add_subdirectory_exclude_test.cmake.in new file mode 100644 index 000000000..fd6b48728 --- /dev/null +++ b/contrib/blast/test/add_subdirectory_exclude_test.cmake.in @@ -0,0 +1,27 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + blast_find_package + LANGUAGES C + VERSION @blast_VERSION@) + +option(ZLIB_BLAST_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_BLAST_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) +option(ZLIB_BLAST_BUILD_TESTING "" @ZLIB_BLAST_BUILD_TESTING@) + +add_subdirectory(@blast_SOURCE_DIR@ + ${CMAKE_CURRENT_BINARY_DIR}/blast + EXCLUDE_FROM_ALL) + +set(BLAST_SRCS + @blast_SOURCE_DIR@/blast-test.c) + +if(ZLIB_BLAST_BUILD_SHARED) + add_executable(test_example ${BLAST_SRCS}) + target_link_libraries(test_example BLAST::BLAST) +endif(ZLIB_BLAST_BUILD_SHARED) + +if(ZLIB_BLAST_BUILD_STATIC) + add_executable(test_example_static ${BLAST_SRCS}) + target_link_libraries(test_example_static BLAST::BLASTSTATIC) +endif(ZLIB_BLAST_BUILD_STATIC) diff --git a/contrib/blast/test/add_subdirectory_test.cmake.in b/contrib/blast/test/add_subdirectory_test.cmake.in new file mode 100644 index 000000000..8b9370f01 --- /dev/null +++ b/contrib/blast/test/add_subdirectory_test.cmake.in @@ -0,0 +1,25 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + blast_find_package + LANGUAGES C + VERSION @blast_VERSION@) + +option(ZLIB_BLAST_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_BLAST_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) +option(ZLIB_BLAST_BUILD_TESTING "" @ZLIB_BLAST_BUILD_TESTING@) + +add_subdirectory(@blast_SOURCE_DIR@ ${CMAKE_CURRENT_BINARY_DIR}/blast) + +set(BLAST_SRCS + @blast_SOURCE_DIR@/blast-test.c) + +if(ZLIB_BLAST_BUILD_SHARED) + add_executable(test_example ${BLAST_SRCS}) + target_link_libraries(test_example BLAST::BLAST) +endif(ZLIB_BLAST_BUILD_SHARED) + +if(ZLIB_BLAST_BUILD_STATIC) + add_executable(test_example_static ${BLAST_SRCS}) + target_link_libraries(test_example_static BLAST::BLASTSTATIC) +endif(ZLIB_BLAST_BUILD_STATIC) diff --git a/contrib/blast/test/find_package_no_components_test.cmake.in b/contrib/blast/test/find_package_no_components_test.cmake.in new file mode 100644 index 000000000..f7054ff9c --- /dev/null +++ b/contrib/blast/test/find_package_no_components_test.cmake.in @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + blast_find_package + LANGUAGES C + VERSION @blast_VERSION@) + +option(ZLIB_BLAST_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_BLAST_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +find_package(blast REQUIRED CONFIG) + +set(BLAST_SRCS + @blast_SOURCE_DIR@/blast-test.c) + +if(ZLIB_BLAST_BUILD_SHARED) + add_executable(test_example ${BLAST_SRCS}) + target_link_libraries(test_example BLAST::BLAST) +endif(ZLIB_BLAST_BUILD_SHARED) + +if(ZLIB_BLAST_BUILD_STATIC) + add_executable(test_example_static ${BLAST_SRCS}) + target_link_libraries(test_example_static BLAST::BLASTSTATIC) +endif(ZLIB_BLAST_BUILD_STATIC) diff --git a/contrib/blast/test/find_package_test.cmake.in b/contrib/blast/test/find_package_test.cmake.in new file mode 100644 index 000000000..c80e50b06 --- /dev/null +++ b/contrib/blast/test/find_package_test.cmake.in @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + blast_find_package + LANGUAGES C + VERSION @blast_VERSION@) + +option(ZLIB_BLAST_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_BLAST_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +set(BLAST_SRCS + @blast_SOURCE_DIR@/blast-test.c) + +if(ZLIB_BLAST_BUILD_SHARED) + find_package(blast REQUIRED COMPONENTS shared CONFIG) + add_executable(test_example ${BLAST_SRCS}) + target_link_libraries(test_example BLAST::BLAST) +endif(ZLIB_BLAST_BUILD_SHARED) + +if(ZLIB_BLAST_BUILD_STATIC) + find_package(blast REQUIRED COMPONENTS static CONFIG) + add_executable(test_example_static ${BLAST_SRCS}) + target_link_libraries(test_example_static BLAST::BLASTSTATIC) +endif(ZLIB_BLAST_BUILD_STATIC) diff --git a/contrib/blast/test/find_package_wrong_components_test.cmake.in b/contrib/blast/test/find_package_wrong_components_test.cmake.in new file mode 100644 index 000000000..608f4085c --- /dev/null +++ b/contrib/blast/test/find_package_wrong_components_test.cmake.in @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + blast_find_package + LANGUAGES C + VERSION @blast_VERSION@) + +option(ZLIB_BLAST_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_BLAST_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +find_package(blast REQUIRED COMPONENTS wrong CONFIG) + +set(BLAST_SRCS + @blast_SOURCE_DIR@/blast-test.c) + +if(ZLIB_BLAST_BUILD_SHARED) + add_executable(test_example ${BLAST_SRCS}) + target_link_libraries(test_example BLAST::BLAST) +endif(ZLIB_BLAST_BUILD_SHARED) + +if(ZLIB_BLAST_BUILD_STATIC) + add_executable(test_example_static ${BLAST_SRCS}) + target_link_libraries(test_example_static BLAST::BLASTSTATIC) +endif(ZLIB_BLAST_BUILD_STATIC) diff --git a/contrib/blast/tester.cmake b/contrib/blast/tester.cmake new file mode 100644 index 000000000..14e69fca5 --- /dev/null +++ b/contrib/blast/tester.cmake @@ -0,0 +1,28 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +#CMAKE_ARGV0 = ${CMAKE_COMMAND} +#CMAKE_ARGV1 = -P +#CMAKE_ARGV2 = ${CMAKE_CURRENT_SOURCE_DIR}/tester.cmake +#CMAKE_ARGV3 = "$" +#CMAKE_ARGV4 = "${CMAKE_CURRENT_SOURCE_DIR}" +#CMAKE_ARGV5 = "${CMAKE_CURRENT_BINARY_DIR}") + +execute_process(COMMAND ${CMAKE_ARGV3} + INPUT_FILE "${CMAKE_ARGV4}/test.pk" + OUTPUT_FILE "${CMAKE_ARGV5}/output.txt" + RESULT_VARIABLE RESULT) + +if(RESULT) + message(FATAL_ERROR "Command exitited with: ${RESULT}") +endif(RESULT) + +execute_process(COMMAND ${CMAKE_ARGV0} -E compare_files + "${CMAKE_ARGV4}/test.txt" + "${CMAKE_ARGV5}/output.txt" + RESULT_VARIABLE RESULT) + +file(REMOVE "${CMAKE_ARGV5}/output.txt") + +if(RESULT) + message(FATAL_ERROR "Files differ") +endif(RESULT) diff --git a/contrib/gcc_gvmat64/CMakeLists.txt b/contrib/gcc_gvmat64/CMakeLists.txt new file mode 100644 index 000000000..53dd5a190 --- /dev/null +++ b/contrib/gcc_gvmat64/CMakeLists.txt @@ -0,0 +1,19 @@ +enable_language(ASM) + +# Need to push CMAKE_ASM_COMPILE_OBJECT to cache as otherwise it's not +# available in top-level + +set(CMAKE_ASM_COMPILE_OBJECT ${CMAKE_ASM_COMPILE_OBJECT} CACHE INTERNAL "" FORCE) + +if(MSVC) + #cmake 4.1 doesn't consider cl an asm compiler + cmake_policy(SET CMP0194 NEW) +endif(MSVC) + +if(ZLIB_BUILD_SHARED) + target_sources(zlib PRIVATE gvmat64.S) +endif(ZLIB_BUILD_SHARED) + +if(ZLIB_BUILD_STATIC) + target_sources(zlibstatic PRIVATE gvmat64.S) +endif(ZLIB_BUILD_STATIC) diff --git a/contrib/infback9/CMakeLists.txt b/contrib/infback9/CMakeLists.txt new file mode 100644 index 000000000..e4bb49e76 --- /dev/null +++ b/contrib/infback9/CMakeLists.txt @@ -0,0 +1,19 @@ +if(ZLIB_BUILD_SHARED) + target_sources(zlib + PRIVATE + infback9.c + inftree9.c + infback9.h + inffix9.h + inftree9.h) +endif(ZLIB_BUILD_SHARED) + +if(ZLIB_BUILD_STATIC) + target_sources(zlibstatic + PRIVATE + infback9.c + inftree9.c + infback9.h + inffix9.h + inftree9.h) +endif(ZLIB_BUILD_STATIC) diff --git a/contrib/iostream3/CMakeLists.txt b/contrib/iostream3/CMakeLists.txt new file mode 100644 index 000000000..e2ac480b7 --- /dev/null +++ b/contrib/iostream3/CMakeLists.txt @@ -0,0 +1,200 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + iostreamV3 + VERSION 1.0.0 + LANGUAGES CXX + DESCRIPTION "A library for using C++ IOStreams with zlib V3" + HOMEPAGE_URL "https://www.zlib.net") + +option(ZLIB_IOSTREAM3_BUILD_SHARED "Enable building blast shared library" ON) +option(ZLIB_IOSTREAM3_BUILD_STATIC "Enable building blast static library" ON) +option(ZLIB_IOSTREAM3_BUILD_TESTING "Enable building tests for blast" ON) +option(ZLIB_IOSTREAM3_INSTALL "Enable installation of iostream" ON) + +include(GNUInstallDirs) +include(CMakePackageConfigHelpers) + +if(NOT DEFINED ZLIB_BUILD_IOSTREAM3) + if(ZLIB_IOSTREAM3_BUILD_SHARED) + list(APPEND REQUIRED_COMPONENTS "shared") + endif(ZLIB_IOSTREAM3_BUILD_SHARED) + + if(ZLIB_IOSTREAM3_BUILD_STATIC) + list(APPEND REQUIRED_COMPONENTS "static") + endif(ZLIB_IOSTREAM3_BUILD_STATIC) + + find_package(ZLIB REQUIRED COMPONENTS ${REQUIRED_COMPONENTS} CONFIG) +endif(NOT DEFINED ZLIB_BUILD_IOSTREAM3) + +if(WIN32 OR CYGWIN) + set(zlibIOStream3_static_suffix "s") + set(CMAKE_DEBUG_POSTFIX "d") +endif(WIN32 OR CYGWIN) + + +function(iostreamv3_findTestEnv testName) + set(testEnv "PATH=") + + if(MSVC OR MINGW) + set(separator "\\\;") + else() + set(separator ":") + endif() + + string(APPEND testEnv "$${separator}") + string(APPEND testEnv "$${separator}") + string(APPEND testEnv "$ENV{PATH}") + + set_tests_properties(${testName} PROPERTIES ENVIRONMENT "${testEnv}") +endfunction(iostreamv3_findTestEnv testName) + +if(ZLIB_IOSTREAM3_BUILD_SHARED) + add_library(zlib_iostream3_iostreamv3 SHARED + zfstream.cc + zfstream.h) + + add_library(IOSTREAMV3::IOSTREAMV3 ALIAS zlib_iostream3_iostreamv3) + + if(NOT CYGWIN) + set_target_properties(zlib_iostream3_iostreamv3 + PROPERTIES + SOVERSION ${iostreamV3_VERSION_MAJOR} + VERSION ${iostreamV3_VERSION}) + endif(NOT CYGWIN) + + set_target_properties(zlib_iostream3_iostreamv3 + PROPERTIES + EXPORT_NAME IOSTREAMV3 + OUTPUT_NAME iostream3) + + target_link_libraries(zlib_iostream3_iostreamv3 + PUBLIC ZLIB::ZLIB) + + if(ZLIB_IOSTREAM3_BUILD_TESTING) + enable_testing() + + add_executable(zlib_iostream3_test test.cc zfstream.h) + + target_link_libraries(zlib_iostream3_test + PRIVATE zlib_iostream3_iostreamv3) + + add_test(NAME zlib_iostream3_test COMMAND zlib_iostream3_test) + + set_tests_properties(zlib_iostream3_test + PROPERTIES + FIXTURES_REQUIRED zlib_iostream3_cleanup) + + if(MSVC + OR MSYS + OR MINGW + OR CYGWIN) + iostreamv3_findtestenv(zlib_iostream3_test) + endif( + MSVC + OR MSYS + OR MINGW + OR CYGWIN) + endif(ZLIB_IOSTREAM3_BUILD_TESTING) +endif(ZLIB_IOSTREAM3_BUILD_SHARED) + +if(ZLIB_IOSTREAM3_BUILD_STATIC) + add_library(zlib_iostream3_iostreamv3Static STATIC + zfstream.cc + zfstream.h) + + add_library(IOSTREAMV3::IOSTREAMV3STATIC + ALIAS zlib_iostream3_iostreamv3Static) + + target_link_libraries(zlib_iostream3_iostreamv3Static + PUBLIC ZLIB::ZLIBSTATIC) + + set_target_properties(zlib_iostream3_iostreamv3Static + PROPERTIES + EXPORT_NAME IOSTREAMV3STATIC + OUTPUT_NAME iostream3${zlib_IOStream3_static_suffix}) + + if(ZLIB_IOSTREAM3_BUILD_TESTING) + enable_testing() + + add_executable(zlib_iostream3_testStatic test.cc zfstream.h) + + target_link_libraries(zlib_iostream3_testStatic + PRIVATE zlib_iostream3_iostreamv3Static) + + add_test(NAME zlib_iostream3_testStatic + COMMAND zlib_iostream3_testStatic) + + set_tests_properties(zlib_iostream3_testStatic + PROPERTIES + FIXTURES_REQUIRED zlib_iostream3_cleanup) + endif(ZLIB_IOSTREAM3_BUILD_TESTING) +endif(ZLIB_IOSTREAM3_BUILD_STATIC) + +if(ZLIB_IOSTREAM3_BUILD_TESTING) + add_test(NAME zlib_iostream3_cleanup COMMAND ${CMAKE_COMMAND} -E rm + ${CMAKE_CURRENT_BINARY_DIR}/test1.txt.gz + ${CMAKE_CURRENT_BINARY_DIR}/test2.txt.gz) + + set_tests_properties(zlib_iostream3_cleanup + PROPERTIES + FIXTURES_CLEANUP zlib_iostream3_cleanup) + + add_subdirectory(test) +endif(ZLIB_IOSTREAM3_BUILD_TESTING) + +if(ZLIB_IOSTREAM3_INSTALL) + if(ZLIB_IOSTREAM3_BUILD_SHARED) + install( + TARGETS zlib_iostream3_iostreamv3 + COMPONENT Runtime + EXPORT zlibiostream3SharedExport + RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}") + install( + EXPORT zlibiostream3SharedExport + FILE iostreamv3-shared.cmake + NAMESPACE IOSTREAMV3:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iostreamv3) + + if(MSVC) + install( + FILES $ + COMPONENT Development + DESTINATION ${CMAKE_INSTALL_BINDIR} + CONFIGURATIONS Debug OR RelWithDebInfo + OPTIONAL) + endif(MSVC) + endif(ZLIB_IOSTREAM3_BUILD_SHARED) + + if(ZLIB_IOSTREAM3_BUILD_STATIC) + install( + TARGETS zlib_iostream3_iostreamv3Static + COMPONENT Development + EXPORT iostream3StaticExport + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}") + install( + EXPORT iostream3StaticExport + FILE iostreamv3-static.cmake + NAMESPACE IOSTREAMV3:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iostreamv3) + endif(ZLIB_IOSTREAM3_BUILD_STATIC) + + configure_package_config_file( + ${iostreamV3_SOURCE_DIR}/iostream3Config.cmake.in + ${iostreamV3_BINARY_DIR}/iostreamv3Config.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iostreamv3) + + write_basic_package_version_file( + "${iostreamV3_BINARY_DIR}/iostreamv3ConfigVersion.cmake" + VERSION "${iostream3_VERSION}" + COMPATIBILITY AnyNewerVersion) + + install(FILES ${iostreamV3_BINARY_DIR}/iostreamv3Config.cmake + ${iostreamV3_BINARY_DIR}/iostreamv3ConfigVersion.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/iostreamv3) + install( + FILES zfstream.h + COMPONENT Development + DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") +endif(ZLIB_IOSTREAM3_INSTALL) diff --git a/contrib/iostream3/iostream3Config.cmake.in b/contrib/iostream3/iostream3Config.cmake.in new file mode 100644 index 000000000..a3db5e8a9 --- /dev/null +++ b/contrib/iostream3/iostream3Config.cmake.in @@ -0,0 +1,23 @@ +@PACKAGE_INIT@ + +set(_iostreamv3_supported_components "shared" "static") +include(CMakeFindDependencyMacro) + +if(iostreamv3_FIND_COMPONENTS) + find_dependency(ZLIB CONFIG COMPONENTS ${iostreamv3_FIND_COMPONENTS}) + + foreach(_comp ${iostreamv3_FIND_COMPONENTS}) + if(NOT _comp IN_LIST _iostreamv3_supported_components) + set(iostreamv3_FOUND False) + set(iostreamv3_NOT_FOUND_MESSAGE "Unsupported component: ${_comp}") + endif(NOT _comp IN_LIST _iostreamv3_supported_components) + + include("${CMAKE_CURRENT_LIST_DIR}/iostreamv3-${_comp}.cmake") + endforeach(_comp ${iostreamv3_FIND_COMPONENTS}) +else(iostream3_FIND_COMPONENTS) + find_dependency(ZLIB CONFIG) + + foreach(_component_config IN LISTS _iostreamv3_supported_components) + include("${CMAKE_CURRENT_LIST_DIR}/iostreamv3-${_component_config}.cmake") + endforeach(_component_config IN LISTS _iostreamv3_supported_components) +endif(iostreamv3_FIND_COMPONENTS) diff --git a/contrib/iostream3/test/CMakeLists.txt b/contrib/iostream3/test/CMakeLists.txt new file mode 100644 index 000000000..44e7d6017 --- /dev/null +++ b/contrib/iostream3/test/CMakeLists.txt @@ -0,0 +1,191 @@ +# if we are built from with zlib, use this path's) +if(DEFINED ZLIB_BUILD_IOSTREAM3) + set(WORK_DIR ${zlib_BINARY_DIR}) + set(inst_setup zlib_install) +else(DEFINED ZLIB_BUILD_IOSTREAM3) + set(WORK_DIR ${iostreamV3_BINARY_DIR}) + set(inst_setup zlib_iostream3_install) + set(ZLIB_ARG "-DZLIB_DIR=${ZLIB_DIR}") + + add_test( + NAME zlib_iostream3_install + COMMAND ${CMAKE_COMMAND} --install ${minizip_BINARY_DIR} --prefix + ${CMAKE_CURRENT_BINARY_DIR}/test_install --config $ + WORKING_DIRECTORY ${iostreamV3_BINARY_DIR}) + + set_tests_properties(zlib_iostream3_install + PROPERTIES + FIXTURES_SETUP zlib_iostream3_install) +endif(DEFINED ZLIB_BUILD_IOSTREAM3) + +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test) +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test) +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/find_package_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test/CMakeLists.txt @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/add_subdirectory_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test/CMakeLists.txt @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/add_subdirectory_exclude_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test/CMakeLists.txt + @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/find_package_no_components_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test/CMakeLists.txt + @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/find_package_wrong_components_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test/CMakeLists.txt + @ONLY) + +# CMAKE_GENERATOR_PLATFORM doesn't work in the if +set(GENERATOR ${CMAKE_GENERATOR_PLATFORM}) + +if(GENERATOR) + set(PLATFORM "-A ${GENERATOR}") +endif(GENERATOR) + +# +# findpackage_test +# +add_test( + NAME zlib_iostream3_find_package_configure + COMMAND + ${CMAKE_COMMAND} + ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_test_build + -DCMAKE_BUILD_TYPE=$ + -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_test) + +add_test( + NAME zlib_iostream3_find_package_build + COMMAND ${CMAKE_COMMAND} --build . --config $ + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test_build) + +set_tests_properties(zlib_iostream3_find_package_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + FIXTURES_SETUP iostream3_fp_config) + +set_tests_properties(zlib_iostream3_find_package_build + PROPERTIES + FIXTURES_REQUIRED iostream3_fp_config) + +# +# add_subdirectory_test +# +add_test( + NAME zlib_iostream3_add_subdirectory_configure + COMMAND + ${CMAKE_COMMAND} + ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test_build + -DCMAKE_BUILD_TYPE=$ + -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install + ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test) + +add_test( + NAME zlib_iostream3_add_subdirectory_build + COMMAND ${CMAKE_COMMAND} --build . --config $ + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test_build) + +set_tests_properties(zlib_iostream3_add_subdirectory_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + FIXTURES_SETUP iostream3as_config) + +set_tests_properties(zlib_iostream3_add_subdirectory_build + PROPERTIES + FIXTURES_REQUIRED iostream3_as_config) + +# +# add_subdirectory_exclude_test +# +add_test( + NAME zlib_iostream3_add_subdirectory_exclude_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test_build + -DCMAKE_BUILD_TYPE=$ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test) + +add_test( + NAME zlib_iostream3_add_subdirectory_exclude_build + COMMAND ${CMAKE_COMMAND} --build . --config $ + WORKING_DIRECTORY + ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test_build) + +set_tests_properties(zlib_iostream3_add_subdirectory_exclude_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + FIXTURES_SETUP iostream3_asx_config) + +set_tests_properties(zlib_iostream3_add_subdirectory_exclude_build + PROPERTIES + FIXTURES_REQUIRED iostream3_asx_config) + +# +# findpackage_no_components_test +# +add_test( + NAME zlib_iostream3_find_package_no_components_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test_build + -DCMAKE_BUILD_TYPE=$ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test) + +set_tests_properties(zlib_iostream3_find_package_no_components_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup}) + +if(NOT ZLIB_IOSTREAM3_BUILD_SHARED OR NOT ZLIB_IOSTREAM3_BUILD_STATIC) + set_tests_properties(zlib_iostream3_find_package_no_components_configure + PROPERTIES + WILL_FAIL TRUE) +endif(NOT ZLIB_IOSTREAM3_BUILD_SHARED OR NOT ZLIB_IOSTREAM3_BUILD_STATIC) + +# +# findpackage_no_components_test +# +add_test( + NAME zlib_iostream3_find_package_wrong_components_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test_build + -DCMAKE_BUILD_TYPE=$ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test) + +set_tests_properties(zlib_iostream3_find_package_wrong_components_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + WILL_FAIL TRUE) diff --git a/contrib/iostream3/test/add_subdirectory_exclude_test.cmake.in b/contrib/iostream3/test/add_subdirectory_exclude_test.cmake.in new file mode 100644 index 000000000..efc9cd8b8 --- /dev/null +++ b/contrib/iostream3/test/add_subdirectory_exclude_test.cmake.in @@ -0,0 +1,27 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + iostream_add_subdirectory_exclude + LANGUAGES CXX + VERSION @iostreamV3_VERSION@) + +option(ZLIB_IOSTREAM3_BUILD_SHARED "" @ZLIB_IOSTREAM3_BUILD_SHARED@) +option(ZLIB_IOSTREAM3_BUILD_STATIC "" @ZLIB_IOSTREAM3_BUILD_STATIC@) +option(ZLIB_IOSTREAM3_BUILD_TESTING "" OFF) + +add_subdirectory(@iostreamV3_SOURCE_DIR@ + ${CMAKE_CURRENT_BINARY_DIR}/iostream3 + EXCLUDE_FROM_ALL) + +set(IOSTREAM_SRCS + @iostreamV3_SOURCE_DIR@/test.cc) + +if(ZLIB_IOSTREAM3_BUILD_SHARED) + add_executable(test_example ${IOSTREAM_SRCS}) + target_link_libraries(test_example IOSTREAMV3::IOSTREAMV3) +endif(ZLIB_IOSTREAM3_BUILD_SHARED) + +if(ZLIB_IOSTREAM3_BUILD_STATIC) + add_executable(test_example_static ${IOSTREAM_SRCS}) + target_link_libraries(test_example_static IOSTREAMV3::IOSTREAMV3STATIC) +endif(ZLIB_IOSTREAM3_BUILD_STATIC) diff --git a/contrib/iostream3/test/add_subdirectory_test.cmake.in b/contrib/iostream3/test/add_subdirectory_test.cmake.in new file mode 100644 index 000000000..5eed2cc42 --- /dev/null +++ b/contrib/iostream3/test/add_subdirectory_test.cmake.in @@ -0,0 +1,25 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + iostream_add_subdirectory + LANGUAGES CXX + VERSION @iostreamV3_VERSION@) + +option(ZLIB_IOSTREAM3_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_IOSTREAM3_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) +option(ZLIB_IOSTREAM3_BUILD_TESTING "" OFF) + +add_subdirectory(@iostreamV3_SOURCE_DIR@ ${CMAKE_CURRENT_BINARY_DIR}/iostream3) + +set(IOSTREAM_SRCS + @iostreamV3_SOURCE_DIR@/test.cc) + +if(ZLIB_IOSTREAM3_BUILD_SHARED) + add_executable(test_example ${IOSTREAM_SRCS}) + target_link_libraries(test_example IOSTREAMV3::IOSTREAMV3) +endif(ZLIB_IOSTREAM3_BUILD_SHARED) + +if(ZLIB_IOSTREAM3_BUILD_STATIC) + add_executable(test_example_static ${IOSTREAM_SRCS}) + target_link_libraries(test_example_static IOSTREAMV3::IOSTREAMV3STATIC) +endif(ZLIB_IOSTREAM3_BUILD_STATIC) diff --git a/contrib/iostream3/test/find_package_no_components_test.cmake.in b/contrib/iostream3/test/find_package_no_components_test.cmake.in new file mode 100644 index 000000000..4daf76e23 --- /dev/null +++ b/contrib/iostream3/test/find_package_no_components_test.cmake.in @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + iostream_find_package_no_components + LANGUAGES CXX + VERSION @iostreamV3_VERSION@) + +option(ZLIB_IOSTREAM3_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_IOSTREAM3_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +find_package(iostreamv3 REQUIRED CONFIG) + +set(IOSTREAM_SRCS + @iostreamV3_SOURCE_DIR@/test.cc) + +if(ZLIB_IOSTREAM3_BUILD_SHARED) + add_executable(test_example ${IOSTREAM_SRCS}) + target_link_libraries(test_example IOSTREAMV3::IOSTREAMV3) +endif(ZLIB_IOSTREAM3_BUILD_SHARED) + +if(ZLIB_IOSTREAM3_BUILD_STATIC) + add_executable(test_example_static ${IOSTREAM_SRCS}) + target_link_libraries(test_example_static IOSTREAMV3::IOSTREAMV3STATIC) +endif(ZLIB_IOSTREAM3_BUILD_STATIC) diff --git a/contrib/iostream3/test/find_package_test.cmake.in b/contrib/iostream3/test/find_package_test.cmake.in new file mode 100644 index 000000000..08abe5611 --- /dev/null +++ b/contrib/iostream3/test/find_package_test.cmake.in @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + iostream_find_package + LANGUAGES CXX + VERSION @iostreamV3_VERSION@) + +option(ZLIB_IOSTREAM_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_IOSTREAM_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +set(IOSTREAM_SRCS + @iostreamV3_SOURCE_DIR@/test.cc) + +if(ZLIB_IOSTREAM_BUILD_SHARED) + find_package(iostreamv3 REQUIRED COMPONENTS shared CONFIG) + add_executable(test_example ${IOSTREAM_SRCS}) + target_link_libraries(test_example IOSTREAMV3::IOSTREAMV3) +endif(ZLIB_IOSTREAM_BUILD_SHARED) + +if(ZLIB_IOSTREAM_BUILD_STATIC) + find_package(iostreamv3 REQUIRED COMPONENTS static CONFIG) + add_executable(test_example_static ${IOSTREAM_SRCS}) + target_link_libraries(test_example_static IOSTREAMV3::IOSTREAMV3STATIC) +endif(ZLIB_IOSTREAM_BUILD_STATIC) diff --git a/contrib/iostream3/test/find_package_wrong_components_test.cmake.in b/contrib/iostream3/test/find_package_wrong_components_test.cmake.in new file mode 100644 index 000000000..83435a854 --- /dev/null +++ b/contrib/iostream3/test/find_package_wrong_components_test.cmake.in @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + iostream_find_package + LANGUAGES CXX + VERSION @iostreamV3_VERSION@) + +option(ZLIB_IOSTREAM_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_IOSTREAM_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +find_package(iostreamv3 REQUIRED COMPONENTS wrongCONFIG) + +set(IOSTREAM_SRCS + @iostreamV3_SOURCE_DIR@/test.cc) + +if(ZLIB_IOSTREAM_BUILD_SHARED) + add_executable(test_example ${IOSTREAM_SRCS}) + target_link_libraries(test_example IOSTREAMV3::IOSTREAMV3) +endif(ZLIB_IOSTREAM_BUILD_SHARED) + +if(ZLIB_IOSTREAM_BUILD_STATIC) + add_executable(test_example_static ${PUFF_SRCS}) + target_link_libraries(test_example_static IOSTREAMV3::IOSTREAMV3STATIC) +endif(ZLIB_IOSTREAM_BUILD_STATIC) diff --git a/contrib/minizip/test/CMakeLists.txt b/contrib/minizip/test/CMakeLists.txt index 2f86ee34b..fc64b9e7a 100644 --- a/contrib/minizip/test/CMakeLists.txt +++ b/contrib/minizip/test/CMakeLists.txt @@ -1,10 +1,10 @@ # if we are built from with zlib, use this path's) -if(DEFINED ZLIB_BUILD_SHARED) +if(DEFINED ZLIB_BUILD_MINIZIP) set(WORK_DIR ${zlib_BINARY_DIR}) - set(inst_setup minizip_minizip_install) -else(DEFINED ZLIB_BUILD_SHARED) + set(inst_setup zlib_install) +else(DEFINED ZLIB_BUILD_MINIZIP) set(WORK_DIR ${minizip_BINARY_DIR}) - set(inst_setup minizip_minizip_install) + set(inst_setup minizip_install) set(ZLIB_ARG "-DZLIB_DIR=${ZLIB_DIR}") add_test( @@ -13,9 +13,10 @@ else(DEFINED ZLIB_BUILD_SHARED) ${CMAKE_CURRENT_BINARY_DIR}/test_install --config $ WORKING_DIRECTORY ${minizip_BINARY_DIR}) - set_tests_properties(minizip_install PROPERTIES FIXTURES_SETUP - minizip_install) -endif(DEFINED ZLIB_BUILD_SHARED) + set_tests_properties(minizip_install + PROPERTIES + FIXTURES_SETUP minizip_install) +endif(DEFINED ZLIB_BUILD_MINIZIP) file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test) file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test) diff --git a/contrib/puff/CMakeLists.txt b/contrib/puff/CMakeLists.txt new file mode 100644 index 000000000..2f902c0df --- /dev/null +++ b/contrib/puff/CMakeLists.txt @@ -0,0 +1,219 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + puff + VERSION 2.3.0 + LANGUAGES C + DESCRIPTION "A library for decompressing deflate with very little footprint" + HOMEPAGE_URL "https://www.zlib.net") + +option(ZLIB_PUFF_BUILD_SHARED "Enable building blast shared library" ON) +option(ZLIB_PUFF_BUILD_STATIC "Enable building blast static library" ON) +option(ZLIB_PUFF_BUILD_TESTING "Enable building tests for blast" ON) +option(ZLIB_PUFF_INSTALL "Enable installation of puff" ON) + +include(GNUInstallDirs) +include(CMakePackageConfigHelpers) + +if(NOT DEFINED ZLIB_BUILD_PUFF) + if(ZLIB_PUFF_BUILD_SHARED) + list(APPEND REQUIRED_COMPONENTS "shared") + endif(ZLIB_PUFF_BUILD_SHARED) + + if(ZLIB_PUFF_BUILD_STATIC) + list(APPEND REQUIRED_COMPONENTS "static") + endif(ZLIB_PUFF_BUILD_STATIC) + + find_package(ZLIB REQUIRED COMPONENTS ${REQUIRED_COMPONENTS} CONFIG) +endif(NOT DEFINED ZLIB_BUILD_PUFF) + +if(WIN32 OR CYGWIN) + set(zlibpuff_static_suffix "s") + set(CMAKE_DEBUG_POSTFIX "d") +endif(WIN32 OR CYGWIN) + +if(ZLIB_PUFF_BUILD_TESTING) + add_executable(zlib_puff_bin-writer bin-writer.c) + + if(${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR + ${CMAKE_C_COMPILER_ID} STREQUAL "Clang") + set(CFLAGS_OLD ${CMAKE_C_FLAGS}) + set(CMAKE_C_FLAGS + "" + CACHE STRING "" FORCE) + + if(${CMAKE_C_COMPILER_ID} STREQUAL "GNU") + find_program(GCOV_EXECUTABLE gcov) + endif(${CMAKE_C_COMPILER_ID} STREQUAL "GNU") + + if(${CMAKE_C_COMPILER_ID} STREQUAL "Clang") + set(llvm_names llvm_cov) + list(APPEND llvm_names llvm-cov) + + foreach(ver RANGE 11 99) + list(APPEND llvm_names llvm-cov-${ver}) + endforeach(ver RANGE 11 99) + + find_program(GCOV_EXECUTABLE NAMES ${llvm_names}) + set(llvm_option "gcov") + endif(${CMAKE_C_COMPILER_ID} STREQUAL "Clang") + endif(${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR + ${CMAKE_C_COMPILER_ID} STREQUAL "Clang") + + add_subdirectory(test) +endif(ZLIB_PUFF_BUILD_TESTING) + +if(ZLIB_PUFF_BUILD_SHARED) + add_library(zlib_puff_puff SHARED + puff.c + puff.h) + + add_library(PUFF::PUFF ALIAS zlib_puff_puff) + + if(NOT CYGWIN) + set_target_properties(zlib_puff_puff + PROPERTIES + SOVERSION ${puff_VERSION_MAJOR} + VERSION ${puff_VERSION}) + endif(NOT CYGWIN) + + set_target_properties( + zlib_puff_puff + PROPERTIES + EXPORT_NAME PUFF + OUTPUT_NAME puff) + + if(ZLIB_PUFF_BUILD_TESTING AND NOT WIN32) + enable_testing() + + add_executable(zlib_puff_test pufftest.c puff.h) + + target_link_libraries(zlib_puff_test + PRIVATE zlib_puff_puff) + + add_test(NAME zlib_puff_test + COMMAND ${CMAKE_COMMAND} -P + ${CMAKE_CURRENT_SOURCE_DIR}/tester.cmake + "$" + "${CMAKE_CURRENT_SOURCE_DIR}") + + if(GCOV_EXECUTABLE) + add_executable(zlib_puff_test-coverage pufftest.c puff.c puff.h) + + target_compile_options(zlib_puff_test-coverage PRIVATE -coverage) + + target_link_options(zlib_puff_test-coverage PRIVATE -coverage) + + add_test(NAME zlib_puff_test-coverage + COMMAND ${CMAKE_COMMAND} -P + ${CMAKE_CURRENT_SOURCE_DIR}/tester-cov.cmake + "$" + "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_BINARY_DIR}" + ${GCOV_EXECUTABLE} + ${llvm_option}) + endif(GCOV_EXECUTABLE) + endif(ZLIB_PUFF_BUILD_TESTING AND NOT WIN32) +endif(ZLIB_PUFF_BUILD_SHARED) + +if(ZLIB_PUFF_BUILD_STATIC) + add_library(zlib_puff_puffStatic STATIC + puff.c + puff.h) + + add_library(PUFF::PUFFSTATIC ALIAS zlib_puff_puffStatic) + + set_target_properties(zlib_puff_puffStatic + PROPERTIES + EXPORT_NAME PUFFSTATIC + OUTPUT_NAME puff${zlib_puff_static_suffix}) + + if(ZLIB_PUFF_BUILD_TESTING AND NOT WIN32) + enable_testing() + + add_executable(zlib_puff_testStatic pufftest.c puff.h) + + target_link_libraries(zlib_puff_testStatic + PRIVATE zlib_puff_puffStatic) + add_test(NAME zlib_puff_testStatic + COMMAND ${CMAKE_COMMAND} -P + ${CMAKE_CURRENT_SOURCE_DIR}/tester.cmake + "$" + "${CMAKE_CURRENT_SOURCE_DIR}") + + if(GCOV_EXECUTABLE) + add_executable(zlib_puff_testStatic-coverage pufftest.c puff.c puff.h) + + target_compile_options(zlib_puff_testStatic-coverage + PRIVATE -coverage) + + target_link_options(zlib_puff_testStatic-coverage + PRIVATE -coverage) + + add_test(NAME zlib_puff_testStatic-coverage + COMMAND ${CMAKE_COMMAND} -P + ${CMAKE_CURRENT_SOURCE_DIR}/tester-cov.cmake + "$" + "${CMAKE_CURRENT_SOURCE_DIR}" + "${CMAKE_CURRENT_BINARY_DIR}" + ${GCOV_EXECUTABLE} + ${llvm_option}) + endif(GCOV_EXECUTABLE) + endif(ZLIB_PUFF_BUILD_TESTING AND NOT WIN32) +endif(ZLIB_PUFF_BUILD_STATIC) + +if(ZLIB_PUFF_INSTALL) + if(ZLIB_PUFF_BUILD_SHARED) + install( + TARGETS zlib_puff_puff + COMPONENT Runtime + EXPORT puffSharedExport + RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}" + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}") + install( + EXPORT puffSharedExport + FILE puff-shared.cmake + NAMESPACE PUFF:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/puff) + + if(MSVC) + install( + FILES $ + COMPONENT Development + DESTINATION ${CMAKE_INSTALL_BINDIR} + CONFIGURATIONS Debug OR RelWithDebInfo + OPTIONAL) + endif(MSVC) + endif(ZLIB_PUFF_BUILD_SHARED) + + if(ZLIB_PUFF_BUILD_STATIC) + install( + TARGETS zlib_puff_puffStatic + COMPONENT Development + EXPORT puffStaticExport + ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}") + install( + EXPORT puffStaticExport + FILE puff-static.cmake + NAMESPACE PUFF:: + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/puff) + endif(ZLIB_PUFF_BUILD_STATIC) + + configure_package_config_file( + ${puff_SOURCE_DIR}/puffConfig.cmake.in + ${puff_BINARY_DIR}/puffConfig.cmake + INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/puff) + + write_basic_package_version_file( + "${puff_BINARY_DIR}/puffConfigVersion.cmake" + VERSION "${puff_VERSION}" + COMPATIBILITY AnyNewerVersion) + + install(FILES ${puff_BINARY_DIR}/puffConfig.cmake + ${puff_BINARY_DIR}/puffConfigVersion.cmake + DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/puff) + install( + FILES puff.h + COMPONENT Development + DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}") +endif(ZLIB_PUFF_INSTALL) diff --git a/contrib/puff/bin-writer.c b/contrib/puff/bin-writer.c new file mode 100644 index 000000000..cfd8306ae --- /dev/null +++ b/contrib/puff/bin-writer.c @@ -0,0 +1,26 @@ +#include "stdio.h" +#include "stdlib.h" + +/** + * Reads hexadecimal values from stdin and writes binary bytes to stdout. + * Accepts hex values separated by spaces, newlines, commas, etc. + * Handles both uppercase and lowercase hex digits. + */ +int main(void) { + char hexStr[3]; // Two hex digits + null terminator + int ch; + + // Read characters until EOF + while((ch = getchar()) != EOF) { + hexStr[0] = (char)ch; + hexStr[1] = (char)getchar(); + hexStr[2] = '\0'; // Null-terminate string + char *endptr; + unsigned char byte = (unsigned char)strtol(hexStr, &endptr, 16); + fwrite(&byte, 1, 1, stdout); + if((ch = getchar()) == EOF) // Read seaparating space + break; + } + + return 0; +} diff --git a/contrib/puff/puffConfig.cmake.in b/contrib/puff/puffConfig.cmake.in new file mode 100644 index 000000000..227f9888d --- /dev/null +++ b/contrib/puff/puffConfig.cmake.in @@ -0,0 +1,18 @@ +@PACKAGE_INIT@ + +set(_puff_supported_components "shared" "static") + +if(puff_FIND_COMPONENTS) + foreach(_comp ${puff_FIND_COMPONENTS}) + if(NOT _comp IN_LIST _puff_supported_components) + set(puff_FOUND False) + set(puff_NOT_FOUND_MESSAGE "Unsupported component: ${_comp}") + endif(NOT _comp IN_LIST _puff_supported_components) + + include("${CMAKE_CURRENT_LIST_DIR}/puff-${_comp}.cmake") + endforeach(_comp ${puff_FIND_COMPONENTS}) +else(puff_FIND_COMPONENTS) + foreach(_component_config IN LISTS _puff_supported_components) + include("${CMAKE_CURRENT_LIST_DIR}/puff-${_component_config}.cmake") + endforeach(_component_config IN LISTS _puff_supported_components) +endif(puff_FIND_COMPONENTS) diff --git a/contrib/puff/test/CMakeLists.txt b/contrib/puff/test/CMakeLists.txt new file mode 100644 index 000000000..2548d5715 --- /dev/null +++ b/contrib/puff/test/CMakeLists.txt @@ -0,0 +1,191 @@ +# if we are built from with zlib, use this path's) +if(DEFINED ZLIB_BUILD_PUFF) + set(WORK_DIR ${zlib_BINARY_DIR}) + set(inst_setup zlib_install) +else(DEFINED ZLIB_BUILD_PUFF) + set(WORK_DIR ${puff_BINARY_DIR}) + set(inst_setup zlib_puff_install) + set(ZLIB_ARG "-DZLIB_DIR=${ZLIB_DIR}") + + add_test( + NAME zlib_puff_install + COMMAND ${CMAKE_COMMAND} --install ${puff_BINARY_DIR} --prefix + ${CMAKE_CURRENT_BINARY_DIR}/test_install --config $ + WORKING_DIRECTORY ${puff_BINARY_DIR}) + + set_tests_properties(zlib_puff_install + PROPERTIES + FIXTURES_SETUP zlib_puff_install) +endif(DEFINED ZLIB_BUILD_PUFF) + +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test) +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test) +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/find_package_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test/CMakeLists.txt @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/add_subdirectory_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test/CMakeLists.txt @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/add_subdirectory_exclude_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test/CMakeLists.txt + @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/find_package_no_components_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test/CMakeLists.txt + @ONLY) + +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/find_package_wrong_components_test.cmake.in + ${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test/CMakeLists.txt + @ONLY) + +# CMAKE_GENERATOR_PLATFORM doesn't work in the if +set(GENERATOR ${CMAKE_GENERATOR_PLATFORM}) + +if(GENERATOR) + set(PLATFORM "-A ${GENERATOR}") +endif(GENERATOR) + +# +# findpackage_test +# +add_test( + NAME zlib_puff_find_package_configure + COMMAND + ${CMAKE_COMMAND} + ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_test_build + -DCMAKE_BUILD_TYPE=$ + -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install + ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_test) + +add_test( + NAME zlib_puff_find_package_build + COMMAND ${CMAKE_COMMAND} --build . --config $ + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/findpackage_test_build) + +set_tests_properties(zlib_puff_find_package_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + FIXTURES_SETUP puff_fp_config) + +set_tests_properties(zlib_puff_find_package_build + PROPERTIES + FIXTURES_REQUIRED puff_fp_config) + +# +# add_subdirectory_test +# +add_test( + NAME zlib_puff_add_subdirectory_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test_build + -DCMAKE_BUILD_TYPE=$ + -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test) + +add_test( + NAME zlib_puff_add_subdirectory_build + COMMAND ${CMAKE_COMMAND} --build . --config $ + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_test_build) + +set_tests_properties(zlib_puff_add_subdirectory_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + FIXTURES_SETUP puiff_as_config) + +set_tests_properties(zlib_puff_add_subdirectory_build + PROPERTIES + FIXTURES_REQUIRED puff_as_config) + +# +# add_subdirectory_exclude_test +# +add_test( + NAME zlib_puff_add_subdirectory_exclude_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test_build + -DCMAKE_BUILD_TYPE=$ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test) + +add_test( + NAME zlib_puff_add_subdirectory_exclude_build + COMMAND ${CMAKE_COMMAND} --build . --config $ + WORKING_DIRECTORY + ${CMAKE_CURRENT_BINARY_DIR}/add_subdirectory_exclude_test_build) + +set_tests_properties(zlib_puff_add_subdirectory_exclude_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + FIXTURES_SETUP puff_asx_config) + +set_tests_properties(zlib_puff_add_subdirectory_exclude_build + PROPERTIES + FIXTURES_REQUIRED puff_asx_config) + +# +# findpackage_no_components_test +# +add_test( + NAME zlib_puff_find_package_no_components_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test_build + -DCMAKE_BUILD_TYPE=$ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_no_components_test) + +set_tests_properties( + zlib_puff_find_package_no_components_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup}) + +if(NOT ZLIB_PUFF_BUILD_SHARED OR NOT ZLIB_PUFF_BUILD_STATIC) + set_tests_properties(zlib_puff_find_package_no_components_configure + PROPERTIES + WILL_FAIL TRUE) +endif(NOT ZLIB_PUFF_BUILD_SHARED OR NOT ZLIB_PUFF_BUILD_STATIC) + +# +# findpackage_no_components_test +# +add_test( + NAME zlib_puff_find_package_wrong_components_configure + COMMAND + ${CMAKE_COMMAND} ${PLATFORM} + -B${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test_build + -DCMAKE_BUILD_TYPE=$ -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} + -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS} + -DCMAKE_INSTALL_PREFIX=${WORK_DIR}/test/test_install ${ZLIB_ARG} + --fresh + -G "${CMAKE_GENERATOR}" + -S${CMAKE_CURRENT_BINARY_DIR}/findpackage_wrong_components_test) + +set_tests_properties(zlib_puff_find_package_wrong_components_configure + PROPERTIES + FIXTURES_REQUIRED ${inst_setup} + WILL_FAIL TRUE) diff --git a/contrib/puff/test/add_subdirectory_exclude_test.cmake.in b/contrib/puff/test/add_subdirectory_exclude_test.cmake.in new file mode 100644 index 000000000..0e24c0161 --- /dev/null +++ b/contrib/puff/test/add_subdirectory_exclude_test.cmake.in @@ -0,0 +1,26 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + zlib_puff_add_subdirectory_exclude_from_all + LANGUAGES C + VERSION @puff_VERSION@) + +option(ZLIB_PUFF_BUILD_TESTING "" OFF) +option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +add_subdirectory(@puff_SOURCE_DIR@ ${CMAKE_CURRENT_BINARY_DIR}/puff + EXCLUDE_FROM_ALL) + +set(PUFF_SRCS + @puff_SOURCE_DIR@/pufftest.c) + +if(ZLIB_PUFF_BUILD_SHARED) + add_executable(test_example ${PUFF_SRCS}) + target_link_libraries(test_example PUFF::PUFF) +endif(ZLIB_PUFF_BUILD_SHARED) + +if(ZLIB_PUFF_BUILD_STATIC) + add_executable(test_example_static ${PUFF_SRCS}) + target_link_libraries(test_example_static PUFF::PUFFSTATIC) +endif(ZLIB_PUFF_BUILD_STATIC) diff --git a/contrib/puff/test/add_subdirectory_test.cmake.in b/contrib/puff/test/add_subdirectory_test.cmake.in new file mode 100644 index 000000000..8e7e47b4d --- /dev/null +++ b/contrib/puff/test/add_subdirectory_test.cmake.in @@ -0,0 +1,25 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + zlib_puff_add_subdirectory + LANGUAGES C + VERSION @puff_VERSION@) + +option(ZLIB_PUFF_BUILD_TESTING "" OFF) +option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +add_subdirectory(@puff_SOURCE_DIR@ ${CMAKE_CURRENT_BINARY_DIR}/puff) + +set(PUFF_SRCS + @puff_SOURCE_DIR@/pufftest.c) + +if(ZLIB_PUFF_BUILD_SHARED) + add_executable(test_example ${PUFF_SRCS}) + target_link_libraries(test_example PUFF::PUFF) +endif(ZLIB_PUFF_BUILD_SHARED) + +if(ZLIB_PUFF_BUILD_STATIC) + add_executable(test_example_static ${PUFF_SRCS}) + target_link_libraries(test_example_static PUFF::PUFFSTATIC) +endif(ZLIB_PUFF_BUILD_STATIC) diff --git a/contrib/puff/test/find_package_no_components_test.cmake.in b/contrib/puff/test/find_package_no_components_test.cmake.in new file mode 100644 index 000000000..2040bfd18 --- /dev/null +++ b/contrib/puff/test/find_package_no_components_test.cmake.in @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + puff_find_package + LANGUAGES C + VERSION @puff_VERSION@) + +option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +find_package(puff REQUIRED CONFIG) + +set(PUFF_SRCS + @puff_SOURCE_DIR@/pufftest.c) + +if(ZLIB_PUFF_BUILD_SHARED) + add_executable(test_example ${PUFF_SRCS}) + target_link_libraries(test_example PUFF::PUFF) +endif(ZLIB_PUFF_BUILD_SHARED) + +if(ZLIB_PUFF_BUILD_STATIC) + add_executable(test_example_static ${PUFF_SRCS}) + target_link_libraries(test_example_static PUFF::PUFFSTATIC) +endif(ZLIB_PUFF_BUILD_STATIC) diff --git a/contrib/puff/test/find_package_test.cmake.in b/contrib/puff/test/find_package_test.cmake.in new file mode 100644 index 000000000..e8a0ceffb --- /dev/null +++ b/contrib/puff/test/find_package_test.cmake.in @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + puff_find_package + LANGUAGES C + VERSION @puff_VERSION@) + +option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +set(PUFF_SRCS + @puff_SOURCE_DIR@/pufftest.c) + +if(ZLIB_PUFF_BUILD_SHARED) + find_package(puff REQUIRED COMPONENTS shared CONFIG) + add_executable(test_example ${PUFF_SRCS}) + target_link_libraries(test_example PUFF::PUFF) +endif(ZLIB_PUFF_BUILD_SHARED) + +if(ZLIB_PUFF_BUILD_STATIC) + find_package(puff REQUIRED COMPONENTS static CONFIG) + add_executable(test_example_static ${PUFF_SRCS}) + target_link_libraries(test_example_static PUFF::PUFFSTATIC) +endif(ZLIB_PUFF_BUILD_STATIC) diff --git a/contrib/puff/test/find_package_wrong_components_test.cmake.in b/contrib/puff/test/find_package_wrong_components_test.cmake.in new file mode 100644 index 000000000..a5cd4979c --- /dev/null +++ b/contrib/puff/test/find_package_wrong_components_test.cmake.in @@ -0,0 +1,24 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + puff_find_package + LANGUAGES C + VERSION @puff_VERSION@) + +option(ZLIB_PUFF_BUILD_SHARED "" @ZLIB_PUFF_BUILD_SHARED@) +option(ZLIB_PUFF_BUILD_STATIC "" @ZLIB_PUFF_BUILD_STATIC@) + +find_package(puff REQUIRED COMPONENTS wrong CONFIG) + +set(PUFF_SRCS + @puff_SOURCE_DIR@/pufftest.c) + +if(ZLIB_PUFF_BUILD_SHARED) + add_executable(test_example ${PUFF_SRCS}) + target_link_libraries(test_example PUFF::PUFF) +endif(ZLIB_PUFF_BUILD_SHARED) + +if(ZLIB_PUFF_BUILD_STATIC) + add_executable(test_example_static ${PUFF_SRCS}) + target_link_libraries(test_example_static PUFF::PUFFSTATIC) +endif(ZLIB_PUFF_BUILD_STATIC) diff --git a/contrib/puff/tester-cov.cmake b/contrib/puff/tester-cov.cmake new file mode 100644 index 000000000..5dc9662e0 --- /dev/null +++ b/contrib/puff/tester-cov.cmake @@ -0,0 +1,56 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +#CMAKE_ARGV0 = ${CMAKE_COMMAND} +#CMAKE_ARGV1 = -P +#CMAKE_ARGV2 = ${CMAKE_CURRENT_SOURCE_DIR}/tester-cov.cmake +#CMAKE_ARGV3 = "$" +#CMAKE_ARGV4 = "${CMAKE_CURRENT_SOURCE_DIR}" +#CMAKE_ARGV5 = "${CMAKE_CURRENT_BINARY_DIR}" +#CMAKE_ARGV6 = GCOV_EXECUTABLE +#CMAKE_ARGV7 = GCOV_EXECUTABLE + +function(puff_cov_test test_string expected_result) + execute_process(COMMAND ${CMAKE_ARGV0} -E echo_append ${test_string} + COMMAND ${CMAKE_ARGV5}/bin-writer + COMMAND ${CMAKE_ARGV3} + RESULT_VARIABLE RESULT) + + if(NOT RESULT EQUAL expected_result) + message(FATAL_ERROR "${RESULT} not matching ${expected_result}") + endif(NOT RESULT EQUAL expected_result) +endfunction(puff_cov_test test_string expected_result) + +execute_process(COMMAND ${CMAKE_ARGV3} -w ${CMAKE_ARGV4}/zeros.raw) + +puff_cov_test("04" "2") +puff_cov_test("00" "2") +puff_cov_test("00 00 00 00 00" "254") +puff_cov_test("00 01 00 fe ff" "2") + +execute_process(COMMAND ${CMAKE_ARGV0} -E echo_append "01 01 00 fe ff 0a" + COMMAND ${CMAKE_ARGV5}/bin-writer + COMMAND ${CMAKE_ARGV3}) + +puff_cov_test("02 7e ff ff" "246") +puff_cov_test("02" "2") +puff_cov_test("04 80 49 92 24 49 92 24 0f b4 ff ff c3 04" "2") +puff_cov_test("04 80 49 92 24 49 92 24 71 ff ff 93 11 00" "249") +puff_cov_test("04 c0 81 08 00 00 00 00 20 7f eb 0b 00 00" "246") + +execute_process(COMMAND ${CMAKE_ARGV0} -E echo_append "0b 00 00" + COMMAND ${CMAKE_ARGV5}/bin-writer + COMMAND ${CMAKE_ARGV3}) + +puff_cov_test("1a 07" "246") +puff_cov_test("0c c0 81 00 00 00 00 00 90 ff 6b 04" "245") + +execute_process(COMMAND ${CMAKE_ARGV3} -f ${CMAKE_ARGV4}/zeros.raw) + +puff_cov_test("fc 00 00" "253") +puff_cov_test("04 00 fe ff" "252") +puff_cov_test("04 00 24 49" "251") +puff_cov_test("04 80 49 92 24 49 92 24 0f b4 ff ff c3 84" "248") +puff_cov_test("04 00 24 e9 ff ff" "250") +puff_cov_test("04 00 24 e9 ff 6d" "247") + +execute_process(COMMAND ${CMAKE_ARGV6} ${CMAKE_ARGV7} -n puff.c.gcno) diff --git a/contrib/puff/tester.cmake b/contrib/puff/tester.cmake new file mode 100644 index 000000000..be3b81fd9 --- /dev/null +++ b/contrib/puff/tester.cmake @@ -0,0 +1,16 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +#CMAKE_ARGV0 = ${CMAKE_COMMAND} +#CMAKE_ARGV1 = -P +#CMAKE_ARGV2 = ${CMAKE_CURRENT_SOURCE_DIR}/tester.cmake +#CMAKE_ARGV3 = "$" +#CMAKE_ARGV4 = "${CMAKE_CURRENT_SOURCE_DIR}" + +execute_process(COMMAND ${CMAKE_ARGV3} + INPUT_FILE "${CMAKE_ARGV4}/zeros.raw" + RESULT_VARIABLE RESULT + COMMAND_ECHO STDERR) + +if(RESULT) + message(FATAL_ERROR "Command exitited with: ${RESULT}") +endif(RESULT) diff --git a/contrib/testzlib/CMakeLists.txt b/contrib/testzlib/CMakeLists.txt new file mode 100644 index 000000000..b710c76b7 --- /dev/null +++ b/contrib/testzlib/CMakeLists.txt @@ -0,0 +1,44 @@ +cmake_minimum_required(VERSION 3.12...3.31) + +project( + testzlib + VERSION 1.0.0 + LANGUAGES C + DESCRIPTION "A little program to test zlib" + HOMEPAGE_URL "https://www.zlib.net") + +option(ZLIB_TESTZLIB_BUILD_SHARED "Enable building testzlib" ON) +option(ZLIB_TESTZLIB_BUILD_STATIC "Enable building static linked testzlib" ON) +option(ZLIB_TESTZLIB_INSTALL "Enable installation of testzlib" ON) + +if(ZLIB_TESTZLIB_BUILD_SHARED) + add_executable(zlib_testzlib testzlib.c) + target_link_libraries(zlib_testzlib PRIVATE ZLIB::ZLIB) + + set_target_properties(zlib_testzlib + PROPERTIES + OUTPUT_NAME testzlib) + + if(ZLIB_TESTZLIB_INSTALL) + install( + TARGETS zlib_testzlib + COMPONENT Runtime + RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}") + endif(ZLIB_TESTZLIB_INSTALL) +endif(ZLIB_TESTZLIB_BUILD_SHARED) + +if(ZLIB_TESTZLIB_BUILD_STATIC) + add_executable(zlib_testzlibStatic testzlib.c) + target_link_libraries(zlib_testzlibStatic PRIVATE ZLIB::ZLIBSTATIC) + + set_target_properties(zlib_testzlibStatic + PROPERTIES + OUTPUT_NAME testzlibStatic) + + if(ZLIB_TESTZLIB_INSTALL) + install( + TARGETS zlib_testzlibStatic + COMPONENT Runtime + RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}") + endif(ZLIB_TESTZLIB_INSTALL) +endif(ZLIB_TESTZLIB_BUILD_STATIC) diff --git a/contrib/untgz/Makefile b/contrib/untgz/Makefile deleted file mode 100644 index b54266fba..000000000 --- a/contrib/untgz/Makefile +++ /dev/null @@ -1,14 +0,0 @@ -CC=cc -CFLAGS=-g - -untgz: untgz.o ../../libz.a - $(CC) $(CFLAGS) -o untgz untgz.o -L../.. -lz - -untgz.o: untgz.c ../../zlib.h - $(CC) $(CFLAGS) -c -I../.. untgz.c - -../../libz.a: - cd ../..; ./configure; make - -clean: - rm -f untgz untgz.o *~ diff --git a/contrib/untgz/Makefile.msc b/contrib/untgz/Makefile.msc deleted file mode 100644 index 77b860221..000000000 --- a/contrib/untgz/Makefile.msc +++ /dev/null @@ -1,17 +0,0 @@ -CC=cl -CFLAGS=-MD - -untgz.exe: untgz.obj ..\..\zlib.lib - $(CC) $(CFLAGS) untgz.obj ..\..\zlib.lib - -untgz.obj: untgz.c ..\..\zlib.h - $(CC) $(CFLAGS) -c -I..\.. untgz.c - -..\..\zlib.lib: - cd ..\.. - $(MAKE) -f win32\makefile.msc - cd contrib\untgz - -clean: - -del untgz.obj - -del untgz.exe diff --git a/contrib/untgz/untgz.c b/contrib/untgz/untgz.c deleted file mode 100644 index 78579211f..000000000 --- a/contrib/untgz/untgz.c +++ /dev/null @@ -1,667 +0,0 @@ -/* - * untgz.c -- Display contents and extract files from a gzip'd TAR file - * - * written by Pedro A. Aranda Gutierrez - * adaptation to Unix by Jean-loup Gailly - * various fixes by Cosmin Truta - * - * This software is provided 'as-is', without any express or implied - * warranty. In no event will the authors be held liable for any damages - * arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, - * including commercial applications, and to alter it and redistribute it - * freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not - * claim that you wrote the original software. If you use this software - * in a product, an acknowledgment in the product documentation would be - * appreciated but is not required. - * 2. Altered source versions must be plainly marked as such, and must not be - * misrepresented as being the original software. - * 3. This notice may not be removed or altered from any source distribution. - */ - -#include -#include -#include -#include -#include - -#include "zlib.h" - -#ifdef _WIN32 -# include -# include -# include -# ifndef F_OK -# define F_OK 0 -# endif -# define mkdir(dirname,mode) _mkdir(dirname) -# ifdef _MSC_VER -# define access(path,mode) _access(path,mode) -# define chmod(path,mode) _chmod(path,mode) -# define strdup(str) _strdup(str) -# endif -#else -# include -# include -# include -#endif - - -/* values used in typeflag field */ - -#define REGTYPE '0' /* regular file */ -#define AREGTYPE '\0' /* regular file */ -#define LNKTYPE '1' /* link */ -#define SYMTYPE '2' /* reserved */ -#define CHRTYPE '3' /* character special */ -#define BLKTYPE '4' /* block special */ -#define DIRTYPE '5' /* directory */ -#define FIFOTYPE '6' /* FIFO special */ -#define CONTTYPE '7' /* reserved */ - -/* GNU tar extensions */ - -#define GNUTYPE_DUMPDIR 'D' /* file names from dumped directory */ -#define GNUTYPE_LONGLINK 'K' /* long link name */ -#define GNUTYPE_LONGNAME 'L' /* long file name */ -#define GNUTYPE_MULTIVOL 'M' /* continuation of file from another volume */ -#define GNUTYPE_NAMES 'N' /* file name that does not fit into main hdr */ -#define GNUTYPE_SPARSE 'S' /* sparse file */ -#define GNUTYPE_VOLHDR 'V' /* tape/volume header */ - - -/* tar header */ - -#define BLOCKSIZE 512 -#define SHORTNAMESIZE 100 - -struct tar_header -{ /* byte offset */ - char name[100]; /* 0 */ - char mode[8]; /* 100 */ - char uid[8]; /* 108 */ - char gid[8]; /* 116 */ - char size[12]; /* 124 */ - char mtime[12]; /* 136 */ - char chksum[8]; /* 148 */ - char typeflag; /* 156 */ - char linkname[100]; /* 157 */ - char magic[6]; /* 257 */ - char version[2]; /* 263 */ - char uname[32]; /* 265 */ - char gname[32]; /* 297 */ - char devmajor[8]; /* 329 */ - char devminor[8]; /* 337 */ - char prefix[155]; /* 345 */ - /* 500 */ -}; - -union tar_buffer -{ - char buffer[BLOCKSIZE]; - struct tar_header header; -}; - -struct attr_item -{ - struct attr_item *next; - char *fname; - int mode; - time_t time; -}; - -enum { TGZ_EXTRACT, TGZ_LIST, TGZ_INVALID }; - -char *prog; - -void error(const char *msg) -{ - fprintf(stderr, "%s: %s\n", prog, msg); - exit(1); -} - -const char *TGZsuffix[] = { "\0", ".tar", ".tar.gz", ".taz", ".tgz", NULL }; - -/* return the file name of the TGZ archive */ -/* or NULL if it does not exist */ - -char *TGZfname (const char *arcname) -{ - static char buffer[1024]; - int origlen,i; - - strcpy(buffer,arcname); - origlen = strlen(buffer); - - for (i=0; TGZsuffix[i]; i++) - { - strcpy(buffer+origlen,TGZsuffix[i]); - if (access(buffer,F_OK) == 0) - return buffer; - } - return NULL; -} - - -/* error message for the filename */ - -void TGZnotfound (const char *arcname) -{ - int i; - - fprintf(stderr,"%s: Couldn't find ",prog); - for (i=0;TGZsuffix[i];i++) - fprintf(stderr,(TGZsuffix[i+1]) ? "%s%s, " : "or %s%s\n", - arcname, - TGZsuffix[i]); - exit(1); -} - - -/* convert octal digits to int */ -/* on error return -1 */ - -int getoct (char *p,int width) -{ - int result = 0; - char c; - - while (width--) - { - c = *p++; - if (c == 0) - break; - if (c == ' ') - continue; - if (c < '0' || c > '7') - return -1; - result = result * 8 + (c - '0'); - } - return result; -} - - -/* convert time_t to string */ -/* use the "YYYY/MM/DD hh:mm:ss" format */ - -char *strtime (time_t *t) -{ - struct tm *local; - static char result[32]; - - local = localtime(t); - sprintf(result,"%4d/%02d/%02d %02d:%02d:%02d", - local->tm_year+1900, local->tm_mon+1, local->tm_mday, - local->tm_hour, local->tm_min, local->tm_sec); - return result; -} - - -/* set file time */ - -int setfiletime (char *fname,time_t ftime) -{ -#ifdef _WIN32 - static int isWinNT = -1; - SYSTEMTIME st; - FILETIME locft, modft; - struct tm *loctm; - HANDLE hFile; - int result; - - loctm = localtime(&ftime); - if (loctm == NULL) - return -1; - - st.wYear = (WORD)loctm->tm_year + 1900; - st.wMonth = (WORD)loctm->tm_mon + 1; - st.wDayOfWeek = (WORD)loctm->tm_wday; - st.wDay = (WORD)loctm->tm_mday; - st.wHour = (WORD)loctm->tm_hour; - st.wMinute = (WORD)loctm->tm_min; - st.wSecond = (WORD)loctm->tm_sec; - st.wMilliseconds = 0; - if (!SystemTimeToFileTime(&st, &locft) || - !LocalFileTimeToFileTime(&locft, &modft)) - return -1; - - if (isWinNT < 0) - isWinNT = (GetVersion() < 0x80000000) ? 1 : 0; - hFile = CreateFile(fname, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, - (isWinNT ? FILE_FLAG_BACKUP_SEMANTICS : 0), - NULL); - if (hFile == INVALID_HANDLE_VALUE) - return -1; - result = SetFileTime(hFile, NULL, NULL, &modft) ? 0 : -1; - CloseHandle(hFile); - return result; -#else - struct utimbuf settime; - - settime.actime = settime.modtime = ftime; - return utime(fname,&settime); -#endif -} - - -/* push file attributes */ - -void push_attr(struct attr_item **list,char *fname,int mode,time_t time) -{ - struct attr_item *item; - - item = (struct attr_item *)malloc(sizeof(struct attr_item)); - if (item == NULL) - error("Out of memory"); - item->fname = strdup(fname); - item->mode = mode; - item->time = time; - item->next = *list; - *list = item; -} - - -/* restore file attributes */ - -void restore_attr(struct attr_item **list) -{ - struct attr_item *item, *prev; - - for (item = *list; item != NULL; ) - { - setfiletime(item->fname,item->time); - chmod(item->fname,item->mode); - prev = item; - item = item->next; - free(prev); - } - *list = NULL; -} - - -/* match regular expression */ - -#define ISSPECIAL(c) (((c) == '*') || ((c) == '/')) - -int ExprMatch (char *string,char *expr) -{ - while (1) - { - if (ISSPECIAL(*expr)) - { - if (*expr == '/') - { - if (*string != '\\' && *string != '/') - return 0; - string ++; expr++; - } - else if (*expr == '*') - { - if (*expr ++ == 0) - return 1; - while (*++string != *expr) - if (*string == 0) - return 0; - } - } - else - { - if (*string != *expr) - return 0; - if (*expr++ == 0) - return 1; - string++; - } - } -} - - -/* recursive mkdir */ -/* abort on ENOENT; ignore other errors like "directory already exists" */ -/* return 1 if OK */ -/* 0 on error */ - -int makedir (char *newdir) -{ - char *buffer = strdup(newdir); - char *p; - int len = strlen(buffer); - - if (len <= 0) { - free(buffer); - return 0; - } - if (buffer[len-1] == '/') { - buffer[len-1] = '\0'; - } - if (mkdir(buffer, 0755) == 0) - { - free(buffer); - return 1; - } - - p = buffer+1; - while (1) - { - char hold; - - while(*p && *p != '\\' && *p != '/') - p++; - hold = *p; - *p = 0; - if ((mkdir(buffer, 0755) == -1) && (errno == ENOENT)) - { - fprintf(stderr,"%s: Couldn't create directory %s\n",prog,buffer); - free(buffer); - return 0; - } - if (hold == 0) - break; - *p++ = hold; - } - free(buffer); - return 1; -} - - -int matchname (int arg,int argc,char **argv,char *fname) -{ - if (arg == argc) /* no arguments given (untgz tgzarchive) */ - return 1; - - while (arg < argc) - if (ExprMatch(fname,argv[arg++])) - return 1; - - return 0; /* ignore this for the moment being */ -} - - -/* tar file list or extract */ - -int tar (gzFile in,int action,int arg,int argc,char **argv) -{ - union tar_buffer buffer; - int len; - int err; - int getheader = 1; - int remaining = 0; - FILE *outfile = NULL; - char fname[BLOCKSIZE]; - int tarmode; - time_t tartime; - struct attr_item *attributes = NULL; - - if (action == TGZ_LIST) - printf(" date time size file\n" - " ---------- -------- --------- -------------------------------------\n"); - while (1) - { - len = gzread(in, &buffer, BLOCKSIZE); - if (len < 0) - error(gzerror(in, &err)); - /* - * Always expect complete blocks to process - * the tar information. - */ - if (len != BLOCKSIZE) - { - action = TGZ_INVALID; /* force error exit */ - remaining = 0; /* force I/O cleanup */ - } - - /* - * If we have to get a tar header - */ - if (getheader >= 1) - { - /* - * if we met the end of the tar - * or the end-of-tar block, - * we are done - */ - if (len == 0 || buffer.header.name[0] == 0) - break; - - tarmode = getoct(buffer.header.mode,8); - tartime = (time_t)getoct(buffer.header.mtime,12); - if (tarmode == -1 || tartime == (time_t)-1) - { - buffer.header.name[0] = 0; - action = TGZ_INVALID; - } - - if (getheader == 1) - { - strncpy(fname,buffer.header.name,SHORTNAMESIZE); - if (fname[SHORTNAMESIZE-1] != 0) - fname[SHORTNAMESIZE] = 0; - } - else - { - /* - * The file name is longer than SHORTNAMESIZE - */ - if (strncmp(fname,buffer.header.name,SHORTNAMESIZE-1) != 0) - error("bad long name"); - getheader = 1; - } - - /* - * Act according to the type flag - */ - switch (buffer.header.typeflag) - { - case DIRTYPE: - if (action == TGZ_LIST) - printf(" %s %s\n",strtime(&tartime),fname); - if (action == TGZ_EXTRACT) - { - makedir(fname); - push_attr(&attributes,fname,tarmode,tartime); - } - break; - case REGTYPE: - case AREGTYPE: - remaining = getoct(buffer.header.size,12); - if (remaining == -1) - { - action = TGZ_INVALID; - break; - } - if (action == TGZ_LIST) - printf(" %s %9d %s\n",strtime(&tartime),remaining,fname); - else if (action == TGZ_EXTRACT) - { - if (matchname(arg,argc,argv,fname)) - { - outfile = fopen(fname,"wb"); - if (outfile == NULL) { - /* try creating directory */ - char *p = strrchr(fname, '/'); - if (p != NULL) { - *p = '\0'; - makedir(fname); - *p = '/'; - outfile = fopen(fname,"wb"); - } - } - if (outfile != NULL) - printf("Extracting %s\n",fname); - else - fprintf(stderr, "%s: Couldn't create %s",prog,fname); - } - else - outfile = NULL; - } - getheader = 0; - break; - case GNUTYPE_LONGLINK: - case GNUTYPE_LONGNAME: - remaining = getoct(buffer.header.size,12); - if (remaining < 0 || remaining >= BLOCKSIZE) - { - action = TGZ_INVALID; - break; - } - len = gzread(in, fname, BLOCKSIZE); - if (len < 0) - error(gzerror(in, &err)); - if (fname[BLOCKSIZE-1] != 0 || (int)strlen(fname) > remaining) - { - action = TGZ_INVALID; - break; - } - getheader = 2; - break; - default: - if (action == TGZ_LIST) - printf(" %s <---> %s\n",strtime(&tartime),fname); - break; - } - } - else - { - unsigned int bytes = (remaining > BLOCKSIZE) ? BLOCKSIZE : remaining; - - if (outfile != NULL) - { - if (fwrite(&buffer,sizeof(char),bytes,outfile) != bytes) - { - fprintf(stderr, - "%s: Error writing %s -- skipping\n",prog,fname); - fclose(outfile); - outfile = NULL; - remove(fname); - } - } - remaining -= bytes; - } - - if (remaining == 0) - { - getheader = 1; - if (outfile != NULL) - { - fclose(outfile); - outfile = NULL; - if (action != TGZ_INVALID) - push_attr(&attributes,fname,tarmode,tartime); - } - } - - /* - * Abandon if errors are found - */ - if (action == TGZ_INVALID) - { - error("broken archive"); - break; - } - } - - /* - * Restore file modes and time stamps - */ - restore_attr(&attributes); - - if (gzclose(in) != Z_OK) - error("failed gzclose"); - - return 0; -} - - -/* ============================================================ */ - -void help(int exitval) -{ - printf("untgz version 0.2.1\n" - " using zlib version %s\n\n", - zlibVersion()); - printf("Usage: untgz file.tgz extract all files\n" - " untgz file.tgz fname ... extract selected files\n" - " untgz -l file.tgz list archive contents\n" - " untgz -h display this help\n"); - exit(exitval); -} - - -/* ============================================================ */ - -#if defined(WIN32) && defined(__GNUC__) -int _CRT_glob = 0; /* disable argument globbing in MinGW */ -#endif - -int main(int argc,char **argv) -{ - int action = TGZ_EXTRACT; - int arg = 1; - char *TGZfile; - gzFile f; - - prog = strrchr(argv[0],'\\'); - if (prog == NULL) - { - prog = strrchr(argv[0],'/'); - if (prog == NULL) - { - prog = strrchr(argv[0],':'); - if (prog == NULL) - prog = argv[0]; - else - prog++; - } - else - prog++; - } - else - prog++; - - if (argc == 1) - help(0); - - if (strcmp(argv[arg],"-l") == 0) - { - action = TGZ_LIST; - if (argc == ++arg) - help(0); - } - else if (strcmp(argv[arg],"-h") == 0) - { - help(0); - } - - if ((TGZfile = TGZfname(argv[arg])) == NULL) - TGZnotfound(argv[arg]); - - ++arg; - if ((action == TGZ_LIST) && (arg != argc)) - help(1); - -/* - * Process the TGZ file - */ - switch(action) - { - case TGZ_LIST: - case TGZ_EXTRACT: - f = gzopen(TGZfile,"rb"); - if (f == NULL) - { - fprintf(stderr,"%s: Couldn't gzopen %s\n",prog,TGZfile); - return 1; - } - exit(tar(f, action, arg, argc, argv)); - break; - - default: - error("Unknown option"); - exit(1); - } - - return 0; -} diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index fab91e4eb..098472ebf 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -98,15 +98,15 @@ if(ZLIB_BUILD_STATIC) target_link_options(infcover PRIVATE -coverage) target_compile_definitions( infcover PRIVATE $<$:HAVE_HIDDEN>) - add_test(NAME zlib-coverage COMMAND infcover) + add_test(NAME zlib_coverage COMMAND infcover) set(INFCOVER_DIR ${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/infcover.dir) add_test( - NAME zlib-coverage-summary + NAME zlib_coverage-summary COMMAND ${GCOV_EXECUTABLE} ${llvm_option} ${CMAKE_CURRENT_SOURCE_DIR}/infcover.c -o ${INFCOVER_DIR}/infcover.c.gcda) - set_tests_properties(zlib-coverage-summary PROPERTIES DEPENDS + set_tests_properties(zlib_coverage-summary PROPERTIES DEPENDS zlib-coverage) set(CMAKE_C_FLAGS ${CFLAGS_OLD}