#

CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12 FATAL_ERROR)

#

PROJECT(libarchive C)

#

SET(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build/cmake")

if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)

  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${libarchive_BINARY_DIR}/bin)

endif()

#

# Set the Build type for make based generators.

# You can choose following types:

#   Debug          : Debug build

#   Release        : Release build

#   RelWithDebInfo : Release build with Debug Info

#   MinSizeRel     : Release Min Size build

IF(NOT CMAKE_BUILD_TYPE)

  SET(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build Type" FORCE)

ENDIF(NOT CMAKE_BUILD_TYPE)

# Set a value type to properly display CMAKE_BUILD_TYPE on GUI if the

# value type is "UNINITIALIZED".

GET_PROPERTY(cached_type CACHE CMAKE_BUILD_TYPE PROPERTY TYPE)

IF("${cached_type}" STREQUAL "UNINITIALIZED")

  SET(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING "Build Type" FORCE)

ENDIF("${cached_type}" STREQUAL "UNINITIALIZED")

# Check the Build Type.

IF(NOT "${CMAKE_BUILD_TYPE}"

       MATCHES "^(Debug|Release|RelWithDebInfo|MinSizeRel)\$")

  MESSAGE(FATAL_ERROR

          "Unknown keyword for CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}\n"

          "Acceptable keywords: Debug,Release,RelWithDebInfo,MinSizeRel")

ENDIF(NOT "${CMAKE_BUILD_TYPE}"

          MATCHES "^(Debug|Release|RelWithDebInfo|MinSizeRel)\$")

# On MacOS, prefer MacPorts libraries to system libraries.

# I haven't come up with a compelling argument for this to be conditional.

list(APPEND CMAKE_PREFIX_PATH /opt/local)

# Enable @rpath in the install name.

# detail in "cmake  --help-policy CMP0042"

SET(CMAKE_MACOSX_RPATH ON)

#

# Version - read from 'version' file.

#

FILE(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/build/version _version)

STRING(REGEX REPLACE

 "^([0-9])[0-9][0-9][0-9][0-9][0-9][0-9][a-z]*$" "\\1" _major ${_version})

STRING(REGEX REPLACE

 "^[0-9]([0-9][0-9][0-9])[0-9][0-9][0-9][a-z]*$" "\\1" _minor ${_version})

STRING(REGEX REPLACE

 "^[0-9][0-9][0-9][0-9]([0-9][0-9][0-9])[a-z]*$" "\\1" _revision ${_version})

STRING(REGEX REPLACE

 "^[0-9][0-9][0-9][0-9][0-9][0-9][0-9]([a-z]*)$" "\\1" _quality ${_version})

SET(_version_number ${_major}${_minor}${_revision})

STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_minor ${_minor})

STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_revision ${_revision})

#

SET(VERSION                    "${_major}.${_trimmed_minor}.${_trimmed_revision}${_quality}")

SET(BSDCPIO_VERSION_STRING     "${VERSION}")

SET(BSDTAR_VERSION_STRING      "${VERSION}")

SET(BSDCAT_VERSION_STRING      "${VERSION}")

SET(LIBARCHIVE_VERSION_NUMBER  "${_version_number}")

SET(LIBARCHIVE_VERSION_STRING  "${VERSION}")

# INTERFACE_VERSION increments with every release

# libarchive 2.7 == interface version 9 = 2 + 7

# libarchive 2.8 == interface version 10 = 2 + 8

# libarchive 2.9 == interface version 11 = 2 + 9

# libarchive 3.0 == interface version 12

# libarchive 3.1 == interface version 13

math(EXPR INTERFACE_VERSION  "13 + ${_minor}")

# Set SOVERSION == Interface version

# ?? Should there be more here ??

SET(SOVERSION "${INTERFACE_VERSION}")

# Enalbe CMAKE_PUSH_CHECK_STATE() and CMAKE_POP_CHECK_STATE() macros

# saving and restoring the state of the variables.

INCLUDE(CMakePushCheckState)

# Initialize the state of the variables. This initialization is not

# necessary but this shows you what value the variables initially have.

SET(CMAKE_REQUIRED_DEFINITIONS)

SET(CMAKE_REQUIRED_INCLUDES)

SET(CMAKE_REQUIRED_LIBRARIES)

SET(CMAKE_REQUIRED_FLAGS)

# Especially for early development, we want to be a little

# aggressive about diagnosing build problems; this can get

# relaxed somewhat in final shipping versions.

IF (CMAKE_C_COMPILER_ID MATCHES "^GNU$")

  SET(CMAKE_REQUIRED_FLAGS "-Wall -Wformat -Wformat-security")

  #################################################################

  # Set compile flags for all build types.

  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wformat -Wformat-security")

  #################################################################

  # Set compile flags for debug build.

  # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Werror")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wextra")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wunused")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wshadow")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wmissing-prototypes")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wcast-qual")

ENDIF (CMAKE_C_COMPILER_ID MATCHES "^GNU$")

IF (CMAKE_C_COMPILER_ID MATCHES "^Clang$")

  SET(CMAKE_REQUIRED_FLAGS "-Wall -Wformat -Wformat-security")

  #################################################################

  # Set compile flags for all build types.

  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wformat -Wformat-security")

  #################################################################

  # Set compile flags for debug build.

  # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Werror")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wextra")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wunused")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wshadow")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wmissing-prototypes")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wcast-qual")

ENDIF (CMAKE_C_COMPILER_ID MATCHES "^Clang$")

IF (CMAKE_C_COMPILER_ID MATCHES "^XL$")

  SET(CMAKE_C_COMPILER "xlc_r")

  SET(CMAKE_REQUIRED_FLAGS "-qflag=e:e -qformat=sec")

  #################################################################

  # Set compile flags for all build types.

  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -qflag=e:e -qformat=sec")

  #################################################################

  # Set compile flags for debug build.

  # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -qhalt=w")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -qflag=w:w")

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -qinfo=pro:use")

ENDIF(CMAKE_C_COMPILER_ID MATCHES "^XL$")

IF (MSVC)

  #################################################################

  # Set compile flags for debug build.

  # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"

  # Enable level 4 C4061: The enumerate has no associated handler in a switch

  #                       statement.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4061")

  # Enable level 4 C4254: A larger bit field was assigned to a smaller bit

  #                       field.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4254")

  # Enable level 4 C4295: An array was initialized but the last character in

  #                       the array is not a null; accessing the array may

  #                       produce unexpected results.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4295")

  # Enable level 4 C4296: An unsigned variable was used in a comparison

  #                       operation with zero.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4296")

  # Enable level 4 C4389: An operation involved signed and unsigned variables.

  #                       This could result in a loss of data.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4389")

  # Enable level 4 C4505: The given function is local and not referenced in

  #                       the body of the module; therefore, the function is

  #                       dead code.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4505")

  # Enable level 4 C4514: The optimizer removed an inline function that is not

  #                       called.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4514")

  # Enable level 4 C4702: Unreachable code.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4702")

  # Enable level 4 C4706: The test value in a conditional expression was the

  #                       result of an assignment.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4706")

  # /WX option is the same as gcc's -Werror option.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /WX")

  # /Oi option enables built-in functions.

  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Oi")

  #################################################################

  # Set compile flags for release build.

  SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Oi")

ENDIF (MSVC)

# Enable CTest/CDash support

include(CTest)

OPTION(ENABLE_NETTLE "Enable use of Nettle" ON)

OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON)

OPTION(ENABLE_LZ4 "Enable the use of the system LZ4 library if found" ON)

OPTION(ENABLE_LZO "Enable the use of the system LZO library if found" OFF)

OPTION(ENABLE_LZMA "Enable the use of the system LZMA library if found" ON)

OPTION(ENABLE_ZLIB "Enable the use of the system ZLIB library if found" ON)

OPTION(ENABLE_BZip2 "Enable the use of the system BZip2 library if found" ON)

OPTION(ENABLE_LIBXML2 "Enable the use of the system libxml2 library if found" ON)

OPTION(ENABLE_EXPAT "Enable the use of the system EXPAT library if found" ON)

OPTION(ENABLE_PCREPOSIX "Enable the use of the system PCREPOSIX library if found" ON)

OPTION(ENABLE_LibGCC "Enable the use of the system LibGCC library if found" ON)

# CNG is used for encrypt/decrypt Zip archives on Windows.

OPTION(ENABLE_CNG "Enable the use of CNG(Crypto Next Generation)" ON)

OPTION(ENABLE_TAR "Enable tar building" ON)

OPTION(ENABLE_TAR_SHARED "Enable dynamic build of tar" FALSE)

OPTION(ENABLE_CPIO "Enable cpio building" ON)

OPTION(ENABLE_CPIO_SHARED "Enable dynamic build of cpio" FALSE)

OPTION(ENABLE_CAT "Enable cat building" ON)

OPTION(ENABLE_CAT_SHARED "Enable dynamic build of cat" FALSE)

OPTION(ENABLE_XATTR "Enable extended attribute support" ON)

OPTION(ENABLE_ACL "Enable ACL support" ON)

OPTION(ENABLE_ICONV "Enable iconv support" ON)

OPTION(ENABLE_TEST "Enable unit and regression tests" ON)

OPTION(ENABLE_COVERAGE "Enable code coverage (GCC only, automatically sets ENABLE_TEST to ON)" FALSE)

OPTION(ENABLE_INSTALL "Enable installing of libraries" ON)

SET(POSIX_REGEX_LIB "AUTO" CACHE STRING "Choose what library should provide POSIX regular expression support")

SET(ENABLE_SAFESEH "AUTO" CACHE STRING "Enable use of /SAFESEH linker flag (MSVC only)")

SET(WINDOWS_VERSION "WIN7" CACHE STRING "Set Windows version to use (Windows only)")

IF(ENABLE_COVERAGE)

	include(LibarchiveCodeCoverage)

ENDIF(ENABLE_COVERAGE)

IF(ENABLE_TEST)

	ENABLE_TESTING()

ENDIF(ENABLE_TEST)

IF(WIN32)

  IF(WINDOWS_VERSION STREQUAL "WIN8")

    SET(NTDDI_VERSION 0x06020000)

    SET(_WIN32_WINNT 0x0602)

    SET(WINVER 0x0602)

  ELSEIF(WINDOWS_VERSION STREQUAL "WIN7")

    SET(NTDDI_VERSION 0x06010000)

    SET(_WIN32_WINNT 0x0601)

    SET(WINVER 0x0601)

  ELSEIF(WINDOWS_VERSION STREQUAL "WS08")

    SET(NTDDI_VERSION 0x06000100)

    SET(_WIN32_WINNT 0x0600)

    SET(WINVER 0x0600)

  ELSEIF(WINDOWS_VERSION STREQUAL "VISTA")

    SET(NTDDI_VERSION 0x06000000)

    SET(_WIN32_WINNT 0x0600)

    SET(WINVER 0x0600)

  ELSEIF(WINDOWS_VERSION STREQUAL "WS03")

    SET(NTDDI_VERSION 0x05020000)

    SET(_WIN32_WINNT 0x0502)

    SET(WINVER 0x0502)

  ELSEIF(WINDOWS_VERSION STREQUAL "WINXP")

    SET(NTDDI_VERSION 0x05010000)

    SET(_WIN32_WINNT 0x0501)

    SET(WINVER 0x0501)

  ELSE(WINDOWS_VERSION STREQUAL "WIN8")

    # Default to Windows Server 2003 API if we don't recognize the specifier

    SET(NTDDI_VERSION 0x05020000)

    SET(_WIN32_WINNT 0x0502)

    SET(WINVER 0x0502)

  ENDIF(WINDOWS_VERSION STREQUAL "WIN8")

ENDIF(WIN32)

IF(MSVC)

  IF(ENABLE_SAFESEH STREQUAL "YES")

    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH")

    SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH")

    SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH")

    SET(ENV{LDFLAGS} "$ENV{LDFLAGS} /SAFESEH")

  ELSEIF(ENABLE_SAFESEH STREQUAL "NO")

    SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")

    SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")

    SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH:NO")

    SET(ENV{LDFLAGS} "$ENV{LDFLAGS} /SAFESEH:NO")

  ENDIF(ENABLE_SAFESEH STREQUAL "YES")

ENDIF(MSVC)

IF("${CMAKE_C_PLATFORM_ID}" MATCHES "^(HP-UX)$")

  ADD_DEFINITIONS(-D_XOPEN_SOURCE=500) # Ask wchar.h for mbstate_t

ENDIF()

#

INCLUDE(CheckCSourceCompiles)

INCLUDE(CheckCSourceRuns)

INCLUDE(CheckFileOffsetBits)

INCLUDE(CheckFuncs)

INCLUDE(CheckHeaderDirent)

INCLUDE(CheckIncludeFile)

INCLUDE(CheckIncludeFiles)

INCLUDE(CheckLibraryExists)

INCLUDE(CheckStructHasMember)

INCLUDE(CheckSymbolExists)

INCLUDE(CheckTypeExists)

INCLUDE(CheckTypeSize)

#

# Generate list.h

#

MACRO (GENERATE_LIST_H _listfile _cmlist __list_sources)

  SET(_argv ${ARGV})

  # Remove _listfile and _cmlist from _argv

  LIST(REMOVE_AT _argv 0 1)

  IF (NOT EXISTS "${_listfile}" OR

     ${_cmlist} IS_NEWER_THAN "${_listfile}")

    MESSAGE(STATUS "Generating ${_listfile}")

    FILE(WRITE ${_listfile} "")

    FOREACH (testfile ${_argv})

      IF (testfile MATCHES "^test_[^/]+[.]c$")

        FILE(STRINGS ${testfile} testvar REGEX "^DEFINE_TEST")

        FOREACH (deftest ${testvar})

          FILE(APPEND ${_listfile} "${deftest}\n")

        ENDFOREACH (deftest)

      ENDIF (testfile MATCHES "^test_[^/]+[.]c$")

    ENDFOREACH (testfile)

  ENDIF (NOT EXISTS "${_listfile}" OR

     ${_cmlist} IS_NEWER_THAN "${_listfile}")

ENDMACRO (GENERATE_LIST_H)

#

# Generate installation rules for man pages.

#

MACRO (INSTALL_MAN __mans)

  FOREACH (_man ${ARGV})

    STRING(REGEX REPLACE "^.+[.]([1-9])" "\\1" _mansect ${_man})

    INSTALL(FILES ${_man} DESTINATION "share/man/man${_mansect}")

  ENDFOREACH (_man)

ENDMACRO (INSTALL_MAN __mans)

#

# Find out what macro is needed to use libraries on Windows.

#

MACRO (TRY_MACRO_FOR_LIBRARY INCLUDES LIBRARIES

       TRY_TYPE SAMPLE_SOURCE MACRO_LIST)

  IF(WIN32 AND NOT CYGWIN)

    CMAKE_PUSH_CHECK_STATE()	# Save the state of the variables

    SET(CMAKE_REQUIRED_INCLUDES ${INCLUDES})

    SET(CMAKE_REQUIRED_LIBRARIES ${LIBRARIES})

    FOREACH(VAR ${MACRO_LIST})

      # Clear ${VAR} from CACHE If the libraries which ${VAR} was

      # checked with are changed.

      SET(VAR_WITH_LIB "${VAR}_WITH_LIB")

      GET_PROPERTY(PREV_VAR_WITH_LIB VARIABLE PROPERTY ${VAR_WITH_LIB})

      IF(NOT "${PREV_VAR_WITH_LIB}" STREQUAL "${LIBRARIES}")

        UNSET(${VAR} CACHE)

      ENDIF(NOT "${PREV_VAR_WITH_LIB}" STREQUAL "${LIBRARIES}")

      # Check if the library can be used with the macro.

      IF("${TRY_TYPE}" MATCHES "COMPILES")

        CHECK_C_SOURCE_COMPILES("${SAMPLE_SOURCE}" ${VAR})

      ELSEIF("${TRY_TYPE}" MATCHES "RUNS")

        CHECK_C_SOURCE_RUNS("${SAMPLE_SOURCE}" ${VAR})

      ELSE("${TRY_TYPE}" MATCHES "COMPILES")

        MESSAGE(FATAL_ERROR "UNKNOWN KEYWORD \"${TRY_TYPE}\" FOR TRY_TYPE")

      ENDIF("${TRY_TYPE}" MATCHES "COMPILES")

      # Save the libraries which ${VAR} is checked with.

      SET(${VAR_WITH_LIB} "${LIBRARIES}" CACHE INTERNAL

          "Macro ${VAR} is checked with")

    ENDFOREACH(VAR)

    CMAKE_POP_CHECK_STATE()	# Restore the state of the variables

  ENDIF(WIN32 AND NOT CYGWIN)

ENDMACRO (TRY_MACRO_FOR_LIBRARY)

#

# Check compress/decompress libraries

#

IF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN)

  # GnuWin32 is only for Win32, not Win64.

  SET(__GNUWIN32PATH "C:/Program Files/GnuWin32")

ENDIF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN)

IF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}")

  # You have to add a path availabel DLL file into PATH environment variable.

  # Maybe DLL path is "C:/Program Files/GnuWin32/bin".

  # The zlib and the bzip2 Setup program have installed programs and DLLs into

  # "C:/Program Files/GnuWin32" by default.

  # This is convenience setting for Windows.

  SET(CMAKE_PREFIX_PATH ${__GNUWIN32PATH} $(CMAKE_PREFIX_PATH))

  #

  # If you didn't use Setup program or installed into nonstandard path,

  # cmake cannot find out your zlib or bzip2 libraries and include files,

  # you should execute cmake with  -DCMAKE_PREFIX_PATH option.

  #   e.g.

  #     cmake -DCMAKE_PREFIX_PATH=<your-GnuWin32-path> <path-to-source>

  #

  # If compiling error occurred in zconf.h, You may need patch to zconf.h.

  #--- zconf.h.orig	2005-07-21 00:40:26.000000000

  #+++ zconf.h	2009-01-19 11:39:10.093750000

  #@@ -286,7 +286,7 @@

  #

  # #if 1           /* HAVE_UNISTD_H -- this line is updated by ./configure */

  # #  include <sys/types.h> /* for off_t */

  #-#  include <unistd.h>    /* for SEEK_* and off_t */

  #+#  include <stdio.h>    /* for SEEK_* and off_t */

  # #  ifdef VMS

  # #    include <unixio.h>   /* for off_t */

  # #  endif

ENDIF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}")

SET(ADDITIONAL_LIBS "")

#

# Find ZLIB

#

IF(ENABLE_ZLIB)

  FIND_PACKAGE(ZLIB)

ELSE()

  SET(ZLIB_FOUND FALSE) # Override cached value

ENDIF()

IF(ZLIB_FOUND)

  SET(HAVE_LIBZ 1)

  SET(HAVE_ZLIB_H 1)

  INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})

  LIST(APPEND ADDITIONAL_LIBS ${ZLIB_LIBRARIES})

  IF(WIN32 AND NOT CYGWIN)

    #

    # Test if ZLIB_WINAPI macro is needed to use.

    #

    TRY_MACRO_FOR_LIBRARY(

      "${ZLIB_INCLUDE_DIR}" "${ZLIB_LIBRARIES}"

      RUNS

      "#include <zlib.h>\nint main() {uLong f = zlibCompileFlags(); return (f&(1U<<10))?0:-1; }"

      ZLIB_WINAPI)

    IF(ZLIB_WINAPI)

      ADD_DEFINITIONS(-DZLIB_WINAPI)

    ELSE(ZLIB_WINAPI)

      # Test if a macro is needed for the library.

      TRY_MACRO_FOR_LIBRARY(

        "${ZLIB_INCLUDE_DIR}" "${ZLIB_LIBRARIES}"

        COMPILES

        "#include <zlib.h>\nint main() {return zlibVersion()?1:0; }"

        "ZLIB_DLL;WITHOUT_ZLIB_DLL")

      IF(ZLIB_DLL)

        ADD_DEFINITIONS(-DZLIB_DLL)

      ENDIF(ZLIB_DLL)

    ENDIF(ZLIB_WINAPI)

  ENDIF(WIN32 AND NOT CYGWIN)

ENDIF(ZLIB_FOUND)

MARK_AS_ADVANCED(CLEAR ZLIB_INCLUDE_DIR)

MARK_AS_ADVANCED(CLEAR ZLIB_LIBRARY)

#

# Find BZip2

#

IF(ENABLE_BZip2)

  FIND_PACKAGE(BZip2)

ELSE()

  SET(BZIP2_FOUND FALSE) # Override cached value

ENDIF()

IF(BZIP2_FOUND)

  SET(HAVE_LIBBZ2 1)

  SET(HAVE_BZLIB_H 1)

  INCLUDE_DIRECTORIES(${BZIP2_INCLUDE_DIR})

  LIST(APPEND ADDITIONAL_LIBS ${BZIP2_LIBRARIES})

  # Test if a macro is needed for the library.

  TRY_MACRO_FOR_LIBRARY(

    "${BZIP2_INCLUDE_DIR}" "${BZIP2_LIBRARIES}"

    COMPILES

    "#include <bzlib.h>\nint main() {return BZ2_bzlibVersion()?1:0; }"

    "USE_BZIP2_DLL;USE_BZIP2_STATIC")

  IF(USE_BZIP2_DLL)

    ADD_DEFINITIONS(-DUSE_BZIP2_DLL)

  ELSEIF(USE_BZIP2_STATIC)

    ADD_DEFINITIONS(-DUSE_BZIP2_STATIC)

  ENDIF(USE_BZIP2_DLL)

ENDIF(BZIP2_FOUND)

MARK_AS_ADVANCED(CLEAR BZIP2_INCLUDE_DIR)

MARK_AS_ADVANCED(CLEAR BZIP2_LIBRARIES)

#

# Find LZMA

#

IF(ENABLE_LZMA)

  FIND_PACKAGE(LibLZMA)

ELSE()

  SET(LIBZMA_FOUND FALSE) # Override cached value

ENDIF()

IF(LIBLZMA_FOUND)

  SET(HAVE_LIBLZMA 1)

  SET(HAVE_LZMA_H 1)

  SET(CMAKE_REQUIRED_INCLUDES ${LIBLZMA_INCLUDE_DIR})

  SET(CMAKE_REQUIRED_LIBRARIES ${LIBLZMA_LIBRARIES})

  INCLUDE_DIRECTORIES(${LIBLZMA_INCLUDE_DIRS})

  LIST(APPEND ADDITIONAL_LIBS ${LIBLZMA_LIBRARIES})

  # Test if a macro is needed for the library.

  TRY_MACRO_FOR_LIBRARY(

    "${LIBLZMA_INCLUDE_DIRS}" "${LIBLZMA_LIBRARIES}"

    COMPILES

    "#include <lzma.h>\nint main() {return (int)lzma_version_number(); }"

    "WITHOUT_LZMA_API_STATIC;LZMA_API_STATIC")

  IF(NOT WITHOUT_LZMA_API_STATIC AND LZMA_API_STATIC)

    ADD_DEFINITIONS(-DLZMA_API_STATIC)

  ENDIF(NOT WITHOUT_LZMA_API_STATIC AND LZMA_API_STATIC)

ELSE(LIBLZMA_FOUND)

# LZMA not found and will not be used.

ENDIF(LIBLZMA_FOUND)

#

# Find LZO2

#

IF(ENABLE_LZO)

  IF (LZO2_INCLUDE_DIR)

    # Already in cache, be silent

    SET(LZO2_FIND_QUIETLY TRUE)

  ENDIF (LZO2_INCLUDE_DIR)

  FIND_PATH(LZO2_INCLUDE_DIR lzo/lzoconf.h)

  FIND_LIBRARY(LZO2_LIBRARY NAMES lzo2 liblzo2)

  INCLUDE(FindPackageHandleStandardArgs)

  FIND_PACKAGE_HANDLE_STANDARD_ARGS(LZO2 DEFAULT_MSG LZO2_LIBRARY LZO2_INCLUDE_DIR)

ELSE(ENABLE_LZO)

  SET(LZO2_FOUND FALSE) # Override cached value

ENDIF(ENABLE_LZO)

IF(LZO2_FOUND)

  SET(HAVE_LIBLZO2 1)

  SET(HAVE_LZO_LZOCONF_H 1)

  SET(HAVE_LZO_LZO1X_H 1)

  INCLUDE_DIRECTORIES(${LZO2_INCLUDE_DIR})

  LIST(APPEND ADDITIONAL_LIBS ${LZO2_LIBRARY})

  #

  # TODO: test for static library.

  #

ENDIF(LZO2_FOUND)

MARK_AS_ADVANCED(CLEAR LZO2_INCLUDE_DIR)

MARK_AS_ADVANCED(CLEAR LZO2_LIBRARY)

#

# Find LZ4

#

IF(ENABLE_LZ4)

  IF (LZ4_INCLUDE_DIR)

    # Already in cache, be silent

    SET(LZ4_FIND_QUIETLY TRUE)

  ENDIF (LZ4_INCLUDE_DIR)

  FIND_PATH(LZ4_INCLUDE_DIR lz4.h)

  FIND_LIBRARY(LZ4_LIBRARY NAMES lz4 liblz4)

  INCLUDE(FindPackageHandleStandardArgs)

  FIND_PACKAGE_HANDLE_STANDARD_ARGS(LZ4 DEFAULT_MSG LZ4_LIBRARY LZ4_INCLUDE_DIR)

ELSE(ENABLE_LZ4)

  SET(LZ4_FOUND FALSE) # Override cached value

ENDIF(ENABLE_LZ4)

IF(LZ4_FOUND)

  SET(HAVE_LIBLZ4 1)

  SET(HAVE_LZ4_H 1)

  CMAKE_PUSH_CHECK_STATE()	# Save the state of the variables

  SET(CMAKE_REQUIRED_INCLUDES ${LZ4_INCLUDE_DIR})

  CHECK_INCLUDE_FILES("lz4hc.h" HAVE_LZ4HC_H)

  CMAKE_POP_CHECK_STATE()	# Restore the state of the variables

  INCLUDE_DIRECTORIES(${LZ4_INCLUDE_DIR})

  LIST(APPEND ADDITIONAL_LIBS ${LZ4_LIBRARY})

  #

  # TODO: test for static library.

  #

ENDIF(LZ4_FOUND)

MARK_AS_ADVANCED(CLEAR LZ4_INCLUDE_DIR)

MARK_AS_ADVANCED(CLEAR LZ4_LIBRARY)

#

# Find Zstd

#

IF (ZSTD_INCLUDE_DIR)

  # Already in cache, be silent

  SET(ZSTD_FIND_QUIETLY TRUE)

ENDIF (ZSTD_INCLUDE_DIR)

FIND_PATH(ZSTD_INCLUDE_DIR zstd.h)

FIND_LIBRARY(ZSTD_LIBRARY NAMES zstd libzstd)

INCLUDE(FindPackageHandleStandardArgs)

FIND_PACKAGE_HANDLE_STANDARD_ARGS(ZSTD DEFAULT_MSG ZSTD_LIBRARY ZSTD_INCLUDE_DIR)

IF(ZSTD_FOUND)

  SET(HAVE_ZSTD_H 1)

  INCLUDE_DIRECTORIES(${ZSTD_INCLUDE_DIR})

  LIST(APPEND ADDITIONAL_LIBS ${ZSTD_LIBRARY})

  SET(CMAKE_REQUIRED_LIBRARIES ${ZSTD_LIBRARY})

  SET(CMAKE_REQUIRED_INCLUDES ${ZSTD_INCLUDE_DIR})

  CHECK_FUNCTION_EXISTS(ZSTD_compressStream HAVE_LIBZSTD)

  #

  # TODO: test for static library.

  #

ENDIF(ZSTD_FOUND)

MARK_AS_ADVANCED(CLEAR ZSTD_INCLUDE_DIR)

MARK_AS_ADVANCED(CLEAR ZSTD_LIBRARY)

#

# Check headers

#

CHECK_HEADER_DIRENT()

SET(INCLUDES "")

MACRO (LA_CHECK_INCLUDE_FILE header var)

      CHECK_INCLUDE_FILES("${INCLUDES};${header}" ${var})

      IF (${var})

      	 SET(INCLUDES ${INCLUDES} ${header})

      ENDIF (${var})

ENDMACRO (LA_CHECK_INCLUDE_FILE)

# Some FreeBSD headers assume sys/types.h was already included.

LA_CHECK_INCLUDE_FILE("sys/types.h" HAVE_SYS_TYPES_H)

# Alphabetize the rest unless there's a compelling reason

LA_CHECK_INCLUDE_FILE("acl/libacl.h" HAVE_ACL_LIBACL_H)

LA_CHECK_INCLUDE_FILE("attr/xattr.h" HAVE_ATTR_XATTR_H)

LA_CHECK_INCLUDE_FILE("ctype.h" HAVE_CTYPE_H)

LA_CHECK_INCLUDE_FILE("copyfile.h" HAVE_COPYFILE_H)

LA_CHECK_INCLUDE_FILE("direct.h" HAVE_DIRECT_H)

LA_CHECK_INCLUDE_FILE("dlfcn.h" HAVE_DLFCN_H)

LA_CHECK_INCLUDE_FILE("errno.h" HAVE_ERRNO_H)

LA_CHECK_INCLUDE_FILE("ext2fs/ext2_fs.h" HAVE_EXT2FS_EXT2_FS_H)

CHECK_C_SOURCE_COMPILES("#include <sys/ioctl.h>

#include <ext2fs/ext2_fs.h>

int main(void) { return EXT2_IOC_GETFLAGS; }" HAVE_WORKING_EXT2_IOC_GETFLAGS)

LA_CHECK_INCLUDE_FILE("fcntl.h" HAVE_FCNTL_H)

LA_CHECK_INCLUDE_FILE("grp.h" HAVE_GRP_H)

LA_CHECK_INCLUDE_FILE("inttypes.h" HAVE_INTTYPES_H)

LA_CHECK_INCLUDE_FILE("io.h" HAVE_IO_H)

LA_CHECK_INCLUDE_FILE("langinfo.h" HAVE_LANGINFO_H)

LA_CHECK_INCLUDE_FILE("limits.h" HAVE_LIMITS_H)

LA_CHECK_INCLUDE_FILE("linux/types.h" HAVE_LINUX_TYPES_H)

LA_CHECK_INCLUDE_FILE("linux/fiemap.h" HAVE_LINUX_FIEMAP_H)

LA_CHECK_INCLUDE_FILE("linux/fs.h" HAVE_LINUX_FS_H)

CHECK_C_SOURCE_COMPILES("#include <sys/ioctl.h>

#include <linux/fs.h>

int main(void) { return FS_IOC_GETFLAGS; }" HAVE_WORKING_FS_IOC_GETFLAGS)

LA_CHECK_INCLUDE_FILE("linux/magic.h" HAVE_LINUX_MAGIC_H)

LA_CHECK_INCLUDE_FILE("locale.h" HAVE_LOCALE_H)

LA_CHECK_INCLUDE_FILE("membership.h" HAVE_MEMBERSHIP_H)

LA_CHECK_INCLUDE_FILE("memory.h" HAVE_MEMORY_H)

LA_CHECK_INCLUDE_FILE("paths.h" HAVE_PATHS_H)

LA_CHECK_INCLUDE_FILE("poll.h" HAVE_POLL_H)

LA_CHECK_INCLUDE_FILE("process.h" HAVE_PROCESS_H)

LA_CHECK_INCLUDE_FILE("pthread.h" HAVE_PTHREAD_H)

LA_CHECK_INCLUDE_FILE("pwd.h" HAVE_PWD_H)

LA_CHECK_INCLUDE_FILE("readpassphrase.h" HAVE_READPASSPHRASE_H)

LA_CHECK_INCLUDE_FILE("regex.h" HAVE_REGEX_H)

LA_CHECK_INCLUDE_FILE("signal.h" HAVE_SIGNAL_H)

LA_CHECK_INCLUDE_FILE("spawn.h" HAVE_SPAWN_H)

LA_CHECK_INCLUDE_FILE("stdarg.h" HAVE_STDARG_H)

LA_CHECK_INCLUDE_FILE("stdint.h" HAVE_STDINT_H)

LA_CHECK_INCLUDE_FILE("stdlib.h" HAVE_STDLIB_H)

LA_CHECK_INCLUDE_FILE("string.h" HAVE_STRING_H)

LA_CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H)

LA_CHECK_INCLUDE_FILE("sys/acl.h" HAVE_SYS_ACL_H)

LA_CHECK_INCLUDE_FILE("sys/cdefs.h" HAVE_SYS_CDEFS_H)

LA_CHECK_INCLUDE_FILE("sys/extattr.h" HAVE_SYS_EXTATTR_H)

LA_CHECK_INCLUDE_FILE("sys/ioctl.h" HAVE_SYS_IOCTL_H)

LA_CHECK_INCLUDE_FILE("sys/mkdev.h" HAVE_SYS_MKDEV_H)

LA_CHECK_INCLUDE_FILE("sys/mount.h" HAVE_SYS_MOUNT_H)

LA_CHECK_INCLUDE_FILE("sys/param.h" HAVE_SYS_PARAM_H)

LA_CHECK_INCLUDE_FILE("sys/poll.h" HAVE_SYS_POLL_H)

LA_CHECK_INCLUDE_FILE("sys/richacl.h" HAVE_SYS_RICHACL_H)

LA_CHECK_INCLUDE_FILE("sys/select.h" HAVE_SYS_SELECT_H)

LA_CHECK_INCLUDE_FILE("sys/stat.h" HAVE_SYS_STAT_H)

LA_CHECK_INCLUDE_FILE("sys/statfs.h" HAVE_SYS_STATFS_H)

LA_CHECK_INCLUDE_FILE("sys/statvfs.h" HAVE_SYS_STATVFS_H)

LA_CHECK_INCLUDE_FILE("sys/sysmacros.h" HAVE_SYS_SYSMACROS_H)

LA_CHECK_INCLUDE_FILE("sys/time.h" HAVE_SYS_TIME_H)

LA_CHECK_INCLUDE_FILE("sys/utime.h" HAVE_SYS_UTIME_H)

LA_CHECK_INCLUDE_FILE("sys/utsname.h" HAVE_SYS_UTSNAME_H)

LA_CHECK_INCLUDE_FILE("sys/vfs.h" HAVE_SYS_VFS_H)

LA_CHECK_INCLUDE_FILE("sys/wait.h" HAVE_SYS_WAIT_H)

LA_CHECK_INCLUDE_FILE("sys/xattr.h" HAVE_SYS_XATTR_H)

LA_CHECK_INCLUDE_FILE("time.h" HAVE_TIME_H)

LA_CHECK_INCLUDE_FILE("unistd.h" HAVE_UNISTD_H)

LA_CHECK_INCLUDE_FILE("utime.h" HAVE_UTIME_H)

LA_CHECK_INCLUDE_FILE("wchar.h" HAVE_WCHAR_H)

LA_CHECK_INCLUDE_FILE("wctype.h" HAVE_WCTYPE_H)

LA_CHECK_INCLUDE_FILE("windows.h" HAVE_WINDOWS_H)

IF(ENABLE_CNG)

  LA_CHECK_INCLUDE_FILE("Bcrypt.h" HAVE_BCRYPT_H)

  IF(HAVE_BCRYPT_H)

    LIST(APPEND ADDITIONAL_LIBS "Bcrypt")

  ENDIF(HAVE_BCRYPT_H)

ELSE(ENABLE_CNG)

  UNSET(HAVE_BCRYPT_H CACHE)

ENDIF(ENABLE_CNG)

# Following files need windows.h, so we should test it after windows.h test.

LA_CHECK_INCLUDE_FILE("wincrypt.h" HAVE_WINCRYPT_H)

LA_CHECK_INCLUDE_FILE("winioctl.h" HAVE_WINIOCTL_H)

#

# Check whether use of __EXTENSIONS__ is safe.

# We need some macro such as _GNU_SOURCE to use extension functions.

#

SET(_INCLUDE_FILES)

FOREACH (it ${_HEADER})

   SET(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n")

ENDFOREACH (it)

CHECK_C_SOURCE_COMPILES(

  "#define __EXTENSIONS__ 1

   ${_INCLUDE_FILES}

   int main() { return 0;}"

 SAFE_TO_DEFINE_EXTENSIONS)

#

# Find Nettle

#

IF(ENABLE_NETTLE)

  FIND_PACKAGE(Nettle)

  IF(NETTLE_FOUND)

    SET(HAVE_LIBNETTLE 1)

    LIST(APPEND ADDITIONAL_LIBS ${NETTLE_LIBRARIES})

    INCLUDE_DIRECTORIES(${NETTLE_INCLUDE_DIR})

    LIST(APPEND CMAKE_REQUIRED_INCLUDES ${NETTLE_INCLUDE_DIR})

    LA_CHECK_INCLUDE_FILE("nettle/aes.h" HAVE_NETTLE_AES_H)

    LA_CHECK_INCLUDE_FILE("nettle/hmac.h" HAVE_NETTLE_HMAC_H)

    LA_CHECK_INCLUDE_FILE("nettle/md5.h" HAVE_NETTLE_MD5_H)

    LA_CHECK_INCLUDE_FILE("nettle/pbkdf2.h" HAVE_NETTLE_PBKDF2_H)

    LA_CHECK_INCLUDE_FILE("nettle/ripemd160.h" HAVE_NETTLE_RIPEMD160_H)

    LA_CHECK_INCLUDE_FILE("nettle/sha.h" HAVE_NETTLE_SHA_H)

  ENDIF(NETTLE_FOUND)

  MARK_AS_ADVANCED(CLEAR NETTLE_INCLUDE_DIR)

  MARK_AS_ADVANCED(CLEAR NETTLE_LIBRARIES)

ENDIF(ENABLE_NETTLE)

#

# Find OpenSSL

# (Except on Mac, where OpenSSL is deprecated.)

#

IF(ENABLE_OPENSSL AND NOT CMAKE_SYSTEM_NAME MATCHES "Darwin")

  FIND_PACKAGE(OpenSSL)

  IF(OPENSSL_FOUND)

    SET(HAVE_LIBCRYPTO 1)

    INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})

    LIST(APPEND ADDITIONAL_LIBS ${OPENSSL_CRYPTO_LIBRARY})

  ENDIF(OPENSSL_FOUND)

ELSE()

  SET(OPENSSL_FOUND FALSE) # Override cached value

ENDIF()

# FreeBSD libmd

IF(NOT OPENSSL_FOUND)

  CHECK_LIBRARY_EXISTS(md "MD5Init" "" LIBMD_FOUND)

  IF(LIBMD_FOUND)

    CMAKE_PUSH_CHECK_STATE()	# Save the state of the variables

    SET(CMAKE_REQUIRED_LIBRARIES "md")

    FIND_LIBRARY(LIBMD_LIBRARY NAMES md)

    LIST(APPEND ADDITIONAL_LIBS ${LIBMD_LIBRARY})

    CMAKE_POP_CHECK_STATE()	# Restore the state of the variables

  ENDIF(LIBMD_FOUND)

ENDIF(NOT OPENSSL_FOUND)

#

# How to prove that CRYPTO functions, which have several names on various

# platforms, just see if archive_digest.c can compile and link against

# required libraries.

#

MACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION)

    FOREACH(ALGORITHM ${ALGORITHMS})

      IF(NOT ARCHIVE_CRYPTO_${ALGORITHM})

      STRING(TOLOWER "${ALGORITHM}" lower_algorithm)

      STRING(TOUPPER "${ALGORITHM}" algorithm)

      IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND)

        SET(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} FALSE)

      ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NOT NETTLE_FOUND)

        SET(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} FALSE)

      ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND)

      IF(NOT DEFINED ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})

        # Probe the local implementation for whether this

	# crypto implementation is available on this platform.

	SET(TRY_CRYPTO_REQUIRED_INCLUDES

	  "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR}/libarchive;${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp")

	SET(TRY_CRYPTO_REQUIRED_LIBS)

	IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)

	    SET(TRY_CRYPTO_REQUIRED_INCLUDES

	      "${TRY_CRYPTO_REQUIRED_INCLUDES};${OPENSSL_INCLUDE_DIR}")

	    SET(TRY_CRYPTO_REQUIRED_LIBS

	        "-DLINK_LIBRARIES:STRING=${OPENSSL_LIBRARIES}")

	ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NETTLE_FOUND)

	    SET(TRY_CRYPTO_REQUIRED_INCLUDES

	      "${TRY_CRYPTO_REQUIRED_INCLUDES};${NETTLE_INCLUDE_DIR}")

	    SET(TRY_CRYPTO_REQUIRED_LIBS

	        "-DLINK_LIBRARIES:STRING=${NETTLE_LIBRARY}")

	ELSEIF("${IMPLEMENTATION}" MATCHES "^LIBMD$" AND LIBMD_FOUND)

	    SET(TRY_CRYPTO_REQUIRED_LIBS

	        "-DLINK_LIBRARIES:STRING=${LIBMD_LIBRARY}")

	ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)

    CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in

      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h)

	FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h"

	     CONFDEFS_H)

	FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/libarchive/archive_digest.c"

	     ARCHIVE_CRYPTO_C)

	SET(SOURCE "${CONFDEFS_H}

#define ARCHIVE_${algorithm}_COMPILE_TEST

#define ARCHIVE_CRYPTO_${algorithm}_${IMPLEMENTATION}

#define PLATFORM_CONFIG_H \"check_crypto_md.h\"

${ARCHIVE_CRYPTO_C}

int

main(int argc, char **argv)

{

  archive_${lower_algorithm}_ctx ctx;

  archive_${lower_algorithm}_init(&ctx;;

  archive_${lower_algorithm}_update(&ctx, *argv, argc);

  archive_${lower_algorithm}_final(&ctx, NULL);

  return 0;

}

")

  FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.h" "")

	FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.c" "${SOURCE}")

	MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}")

	TRY_COMPILE(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}

	  ${CMAKE_BINARY_DIR}

	  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.c

	  CMAKE_FLAGS

	   "${TRY_CRYPTO_REQUIRED_LIBS}"

	   "${TRY_CRYPTO_REQUIRED_INCLUDES}"

	  OUTPUT_VARIABLE OUTPUT)

	# Inform user whether or not we found it; if not, log why we didn't.

        IF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})

          MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} -- found")

		  SET(ARCHIVE_CRYPTO_${ALGORITHM} 1)

        ELSE (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})

          MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} -- not found")

          FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log

    	    "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} failed with the following output:\n"

    	    "${OUTPUT}\n"

    	    "Source file was:\n${SOURCE}\n")

        ENDIF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})

      ENDIF(NOT DEFINED ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})

      # Add appropriate libs/includes depending on whether the implementation

      # was found on this platform.

      IF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})

        IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)

          INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})

	  LIST(APPEND ADDITIONAL_LIBS ${OPENSSL_LIBRARIES})

	   LIST(REMOVE_DUPLICATES ADDITIONAL_LIBS)

        ENDIF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)

      ENDIF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})

      ENDIF(NOT ARCHIVE_CRYPTO_${ALGORITHM})

    ENDFOREACH(ALGORITHM ${ALGORITHMS})

ENDMACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION)

#

# CRYPTO functions on Windows is defined at archive_windows.c, thus we do not

# need the test what the functions can be mapped to archive_{crypto name}_init,

# archive_{crypto name}_update and archive_{crypto name}_final.

# The functions on Windows use CALG_{crypto name} macro to create a crypt object

# and then we need to know what CALG_{crypto name} macros is available to show

# ARCHIVE_CRYPTO_{crypto name}_WIN macros because Windows 2000 and earlier version

# of Windows XP do not support SHA256, SHA384 and SHA512.

#

MACRO(CHECK_CRYPTO_WIN CRYPTO_LIST)

  IF(WIN32 AND NOT CYGWIN)

    FOREACH(CRYPTO ${CRYPTO_LIST})

      IF(NOT ARCHIVE_CRYPTO_${CRYPTO})

      IF(NOT DEFINED ARCHIVE_CRYPTO_${CRYPTO}_WIN)

	STRING(TOUPPER "${CRYPTO}" crypto)

	SET(ALGID "")

	IF ("${CRYPTO}" MATCHES "^MD5$")

	    SET(ALGID "CALG_MD5")

	ENDIF ("${CRYPTO}" MATCHES "^MD5$")

	IF ("${CRYPTO}" MATCHES "^SHA1$")

	    SET(ALGID "CALG_SHA1")

	ENDIF ("${CRYPTO}" MATCHES "^SHA1$")

	IF ("${CRYPTO}" MATCHES "^SHA256$")

	    SET(ALGID "CALG_SHA_256")

	ENDIF ("${CRYPTO}" MATCHES "^SHA256$")

	IF ("${CRYPTO}" MATCHES "^SHA384$")

	    SET(ALGID "CALG_SHA_384")

	ENDIF ("${CRYPTO}" MATCHES "^SHA384$")

	IF ("${CRYPTO}" MATCHES "^SHA512$")

	    SET(ALGID "CALG_SHA_512")

	ENDIF ("${CRYPTO}" MATCHES "^SHA512$")

    CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in

      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h)

	FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h"

	     CONFDEFS_H)

	SET(SOURCE "${CONFDEFS_H}

#define ${crypto}_COMPILE_TEST

#include <windows.h>

#include <wincrypt.h>

int

main(int argc, char **argv)

{

	return ${ALGID};

}