CMakeLists.txt

   1 #
   2 CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12 FATAL_ERROR)
   3 #
   4 PROJECT(libarchive C)
   5 #
   6 SET(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build/cmake")
   7 if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
   8   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${libarchive_BINARY_DIR}/bin)
   9 endif()
  10 #
  11 # Set the Build type for make based generators.
  12 # You can choose following types:
  13 #   Debug          : Debug build
  14 #   Release        : Release build
  15 #   RelWithDebInfo : Release build with Debug Info
  16 #   MinSizeRel     : Release Min Size build
  17 IF(NOT CMAKE_BUILD_TYPE)
  18   SET(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Build Type" FORCE)
  19 ENDIF(NOT CMAKE_BUILD_TYPE)
  20 # Set a value type to properly display CMAKE_BUILD_TYPE on GUI if the
  21 # value type is "UNINITIALIZED".
  22 GET_PROPERTY(cached_type CACHE CMAKE_BUILD_TYPE PROPERTY TYPE)
  23 IF("${cached_type}" STREQUAL "UNINITIALIZED")
  24   SET(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING "Build Type" FORCE)
  25 ENDIF("${cached_type}" STREQUAL "UNINITIALIZED")
  26 # Check the Build Type.
  27 IF(NOT "${CMAKE_BUILD_TYPE}"
  28        MATCHES "^(Debug|Release|RelWithDebInfo|MinSizeRel)\$")
  29   MESSAGE(FATAL_ERROR
  30           "Unknown keyword for CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}\n"
  31           "Acceptable keywords: Debug,Release,RelWithDebInfo,MinSizeRel")
  32 ENDIF(NOT "${CMAKE_BUILD_TYPE}"
  33           MATCHES "^(Debug|Release|RelWithDebInfo|MinSizeRel)\$")
  34
  35 # On MacOS, prefer MacPorts libraries to system libraries.
  36 # I haven't come up with a compelling argument for this to be conditional.
  37 list(APPEND CMAKE_PREFIX_PATH /opt/local)
  38 # Enable @rpath in the install name.
  39 # detail in "cmake  --help-policy CMP0042"
  40 SET(CMAKE_MACOSX_RPATH ON)
  41
  42 #
  43 # Version - read from 'version' file.
  44 #
  45 FILE(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/build/version _version)
  46 STRING(REGEX REPLACE
  47  "^([0-9])[0-9][0-9][0-9][0-9][0-9][0-9][a-z]?$" "\\1" _major ${_version})
  48 STRING(REGEX REPLACE
  49  "^[0-9]([0-9][0-9][0-9])[0-9][0-9][0-9][a-z]?$" "\\1" _minor ${_version})
  50 STRING(REGEX REPLACE
  51  "^[0-9][0-9][0-9][0-9]([0-9][0-9][0-9])[a-z]?$" "\\1" _revision ${_version})
  52 STRING(REGEX REPLACE
  53  "^[0-9][0-9][0-9][0-9][0-9][0-9][0-9]([a-z]?)$" "\\1" _quality ${_version})
  54 SET(_version_number ${_major}${_minor}${_revision})
  55 STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_minor ${_minor})
  56 STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_revision ${_revision})
  57 #
  58 SET(VERSION                    "${_major}.${_trimmed_minor}.${_trimmed_revision}${_quality}")
  59 SET(BSDCPIO_VERSION_STRING     "${VERSION}")
  60 SET(BSDTAR_VERSION_STRING      "${VERSION}")
  61 SET(BSDCAT_VERSION_STRING      "${VERSION}")
  62 SET(LIBARCHIVE_VERSION_NUMBER  "${_version_number}")
  63 SET(LIBARCHIVE_VERSION_STRING  "${VERSION}")
  64
  65 # INTERFACE_VERSION increments with every release
  66 # libarchive 2.7 == interface version 9 = 2 + 7
  67 # libarchive 2.8 == interface version 10 = 2 + 8
  68 # libarchive 2.9 == interface version 11 = 2 + 9
  69 # libarchive 3.0 == interface version 12
  70 # libarchive 3.1 == interface version 13
  71 math(EXPR INTERFACE_VERSION  "13 + ${_minor}")
  72
  73 # Set SOVERSION == Interface version
  74 # ?? Should there be more here ??
  75 SET(SOVERSION "${INTERFACE_VERSION}")
  76
  77 # Enalbe CMAKE_PUSH_CHECK_STATE() and CMAKE_POP_CHECK_STATE() macros
  78 # saving and restoring the state of the variables.
  79 INCLUDE(CMakePushCheckState)
  80
  81 # Initialize the state of the variables. This initialization is not
  82 # necessary but this shows you what value the variables initially have.
  83 SET(CMAKE_REQUIRED_DEFINITIONS)
  84 SET(CMAKE_REQUIRED_INCLUDES)
  85 SET(CMAKE_REQUIRED_LIBRARIES)
  86 SET(CMAKE_REQUIRED_FLAGS)
  87
  88 # Especially for early development, we want to be a little
  89 # aggressive about diagnosing build problems; this can get
  90 # relaxed somewhat in final shipping versions.
  91 IF (CMAKE_C_COMPILER_ID MATCHES "^GNU$")
  92   SET(CMAKE_REQUIRED_FLAGS "-Wall -Wformat -Wformat-security")
  93   #################################################################
  94   # Set compile flags for all build types.
  95   SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wformat -Wformat-security")
  96   #################################################################
  97   # Set compile flags for debug build.
  98   # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"
  99   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Werror")
 100   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wextra")
 101   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wunused")
 102   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wshadow")
 103   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wmissing-prototypes")
 104   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wcast-qual")
 105 ENDIF (CMAKE_C_COMPILER_ID MATCHES "^GNU$")
 106 IF (CMAKE_C_COMPILER_ID MATCHES "^Clang$")
 107   SET(CMAKE_REQUIRED_FLAGS "-Wall -Wformat -Wformat-security")
 108   #################################################################
 109   # Set compile flags for all build types.
 110   SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wformat -Wformat-security")
 111   #################################################################
 112   # Set compile flags for debug build.
 113   # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"
 114   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g")
 115   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Werror")
 116   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wextra")
 117   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wunused")
 118   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wshadow")
 119   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wmissing-prototypes")
 120   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wcast-qual")
 121 ENDIF (CMAKE_C_COMPILER_ID MATCHES "^Clang$")
 122 IF (CMAKE_C_COMPILER_ID MATCHES "^XL$")
 123   SET(CMAKE_C_COMPILER "xlc_r")
 124   SET(CMAKE_REQUIRED_FLAGS "-qflag=e:e -qformat=sec")
 125   #################################################################
 126   # Set compile flags for all build types.
 127   SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -qflag=e:e -qformat=sec")
 128   #################################################################
 129   # Set compile flags for debug build.
 130   # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"
 131   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -g")
 132   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -qhalt=w")
 133   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -qflag=w:w")
 134   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -qinfo=pro:use")
 135 ENDIF(CMAKE_C_COMPILER_ID MATCHES "^XL$")
 136 IF (MSVC)
 137   #################################################################
 138   # Set compile flags for debug build.
 139   # This is added into CMAKE_C_FLAGS when CMAKE_BUILD_TYPE is "Debug"
 140   # Enable level 4 C4061: The enumerate has no associated handler in a switch
 141   #                       statement.
 142   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4061")
 143   # Enable level 4 C4254: A larger bit field was assigned to a smaller bit
 144   #                       field.
 145   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4254")
 146   # Enable level 4 C4295: An array was initialized but the last character in
 147   #                       the array is not a null; accessing the array may
 148   #                       produce unexpected results.
 149   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4295")
 150   # Enable level 4 C4296: An unsigned variable was used in a comparison
 151   #                       operation with zero.
 152   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4296")
 153   # Enable level 4 C4389: An operation involved signed and unsigned variables.
 154   #                       This could result in a loss of data.
 155   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4389")
 156   # Enable level 4 C4505: The given function is local and not referenced in
 157   #                       the body of the module; therefore, the function is
 158   #                       dead code.
 159   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4505")
 160   # Enable level 4 C4514: The optimizer removed an inline function that is not
 161   #                       called.
 162   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4514")
 163   # Enable level 4 C4702: Unreachable code.
 164   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4702")
 165   # Enable level 4 C4706: The test value in a conditional expression was the
 166   #                       result of an assignment.
 167   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /we4706")
 168   # /WX option is the same as gcc's -Werror option.
 169   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /WX")
 170   # /Oi option enables built-in functions.
 171   SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Oi")
 172   #################################################################
 173   # Set compile flags for release build.
 174   SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Oi")
 175 ENDIF (MSVC)
 176
 177 # Enable CTest/CDash support
 178 include(CTest)
 179
 180 OPTION(ENABLE_NETTLE "Enable use of Nettle" ON)
 181 OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON)
 182 OPTION(ENABLE_LZMA "Enable the use of the system found LZMA library if found" ON)
 183 OPTION(ENABLE_ZLIB "Enable the use of the system found ZLIB library if found" ON)
 184 OPTION(ENABLE_BZip2 "Enable the use of the system found BZip2 library if found" ON)
 185 OPTION(ENABLE_LIBXML2 "Enable the use of the system found libxml2 library if found" ON)
 186 OPTION(ENABLE_EXPAT "Enable the use of the system found EXPAT library if found" ON)
 187 OPTION(ENABLE_PCREPOSIX "Enable the use of the system found PCREPOSIX library if found" ON)
 188 OPTION(ENABLE_LibGCC "Enable the use of the system found LibGCC library if found" ON)
 189 # CNG is used for encrypt/decrypt Zip archives on Windows.
 190 OPTION(ENABLE_CNG "Enable the use of CNG(Crypto Next Generation)" ON)
 191
 192 OPTION(ENABLE_TAR "Enable tar building" ON)
 193 OPTION(ENABLE_TAR_SHARED "Enable dynamic build of tar" FALSE)
 194 OPTION(ENABLE_CPIO "Enable cpio building" ON)
 195 OPTION(ENABLE_CPIO_SHARED "Enable dynamic build of cpio" FALSE)
 196 OPTION(ENABLE_CAT "Enable cat building" ON)
 197 OPTION(ENABLE_CAT_SHARED "Enable dynamic build of cat" FALSE)
 198 OPTION(ENABLE_XATTR "Enable extended attribute support" ON)
 199 OPTION(ENABLE_ACL "Enable ACL support" ON)
 200 OPTION(ENABLE_ICONV "Enable iconv support" ON)
 201 OPTION(ENABLE_TEST "Enable unit and regression tests" ON)
 202 OPTION(ENABLE_COVERAGE "Enable code coverage (GCC only, automatically sets ENABLE_TEST to ON)" FALSE)
 203 OPTION(ENABLE_INSTALL "Enable installing of libraries" ON)
 204
 205 SET(POSIX_REGEX_LIB "AUTO" CACHE STRING "Choose what library should provide POSIX regular expression support")
 206 SET(ENABLE_SAFESEH "AUTO" CACHE STRING "Enable use of /SAFESEH linker flag (MSVC only)")
 207 SET(WINDOWS_VERSION "WIN7" CACHE STRING "Set Windows version to use (Windows only)")
 208
 209 IF(ENABLE_COVERAGE)
 210         include(LibarchiveCodeCoverage)
 211 ENDIF(ENABLE_COVERAGE)
 212
 213 IF(ENABLE_TEST)
 214         ENABLE_TESTING()
 215 ENDIF(ENABLE_TEST)
 216
 217 IF(WIN32)
 218   IF(WINDOWS_VERSION STREQUAL "WIN8")
 219     SET(NTDDI_VERSION 0x06020000)
 220     SET(_WIN32_WINNT 0x0602)
 221     SET(WINVER 0x0602)
 222   ELSEIF(WINDOWS_VERSION STREQUAL "WIN7")
 223     SET(NTDDI_VERSION 0x06010000)
 224     SET(_WIN32_WINNT 0x0601)
 225     SET(WINVER 0x0601)
 226   ELSEIF(WINDOWS_VERSION STREQUAL "WS08")
 227     SET(NTDDI_VERSION 0x06000100)
 228     SET(_WIN32_WINNT 0x0600)
 229     SET(WINVER 0x0600)
 230   ELSEIF(WINDOWS_VERSION STREQUAL "VISTA")
 231     SET(NTDDI_VERSION 0x06000000)
 232     SET(_WIN32_WINNT 0x0600)
 233     SET(WINVER 0x0600)
 234   ELSEIF(WINDOWS_VERSION STREQUAL "WS03")
 235     SET(NTDDI_VERSION 0x05020000)
 236     SET(_WIN32_WINNT 0x0502)
 237     SET(WINVER 0x0502)
 238   ELSEIF(WINDOWS_VERSION STREQUAL "WINXP")
 239     SET(NTDDI_VERSION 0x05010000)
 240     SET(_WIN32_WINNT 0x0501)
 241     SET(WINVER 0x0501)
 242   ELSE(WINDOWS_VERSION STREQUAL "WIN8")
 243     # Default to Windows Server 2003 API if we don't recognize the specifier
 244     SET(NTDDI_VERSION 0x05020000)
 245     SET(_WIN32_WINNT 0x0502)
 246     SET(WINVER 0x0502)
 247   ENDIF(WINDOWS_VERSION STREQUAL "WIN8")
 248 ENDIF(WIN32)
 249
 250 IF(MSVC)
 251   IF(ENABLE_SAFESEH STREQUAL "YES")
 252     SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH")
 253     SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH")
 254     SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH")
 255     SET(ENV{LDFLAGS} "$ENV{LDFLAGS} /SAFESEH")
 256   ELSEIF(ENABLE_SAFESEH STREQUAL "NO")
 257     SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")
 258     SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")
 259     SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /SAFESEH:NO")
 260     SET(ENV{LDFLAGS} "$ENV{LDFLAGS} /SAFESEH:NO")
 261   ENDIF(ENABLE_SAFESEH STREQUAL "YES")
 262 ENDIF(MSVC)
 263
 264 IF("${CMAKE_C_PLATFORM_ID}" MATCHES "^(HP-UX)$")
 265   ADD_DEFINITIONS(-D_XOPEN_SOURCE=500) # Ask wchar.h for mbstate_t
 266 ENDIF()
 267
 268 #
 269 INCLUDE(CheckCSourceCompiles)
 270 INCLUDE(CheckCSourceRuns)
 271 INCLUDE(CheckFileOffsetBits)
 272 INCLUDE(CheckFuncs)
 273 INCLUDE(CheckHeaderDirent)
 274 INCLUDE(CheckIncludeFile)
 275 INCLUDE(CheckIncludeFiles)
 276 INCLUDE(CheckLibraryExists)
 277 INCLUDE(CheckStructHasMember)
 278 INCLUDE(CheckSymbolExists)
 279 INCLUDE(CheckTypeExists)
 280 INCLUDE(CheckTypeSize)
 281
 282 #
 283 # Generate list.h
 284 #
 285 MACRO (GENERATE_LIST_H _listfile _cmlist __list_sources)
 286   SET(_argv ${ARGV})
 287   # Remove _listfile and _cmlist from _argv
 288   LIST(REMOVE_AT _argv 0 1)
 289   IF (NOT EXISTS "${_listfile}" OR
 290      ${_cmlist} IS_NEWER_THAN "${_listfile}")
 291
 292     MESSAGE(STATUS "Generating ${_listfile}")
 293     FILE(WRITE ${_listfile} "")
 294     FOREACH (testfile ${_argv})
 295       IF (testfile MATCHES "^test_[^/]+[.]c$")
 296         FILE(STRINGS ${testfile} testvar REGEX "^DEFINE_TEST")
 297         FOREACH (deftest ${testvar})
 298           FILE(APPEND ${_listfile} "${deftest}\n")
 299         ENDFOREACH (deftest)
 300       ENDIF (testfile MATCHES "^test_[^/]+[.]c$")
 301     ENDFOREACH (testfile)
 302
 303   ENDIF (NOT EXISTS "${_listfile}" OR
 304      ${_cmlist} IS_NEWER_THAN "${_listfile}")
 305 ENDMACRO (GENERATE_LIST_H)
 306 #
 307 # Generate installation rules for man pages.
 308 #
 309 MACRO (INSTALL_MAN __mans)
 310   FOREACH (_man ${ARGV})
 311     STRING(REGEX REPLACE "^.+[.]([1-9])" "\\1" _mansect ${_man})
 312     INSTALL(FILES ${_man} DESTINATION "share/man/man${_mansect}")
 313   ENDFOREACH (_man)
 314 ENDMACRO (INSTALL_MAN __mans)
 315 #
 316 # Find out what macro is needed to use libraries on Windows.
 317 #
 318 MACRO (TRY_MACRO_FOR_LIBRARY INCLUDES LIBRARIES
 319        TRY_TYPE SAMPLE_SOURCE MACRO_LIST)
 320   IF(WIN32 AND NOT CYGWIN)
 321     CMAKE_PUSH_CHECK_STATE()    # Save the state of the variables
 322     SET(CMAKE_REQUIRED_INCLUDES ${INCLUDES})
 323     SET(CMAKE_REQUIRED_LIBRARIES ${LIBRARIES})
 324     FOREACH(VAR ${MACRO_LIST})
 325       # Clear ${VAR} from CACHE If the libraries which ${VAR} was
 326       # checked with are changed.
 327       SET(VAR_WITH_LIB "${VAR}_WITH_LIB")
 328       GET_PROPERTY(PREV_VAR_WITH_LIB VARIABLE PROPERTY ${VAR_WITH_LIB})
 329       IF(NOT "${PREV_VAR_WITH_LIB}" STREQUAL "${LIBRARIES}")
 330         UNSET(${VAR} CACHE)
 331       ENDIF(NOT "${PREV_VAR_WITH_LIB}" STREQUAL "${LIBRARIES}")
 332       # Check if the library can be used with the macro.
 333       IF("${TRY_TYPE}" MATCHES "COMPILES")
 334         CHECK_C_SOURCE_COMPILES("${SAMPLE_SOURCE}" ${VAR})
 335       ELSEIF("${TRY_TYPE}" MATCHES "RUNS")
 336         CHECK_C_SOURCE_RUNS("${SAMPLE_SOURCE}" ${VAR})
 337       ELSE("${TRY_TYPE}" MATCHES "COMPILES")
 338         MESSAGE(FATAL_ERROR "UNKNOWN KEYWORD \"${TRY_TYPE}\" FOR TRY_TYPE")
 339       ENDIF("${TRY_TYPE}" MATCHES "COMPILES")
 340       # Save the libraries which ${VAR} is checked with.
 341       SET(${VAR_WITH_LIB} "${LIBRARIES}" CACHE INTERNAL
 342           "Macro ${VAR} is checked with")
 343     ENDFOREACH(VAR)
 344     CMAKE_POP_CHECK_STATE()     # Restore the state of the variables
 345   ENDIF(WIN32 AND NOT CYGWIN)
 346 ENDMACRO (TRY_MACRO_FOR_LIBRARY)
 347 #
 348 # Check compress/decompress libraries
 349 #
 350 IF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN)
 351   # GnuWin32 is only for Win32, not Win64.
 352   SET(__GNUWIN32PATH "C:/Program Files/GnuWin32")
 353 ENDIF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN)
 354 IF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}")
 355   # You have to add a path availabel DLL file into PATH environment variable.
 356   # Maybe DLL path is "C:/Program Files/GnuWin32/bin".
 357   # The zlib and the bzip2 Setup program have installed programs and DLLs into
 358   # "C:/Program Files/GnuWin32" by default.
 359   # This is convenience setting for Windows.
 360   SET(CMAKE_PREFIX_PATH ${__GNUWIN32PATH} $(CMAKE_PREFIX_PATH))
 361   #
 362   # If you didn't use Setup program or installed into nonstandard path,
 363   # cmake cannot find out your zlib or bzip2 libraries and include files,
 364   # you should execute cmake with  -DCMAKE_PREFIX_PATH option.
 365   #   e.g.
 366   #     cmake -DCMAKE_PREFIX_PATH=<your-GnuWin32-path> <path-to-source>
 367   #
 368   # If compiling error occurred in zconf.h, You may need patch to zconf.h.
 369   #--- zconf.h.orig     2005-07-21 00:40:26.000000000
 370   #+++ zconf.h  2009-01-19 11:39:10.093750000
 371   #@@ -286,7 +286,7 @@
 372   #
 373   # #if 1           /* HAVE_UNISTD_H -- this line is updated by ./configure */
 374   # #  include <sys/types.h> /* for off_t */
 375   #-#  include <unistd.h>    /* for SEEK_* and off_t */
 376   #+#  include <stdio.h>    /* for SEEK_* and off_t */
 377   # #  ifdef VMS
 378   # #    include <unixio.h>   /* for off_t */
 379   # #  endif
 380 ENDIF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}")
 381
 382 SET(ADDITIONAL_LIBS "")
 383 #
 384 # Find ZLIB
 385 #
 386 IF(ENABLE_ZLIB)
 387   FIND_PACKAGE(ZLIB)
 388 ELSE()
 389   SET(ZLIB_FOUND FALSE) # Override cached value
 390 ENDIF()
 391 IF(ZLIB_FOUND)
 392   SET(HAVE_LIBZ 1)
 393   SET(HAVE_ZLIB_H 1)
 394   INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
 395   LIST(APPEND ADDITIONAL_LIBS ${ZLIB_LIBRARIES})
 396   IF(WIN32 AND NOT CYGWIN)
 397     #
 398     # Test if ZLIB_WINAPI macro is needed to use.
 399     #
 400     TRY_MACRO_FOR_LIBRARY(
 401       "${ZLIB_INCLUDE_DIR}" "${ZLIB_LIBRARIES}"
 402       RUNS
 403       "#include <zlib.h>\nint main() {uLong f = zlibCompileFlags(); return (f&(1U<<10))?0:-1; }"
 404       ZLIB_WINAPI)
 405     IF(ZLIB_WINAPI)
 406       ADD_DEFINITIONS(-DZLIB_WINAPI)
 407     ELSE(ZLIB_WINAPI)
 408       # Test if a macro is needed for the library.
 409       TRY_MACRO_FOR_LIBRARY(
 410         "${ZLIB_INCLUDE_DIR}" "${ZLIB_LIBRARIES}"
 411         COMPILES
 412         "#include <zlib.h>\nint main() {return zlibVersion()?1:0; }"
 413         "ZLIB_DLL;WITHOUT_ZLIB_DLL")
 414       IF(ZLIB_DLL)
 415         ADD_DEFINITIONS(-DZLIB_DLL)
 416       ENDIF(ZLIB_DLL)
 417     ENDIF(ZLIB_WINAPI)
 418   ENDIF(WIN32 AND NOT CYGWIN)
 419 ENDIF(ZLIB_FOUND)
 420 MARK_AS_ADVANCED(CLEAR ZLIB_INCLUDE_DIR)
 421 MARK_AS_ADVANCED(CLEAR ZLIB_LIBRARY)
 422 #
 423 # Find BZip2
 424 #
 425 IF(ENABLE_BZip2)
 426   FIND_PACKAGE(BZip2)
 427 ELSE()
 428   SET(BZIP2_FOUND FALSE) # Override cached value
 429 ENDIF()
 430 IF(BZIP2_FOUND)
 431   SET(HAVE_LIBBZ2 1)
 432   SET(HAVE_BZLIB_H 1)
 433   INCLUDE_DIRECTORIES(${BZIP2_INCLUDE_DIR})
 434   LIST(APPEND ADDITIONAL_LIBS ${BZIP2_LIBRARIES})
 435   # Test if a macro is needed for the library.
 436   TRY_MACRO_FOR_LIBRARY(
 437     "${BZIP2_INCLUDE_DIR}" "${BZIP2_LIBRARIES}"
 438     COMPILES
 439     "#include <bzlib.h>\nint main() {return BZ2_bzlibVersion()?1:0; }"
 440     "USE_BZIP2_DLL;USE_BZIP2_STATIC")
 441   IF(USE_BZIP2_DLL)
 442     ADD_DEFINITIONS(-DUSE_BZIP2_DLL)
 443   ELSEIF(USE_BZIP2_STATIC)
 444     ADD_DEFINITIONS(-DUSE_BZIP2_STATIC)
 445   ENDIF(USE_BZIP2_DLL)
 446 ENDIF(BZIP2_FOUND)
 447 MARK_AS_ADVANCED(CLEAR BZIP2_INCLUDE_DIR)
 448 MARK_AS_ADVANCED(CLEAR BZIP2_LIBRARIES)
 449
 450
 451 #
 452 # Find LZMA
 453 #
 454 IF(ENABLE_LZMA)
 455   FIND_PACKAGE(LibLZMA)
 456 ELSE()
 457   SET(LIBZMA_FOUND FALSE) # Override cached value
 458 ENDIF()
 459
 460 IF(LIBLZMA_FOUND)
 461   SET(HAVE_LIBLZMA 1)
 462   SET(HAVE_LZMA_H 1)
 463   INCLUDE_DIRECTORIES(${LIBLZMA_INCLUDE_DIRS})
 464   LIST(APPEND ADDITIONAL_LIBS ${LIBLZMA_LIBRARIES})
 465   # Test if a macro is needed for the library.
 466   TRY_MACRO_FOR_LIBRARY(
 467     "${LIBLZMA_INCLUDE_DIRS}" "${LIBLZMA_LIBRARIES}"
 468     COMPILES
 469     "#include <lzma.h>\nint main() {return (int)lzma_version_number(); }"
 470     "WITHOUT_LZMA_API_STATIC;LZMA_API_STATIC")
 471   IF(NOT WITHOUT_LZMA_API_STATIC AND LZMA_API_STATIC)
 472     ADD_DEFINITIONS(-DLZMA_API_STATIC)
 473   ENDIF(NOT WITHOUT_LZMA_API_STATIC AND LZMA_API_STATIC)
 474 ELSE(LIBLZMA_FOUND)
 475 # LZMA not found and will not be used.
 476 ENDIF(LIBLZMA_FOUND)
 477 #
 478 # Find LZO2
 479 #
 480 IF (LZO2_INCLUDE_DIR)
 481   # Already in cache, be silent
 482   SET(LZO2_FIND_QUIETLY TRUE)
 483 ENDIF (LZO2_INCLUDE_DIR)
 484
 485 FIND_PATH(LZO2_INCLUDE_DIR lzo/lzoconf.h)
 486 FIND_LIBRARY(LZO2_LIBRARY NAMES lzo2 liblzo2)
 487 INCLUDE(FindPackageHandleStandardArgs)
 488 FIND_PACKAGE_HANDLE_STANDARD_ARGS(LZO2 DEFAULT_MSG LZO2_LIBRARY LZO2_INCLUDE_DIR)
 489 IF(LZO2_FOUND)
 490   SET(HAVE_LIBLZO2 1)
 491   SET(HAVE_LZO_LZOCONF_H 1)
 492   SET(HAVE_LZO_LZO1X_H 1)
 493   INCLUDE_DIRECTORIES(${LZO2_INCLUDE_DIR})
 494   LIST(APPEND ADDITIONAL_LIBS ${LZO2_LIBRARY})
 495   #
 496   # TODO: test for static library.
 497   #
 498 ENDIF(LZO2_FOUND)
 499 MARK_AS_ADVANCED(CLEAR LZO2_INCLUDE_DIR)
 500 MARK_AS_ADVANCED(CLEAR LZO2_LIBRARY)
 501 #
 502 # Find LZ4
 503 #
 504 IF (LZ4_INCLUDE_DIR)
 505   # Already in cache, be silent
 506   SET(LZ4_FIND_QUIETLY TRUE)
 507 ENDIF (LZ4_INCLUDE_DIR)
 508
 509 FIND_PATH(LZ4_INCLUDE_DIR lz4.h)
 510 FIND_LIBRARY(LZ4_LIBRARY NAMES lz4 liblz4)
 511 INCLUDE(FindPackageHandleStandardArgs)
 512 FIND_PACKAGE_HANDLE_STANDARD_ARGS(LZ4 DEFAULT_MSG LZ4_LIBRARY LZ4_INCLUDE_DIR)
 513 IF(LZ4_FOUND)
 514   SET(HAVE_LIBLZ4 1)
 515   SET(HAVE_LZ4_H 1)
 516   CMAKE_PUSH_CHECK_STATE()      # Save the state of the variables
 517   SET(CMAKE_REQUIRED_INCLUDES ${LZ4_INCLUDE_DIR})
 518   CHECK_INCLUDE_FILES("lz4hc.h" HAVE_LZ4HC_H)
 519   CMAKE_POP_CHECK_STATE()       # Restore the state of the variables
 520   INCLUDE_DIRECTORIES(${LZ4_INCLUDE_DIR})
 521   LIST(APPEND ADDITIONAL_LIBS ${LZ4_LIBRARY})
 522   #
 523   # TODO: test for static library.
 524   #
 525 ENDIF(LZ4_FOUND)
 526 MARK_AS_ADVANCED(CLEAR LZ4_INCLUDE_DIR)
 527 MARK_AS_ADVANCED(CLEAR LZ4_LIBRARY)
 528
 529 #
 530 # Check headers
 531 #
 532 CHECK_HEADER_DIRENT()
 533
 534 SET(INCLUDES "")
 535 MACRO (LA_CHECK_INCLUDE_FILE header var)
 536       CHECK_INCLUDE_FILES("${INCLUDES};${header}" ${var})
 537       IF (${var})
 538          SET(INCLUDES ${INCLUDES} ${header})
 539       ENDIF (${var})
 540 ENDMACRO (LA_CHECK_INCLUDE_FILE)
 541
 542 # Some FreeBSD headers assume sys/types.h was already included.
 543 LA_CHECK_INCLUDE_FILE("sys/types.h" HAVE_SYS_TYPES_H)
 544
 545 # Alphabetize the rest unless there's a compelling reason
 546 LA_CHECK_INCLUDE_FILE("acl/libacl.h" HAVE_ACL_LIBACL_H)
 547 LA_CHECK_INCLUDE_FILE("ctype.h" HAVE_CTYPE_H)
 548 LA_CHECK_INCLUDE_FILE("copyfile.h" HAVE_COPYFILE_H)
 549 LA_CHECK_INCLUDE_FILE("direct.h" HAVE_DIRECT_H)
 550 LA_CHECK_INCLUDE_FILE("dlfcn.h" HAVE_DLFCN_H)
 551 LA_CHECK_INCLUDE_FILE("errno.h" HAVE_ERRNO_H)
 552 LA_CHECK_INCLUDE_FILE("ext2fs/ext2_fs.h" HAVE_EXT2FS_EXT2_FS_H)
 553
 554 CHECK_C_SOURCE_COMPILES("#include <sys/ioctl.h>
 555 #include <ext2fs/ext2_fs.h>
 556 int main(void) { return EXT2_IOC_GETFLAGS; }" HAVE_WORKING_EXT2_IOC_GETFLAGS)
 557
 558 LA_CHECK_INCLUDE_FILE("fcntl.h" HAVE_FCNTL_H)
 559 LA_CHECK_INCLUDE_FILE("grp.h" HAVE_GRP_H)
 560 LA_CHECK_INCLUDE_FILE("inttypes.h" HAVE_INTTYPES_H)
 561 LA_CHECK_INCLUDE_FILE("io.h" HAVE_IO_H)
 562 LA_CHECK_INCLUDE_FILE("langinfo.h" HAVE_LANGINFO_H)
 563 LA_CHECK_INCLUDE_FILE("limits.h" HAVE_LIMITS_H)
 564 LA_CHECK_INCLUDE_FILE("linux/types.h" HAVE_LINUX_TYPES_H)
 565 LA_CHECK_INCLUDE_FILE("linux/fiemap.h" HAVE_LINUX_FIEMAP_H)
 566 LA_CHECK_INCLUDE_FILE("linux/fs.h" HAVE_LINUX_FS_H)
 567 LA_CHECK_INCLUDE_FILE("linux/magic.h" HAVE_LINUX_MAGIC_H)
 568 LA_CHECK_INCLUDE_FILE("locale.h" HAVE_LOCALE_H)
 569 LA_CHECK_INCLUDE_FILE("memory.h" HAVE_MEMORY_H)
 570 LA_CHECK_INCLUDE_FILE("paths.h" HAVE_PATHS_H)
 571 LA_CHECK_INCLUDE_FILE("poll.h" HAVE_POLL_H)
 572 LA_CHECK_INCLUDE_FILE("process.h" HAVE_PROCESS_H)
 573 LA_CHECK_INCLUDE_FILE("pthread.h" HAVE_PTHREAD_H)
 574 LA_CHECK_INCLUDE_FILE("pwd.h" HAVE_PWD_H)
 575 LA_CHECK_INCLUDE_FILE("readpassphrase.h" HAVE_READPASSPHRASE_H)
 576 LA_CHECK_INCLUDE_FILE("regex.h" HAVE_REGEX_H)
 577 LA_CHECK_INCLUDE_FILE("signal.h" HAVE_SIGNAL_H)
 578 LA_CHECK_INCLUDE_FILE("spawn.h" HAVE_SPAWN_H)
 579 LA_CHECK_INCLUDE_FILE("stdarg.h" HAVE_STDARG_H)
 580 LA_CHECK_INCLUDE_FILE("stdint.h" HAVE_STDINT_H)
 581 LA_CHECK_INCLUDE_FILE("stdlib.h" HAVE_STDLIB_H)
 582 LA_CHECK_INCLUDE_FILE("string.h" HAVE_STRING_H)
 583 LA_CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H)
 584 LA_CHECK_INCLUDE_FILE("sys/acl.h" HAVE_SYS_ACL_H)
 585 LA_CHECK_INCLUDE_FILE("sys/cdefs.h" HAVE_SYS_CDEFS_H)
 586 LA_CHECK_INCLUDE_FILE("sys/ioctl.h" HAVE_SYS_IOCTL_H)
 587 LA_CHECK_INCLUDE_FILE("sys/mkdev.h" HAVE_SYS_MKDEV_H)
 588 LA_CHECK_INCLUDE_FILE("sys/mount.h" HAVE_SYS_MOUNT_H)
 589 LA_CHECK_INCLUDE_FILE("sys/param.h" HAVE_SYS_PARAM_H)
 590 LA_CHECK_INCLUDE_FILE("sys/poll.h" HAVE_SYS_POLL_H)
 591 LA_CHECK_INCLUDE_FILE("sys/select.h" HAVE_SYS_SELECT_H)
 592 LA_CHECK_INCLUDE_FILE("sys/stat.h" HAVE_SYS_STAT_H)
 593 LA_CHECK_INCLUDE_FILE("sys/statfs.h" HAVE_SYS_STATFS_H)
 594 LA_CHECK_INCLUDE_FILE("sys/statvfs.h" HAVE_SYS_STATVFS_H)
 595 LA_CHECK_INCLUDE_FILE("sys/time.h" HAVE_SYS_TIME_H)
 596 LA_CHECK_INCLUDE_FILE("sys/utime.h" HAVE_SYS_UTIME_H)
 597 LA_CHECK_INCLUDE_FILE("sys/utsname.h" HAVE_SYS_UTSNAME_H)
 598 LA_CHECK_INCLUDE_FILE("sys/vfs.h" HAVE_SYS_VFS_H)
 599 LA_CHECK_INCLUDE_FILE("sys/wait.h" HAVE_SYS_WAIT_H)
 600 LA_CHECK_INCLUDE_FILE("time.h" HAVE_TIME_H)
 601 LA_CHECK_INCLUDE_FILE("unistd.h" HAVE_UNISTD_H)
 602 LA_CHECK_INCLUDE_FILE("utime.h" HAVE_UTIME_H)
 603 LA_CHECK_INCLUDE_FILE("wchar.h" HAVE_WCHAR_H)
 604 LA_CHECK_INCLUDE_FILE("wctype.h" HAVE_WCTYPE_H)
 605 LA_CHECK_INCLUDE_FILE("windows.h" HAVE_WINDOWS_H)
 606 IF(ENABLE_CNG)
 607   LA_CHECK_INCLUDE_FILE("Bcrypt.h" HAVE_BCRYPT_H)
 608 ELSE(ENABLE_CNG)
 609   UNSET(HAVE_BCRYPT_H CACHE)
 610 ENDIF(ENABLE_CNG)
 611 # Following files need windows.h, so we should test it after windows.h test.
 612 LA_CHECK_INCLUDE_FILE("wincrypt.h" HAVE_WINCRYPT_H)
 613 LA_CHECK_INCLUDE_FILE("winioctl.h" HAVE_WINIOCTL_H)
 614
 615 #
 616 # Check whether use of __EXTENSIONS__ is safe.
 617 # We need some macro such as _GNU_SOURCE to use extension functions.
 618 #
 619 SET(_INCLUDE_FILES)
 620 FOREACH (it ${_HEADER})
 621    SET(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n")
 622 ENDFOREACH (it)
 623
 624 CHECK_C_SOURCE_COMPILES(
 625   "#define __EXTENSIONS__ 1
 626    ${_INCLUDE_FILES}
 627    int main() { return 0;}"
 628  SAFE_TO_DEFINE_EXTENSIONS)
 629
 630 #
 631 # Find Nettle
 632 #
 633 IF(ENABLE_NETTLE)
 634   FIND_PACKAGE(Nettle)
 635   IF(NETTLE_FOUND)
 636     SET(HAVE_LIBNETTLE 1)
 637     LIST(APPEND ADDITIONAL_LIBS ${NETTLE_LIBRARIES})
 638     INCLUDE_DIRECTORIES(${NETTLE_INCLUDE_DIR})
 639
 640     LIST(APPEND CMAKE_REQUIRED_INCLUDES ${NETTLE_INCLUDE_DIR})
 641     LA_CHECK_INCLUDE_FILE("nettle/aes.h" HAVE_NETTLE_AES_H)
 642     LA_CHECK_INCLUDE_FILE("nettle/hmac.h" HAVE_NETTLE_HMAC_H)
 643     LA_CHECK_INCLUDE_FILE("nettle/md5.h" HAVE_NETTLE_MD5_H)
 644     LA_CHECK_INCLUDE_FILE("nettle/pbkdf2.h" HAVE_NETTLE_PBKDF2_H)
 645     LA_CHECK_INCLUDE_FILE("nettle/ripemd160.h" HAVE_NETTLE_RIPEMD160_H)
 646     LA_CHECK_INCLUDE_FILE("nettle/sha.h" HAVE_NETTLE_SHA_H)
 647
 648   ENDIF(NETTLE_FOUND)
 649   MARK_AS_ADVANCED(CLEAR NETTLE_INCLUDE_DIR)
 650   MARK_AS_ADVANCED(CLEAR NETTLE_LIBRARIES)
 651 ENDIF(ENABLE_NETTLE)
 652
 653 #
 654 # Find OpenSSL
 655 # (Except on Mac, where OpenSSL is deprecated.)
 656 #
 657 IF(ENABLE_OPENSSL AND NOT CMAKE_SYSTEM_NAME MATCHES "Darwin")
 658   FIND_PACKAGE(OpenSSL)
 659   IF(OPENSSL_FOUND)
 660     SET(HAVE_LIBCRYPTO 1)
 661     INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
 662     LIST(APPEND ADDITIONAL_LIBS ${OPENSSL_CRYPTO_LIBRARY})
 663   ENDIF(OPENSSL_FOUND)
 664 ELSE()
 665   SET(OPENSSL_FOUND FALSE) # Override cached value
 666 ENDIF()
 667
 668 # FreeBSD libmd
 669 IF(NOT OPENSSL_FOUND)
 670   CHECK_LIBRARY_EXISTS(md "MD5Init" "" LIBMD_FOUND)
 671   IF(LIBMD_FOUND)
 672     CMAKE_PUSH_CHECK_STATE()    # Save the state of the variables
 673     SET(CMAKE_REQUIRED_LIBRARIES "md")
 674     FIND_LIBRARY(LIBMD_LIBRARY NAMES md)
 675     LIST(APPEND ADDITIONAL_LIBS ${LIBMD_LIBRARY})
 676     CMAKE_POP_CHECK_STATE()     # Restore the state of the variables
 677   ENDIF(LIBMD_FOUND)
 678 ENDIF(NOT OPENSSL_FOUND)
 679
 680 #
 681 # How to prove that CRYPTO functions, which have several names on various
 682 # platforms, just see if archive_digest.c can compile and link against
 683 # required libraries.
 684 #
 685 MACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION)
 686     FOREACH(ALGORITHM ${ALGORITHMS})
 687       IF(NOT ARCHIVE_CRYPTO_${ALGORITHM})
 688       STRING(TOLOWER "${ALGORITHM}" lower_algorithm)
 689       STRING(TOUPPER "${ALGORITHM}" algorithm)
 690       IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND)
 691         SET(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} FALSE)
 692       ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NOT NETTLE_FOUND)
 693         SET(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} FALSE)
 694       ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND)
 695
 696       IF(NOT DEFINED ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 697         # Probe the local implementation for whether this
 698         # crypto implementation is available on this platform.
 699         SET(TRY_CRYPTO_REQUIRED_INCLUDES
 700           "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR}/libarchive;${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp")
 701         SET(TRY_CRYPTO_REQUIRED_LIBS)
 702         IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
 703             SET(TRY_CRYPTO_REQUIRED_INCLUDES
 704               "${TRY_CRYPTO_REQUIRED_INCLUDES};${OPENSSL_INCLUDE_DIR}")
 705             SET(TRY_CRYPTO_REQUIRED_LIBS
 706                 "-DLINK_LIBRARIES:STRING=${OPENSSL_LIBRARIES}")
 707         ELSEIF("${IMPLEMENTATION}" MATCHES "^NETTLE$" AND NETTLE_FOUND)
 708             SET(TRY_CRYPTO_REQUIRED_INCLUDES
 709               "${TRY_CRYPTO_REQUIRED_INCLUDES};${NETTLE_INCLUDE_DIR}")
 710             SET(TRY_CRYPTO_REQUIRED_LIBS
 711                 "-DLINK_LIBRARIES:STRING=${NETTLE_LIBRARY}")
 712         ELSEIF("${IMPLEMENTATION}" MATCHES "^LIBMD$" AND LIBMD_FOUND)
 713             SET(TRY_CRYPTO_REQUIRED_LIBS
 714                 "-DLINK_LIBRARIES:STRING=${LIBMD_LIBRARY}")
 715         ENDIF("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
 716
 717     CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in
 718       ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h)
 719         FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h"
 720              CONFDEFS_H)
 721         FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/libarchive/archive_digest.c"
 722              ARCHIVE_CRYPTO_C)
 723
 724         SET(SOURCE "${CONFDEFS_H}
 725
 726 #define ARCHIVE_${algorithm}_COMPILE_TEST
 727 #define ARCHIVE_CRYPTO_${algorithm}_${IMPLEMENTATION}
 728 #define PLATFORM_CONFIG_H \"check_crypto_md.h\"
 729
 730 ${ARCHIVE_CRYPTO_C}
 731
 732 int
 733 main(int argc, char **argv)
 734 {
 735   archive_${lower_algorithm}_ctx ctx;
 736   archive_${lower_algorithm}_init(&ctx);
 737   archive_${lower_algorithm}_update(&ctx, *argv, argc);
 738   archive_${lower_algorithm}_final(&ctx, NULL);
 739   return 0;
 740 }
 741 ")
 742
 743   FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.h" "")
 744         FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.c" "${SOURCE}")
 745         MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}")
 746
 747         TRY_COMPILE(ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION}
 748           ${CMAKE_BINARY_DIR}
 749           ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_md.c
 750           CMAKE_FLAGS
 751            "${TRY_CRYPTO_REQUIRED_LIBS}"
 752            "${TRY_CRYPTO_REQUIRED_INCLUDES}"
 753           OUTPUT_VARIABLE OUTPUT)
 754
 755         # Inform user whether or not we found it; if not, log why we didn't.
 756         IF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 757           MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} -- found")
 758                   SET(ARCHIVE_CRYPTO_${ALGORITHM} 1)
 759         ELSE (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 760           MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} -- not found")
 761           FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 762             "Checking support for ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION} failed with the following output:\n"
 763             "${OUTPUT}\n"
 764             "Source file was:\n${SOURCE}\n")
 765         ENDIF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 766       ENDIF(NOT DEFINED ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 767
 768       # Add appropriate libs/includes depending on whether the implementation
 769       # was found on this platform.
 770       IF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 771         IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
 772           INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
 773           LIST(APPEND ADDITIONAL_LIBS ${OPENSSL_LIBRARIES})
 774            LIST(REMOVE_DUPLICATES ADDITIONAL_LIBS)
 775         ENDIF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND)
 776       ENDIF (ARCHIVE_CRYPTO_${ALGORITHM}_${IMPLEMENTATION})
 777       ENDIF(NOT ARCHIVE_CRYPTO_${ALGORITHM})
 778     ENDFOREACH(ALGORITHM ${ALGORITHMS})
 779 ENDMACRO(CHECK_CRYPTO ALGORITHMS IMPLEMENTATION)
 780
 781 #
 782 # CRYPTO functions on Windows is defined at archive_windows.c, thus we do not
 783 # need the test what the functions can be mapped to archive_{crypto name}_init,
 784 # archive_{crypto name}_update and archive_{crypto name}_final.
 785 # The functions on Windows use CALG_{crypto name} macro to create a crypt object
 786 # and then we need to know what CALG_{crypto name} macros is available to show
 787 # ARCHIVE_CRYPTO_{crypto name}_WIN macros because Windows 2000 and earlier version
 788 # of Windows XP do not support SHA256, SHA384 and SHA512.
 789 #
 790 MACRO(CHECK_CRYPTO_WIN CRYPTO_LIST)
 791   IF(WIN32 AND NOT CYGWIN)
 792     FOREACH(CRYPTO ${CRYPTO_LIST})
 793       IF(NOT ARCHIVE_CRYPTO_${CRYPTO})
 794       IF(NOT DEFINED ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 795         STRING(TOUPPER "${CRYPTO}" crypto)
 796         SET(ALGID "")
 797         IF ("${CRYPTO}" MATCHES "^MD5$")
 798             SET(ALGID "CALG_MD5")
 799         ENDIF ("${CRYPTO}" MATCHES "^MD5$")
 800         IF ("${CRYPTO}" MATCHES "^SHA1$")
 801             SET(ALGID "CALG_SHA1")
 802         ENDIF ("${CRYPTO}" MATCHES "^SHA1$")
 803         IF ("${CRYPTO}" MATCHES "^SHA256$")
 804             SET(ALGID "CALG_SHA_256")
 805         ENDIF ("${CRYPTO}" MATCHES "^SHA256$")
 806         IF ("${CRYPTO}" MATCHES "^SHA384$")
 807             SET(ALGID "CALG_SHA_384")
 808         ENDIF ("${CRYPTO}" MATCHES "^SHA384$")
 809         IF ("${CRYPTO}" MATCHES "^SHA512$")
 810             SET(ALGID "CALG_SHA_512")
 811         ENDIF ("${CRYPTO}" MATCHES "^SHA512$")
 812
 813     CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in
 814       ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h)
 815         FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/confdefs.h"
 816              CONFDEFS_H)
 817
 818         SET(SOURCE "${CONFDEFS_H}
 819
 820 #define ${crypto}_COMPILE_TEST
 821 #include <windows.h>
 822 #include <wincrypt.h>
 823
 824 int
 825 main(int argc, char **argv)
 826 {
 827         return ${ALGID};
 828 }
 829 ")
 830         SET(SOURCE_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_crypto_win.c")
 831
 832         FILE(WRITE "${SOURCE_FILE}" "${SOURCE}")
 833         MESSAGE(STATUS "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN")
 834
 835         TRY_COMPILE(ARCHIVE_CRYPTO_${CRYPTO}_WIN
 836           ${CMAKE_BINARY_DIR}
 837           ${SOURCE_FILE}
 838           CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_BINARY_DIR};${CMAKE_CURRENT_SOURCE_DIR}/libarchive"
 839           OUTPUT_VARIABLE OUTPUT)
 840
 841         IF (ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 842             MESSAGE(STATUS
 843                 "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN -- found")
 844                 SET(ARCHIVE_CRYPTO_${CRYPTO} 1)
 845         ELSE (ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 846             MESSAGE(STATUS
 847                  "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN -- not found")
 848             FILE(APPEND
 849                 ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
 850                 "Checking support for ARCHIVE_CRYPTO_${CRYPTO}_WIN failed with the following output:\n"
 851                 "${OUTPUT}\n"
 852                 "Source file was:\n${SOURCE}\n")
 853         ENDIF (ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 854
 855       ENDIF(NOT DEFINED ARCHIVE_CRYPTO_${CRYPTO}_WIN)
 856       ENDIF(NOT ARCHIVE_CRYPTO_${CRYPTO})
 857     ENDFOREACH(CRYPTO)
 858   ENDIF(WIN32 AND NOT CYGWIN)
 859 ENDMACRO(CHECK_CRYPTO_WIN CRYPTO_LIST)
 860
 861 #
 862 # Find iconv
 863 # POSIX defines the second arg as const char **
 864 # and requires it to be in libc.  But we can accept
 865 # a non-const argument here and can support iconv()
 866 # being in libiconv.
 867 #
 868 MACRO(CHECK_ICONV LIB TRY_ICONV_CONST)
 869   IF(NOT HAVE_ICONV)
 870     CMAKE_PUSH_CHECK_STATE()    # Save the state of the variables
 871     IF (CMAKE_C_COMPILER_ID MATCHES "^GNU$" OR
 872         CMAKE_C_COMPILER_ID MATCHES "^Clang$")
 873       #
 874       # During checking iconv proto type, we should use -Werror to avoid the
 875       # success of iconv detection with a warnig which success is a miss
 876       # detection. So this needs for all build mode(even it's a release mode).
 877       #
 878       SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror")
 879     ENDIF (CMAKE_C_COMPILER_ID MATCHES "^GNU$" OR
 880            CMAKE_C_COMPILER_ID MATCHES "^Clang$")
 881     IF (CMAKE_C_COMPILER_ID MATCHES "^XL$")
 882       SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -qhalt=w -qflag=w:w")
 883     ENDIF (CMAKE_C_COMPILER_ID MATCHES "^XL$")
 884     IF (MSVC)
 885       # NOTE: /WX option is the same as gcc's -Werror option.
 886       SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} /WX")
 887     ENDIF (MSVC)
 888     #
 889     CHECK_C_SOURCE_COMPILES(
 890       "#include <stdlib.h>
 891        #include <iconv.h>
 892        int main() {
 893           ${TRY_ICONV_CONST} char *ccp;
 894           iconv_t cd = iconv_open(\"\", \"\");
 895           iconv(cd, &ccp, (size_t *)0, (char **)0, (size_t *)0);
 896           iconv_close(cd);
 897           return 0;
 898        }"
 899      HAVE_ICONV_${LIB}_${TRY_ICONV_CONST})
 900     IF(HAVE_ICONV_${LIB}_${TRY_ICONV_CONST})
 901       SET(HAVE_ICONV true)
 902       SET(ICONV_CONST ${TRY_ICONV_CONST})
 903     ENDIF(HAVE_ICONV_${LIB}_${TRY_ICONV_CONST})
 904     CMAKE_POP_CHECK_STATE()     # Restore the state of the variables
 905   ENDIF(NOT HAVE_ICONV)
 906 ENDMACRO(CHECK_ICONV TRY_ICONV_CONST)
 907
 908 IF(ENABLE_ICONV)
 909   CMAKE_PUSH_CHECK_STATE()      # Save the state of the variables
 910   FIND_PATH(ICONV_INCLUDE_DIR iconv.h)
 911   IF(ICONV_INCLUDE_DIR)
 912     #SET(INCLUDES ${INCLUDES} "iconv.h")
 913     SET(HAVE_ICONV_H 1)
 914     INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR})
 915     SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR})
 916     CHECK_ICONV("libc" "const")
 917     CHECK_ICONV("libc" "")
 918
 919     # If iconv isn't in libc and we have a libiconv, try that.
 920     FIND_LIBRARY(LIBICONV_PATH NAMES iconv libiconv)
 921     IF(NOT HAVE_ICONV AND LIBICONV_PATH)
 922       LIST(APPEND CMAKE_REQUIRED_LIBRARIES ${LIBICONV_PATH})
 923       # Test if a macro is needed for the library.
 924       TRY_MACRO_FOR_LIBRARY(
 925         "${ICONV_INCLUDE_DIR}" "${LIBICONV_PATH}"
 926         COMPILES
 927         "#include <iconv.h>\nint main() {return iconv_close((iconv_t)0);}"
 928         "WITHOUT_LIBICONV_STATIC;LIBICONV_STATIC")
 929       IF(NOT WITHOUT_LIBICONV_STATIC AND LIBICONV_STATIC)
 930         ADD_DEFINITIONS(-DLIBICONV_STATIC)
 931       ENDIF(NOT WITHOUT_LIBICONV_STATIC AND LIBICONV_STATIC)
 932       #
 933       # Set up CMAKE_REQUIRED_* for CHECK_ICONV
 934       #
 935       SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR})
 936       SET(CMAKE_REQUIRED_LIBRARIES ${LIBICONV_PATH})
 937       IF(LIBICONV_STATIC)
 938         # LIBICONV_STATIC is necessary for the success of CHECK_ICONV
 939         # on Windows.
 940         SET(CMAKE_REQUIRED_DEFINITIONS "-DLIBICONV_STATIC")
 941       ELSE(LIBICONV_STATIC)
 942         SET(CMAKE_REQUIRED_DEFINITIONS)
 943       ENDIF(LIBICONV_STATIC)
 944       CHECK_ICONV("libiconv" "const")
 945       CHECK_ICONV("libiconv" "")
 946       IF (HAVE_ICONV)
 947         LIST(APPEND ADDITIONAL_LIBS ${LIBICONV_PATH})
 948       ENDIF(HAVE_ICONV)
 949     ENDIF(NOT HAVE_ICONV AND LIBICONV_PATH)
 950   ENDIF(ICONV_INCLUDE_DIR)
 951   #
 952   # Find locale_charset() for libiconv.
 953   #
 954   IF(LIBICONV_PATH)
 955     SET(CMAKE_REQUIRED_DEFINITIONS)
 956     SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR})
 957     SET(CMAKE_REQUIRED_LIBRARIES)
 958     CHECK_INCLUDE_FILES("localcharset.h" HAVE_LOCALCHARSET_H)
 959     FIND_LIBRARY(LIBCHARSET_PATH NAMES charset libcharset)
 960     IF(LIBCHARSET_PATH)
 961       SET(CMAKE_REQUIRED_LIBRARIES ${LIBCHARSET_PATH})
 962       IF(WIN32 AND NOT CYGWIN)
 963         # Test if a macro is needed for the library.
 964         TRY_MACRO_FOR_LIBRARY(
 965           "${ICONV_INCLUDE_DIR}" "${LIBCHARSET_PATH}"
 966           COMPILES
 967           "#include <localcharset.h>\nint main() {return locale_charset()?1:0;}"
 968           "WITHOUT_LIBCHARSET_STATIC;LIBCHARSET_STATIC")
 969         IF(NOT WITHOUT_LIBCHARSET_STATIC AND LIBCHARSET_STATIC)
 970           ADD_DEFINITIONS(-DLIBCHARSET_STATIC)
 971         ENDIF(NOT WITHOUT_LIBCHARSET_STATIC AND LIBCHARSET_STATIC)
 972         IF(WITHOUT_LIBCHARSET_STATIC OR LIBCHARSET_STATIC)
 973           SET(HAVE_LOCALE_CHARSET ON CACHE INTERNAL
 974               "Have function locale_charset")
 975         ENDIF(WITHOUT_LIBCHARSET_STATIC OR LIBCHARSET_STATIC)
 976       ELSE(WIN32 AND NOT CYGWIN)
 977         CHECK_FUNCTION_EXISTS_GLIBC(locale_charset HAVE_LOCALE_CHARSET)
 978       ENDIF(WIN32 AND NOT CYGWIN)
 979       IF(HAVE_LOCALE_CHARSET)
 980         LIST(APPEND ADDITIONAL_LIBS ${LIBCHARSET_PATH})
 981       ENDIF(HAVE_LOCALE_CHARSET)
 982     ENDIF(LIBCHARSET_PATH)
 983   ENDIF(LIBICONV_PATH)
 984   CMAKE_POP_CHECK_STATE()       # Restore the state of the variables
 985 ELSE(ENABLE_ICONV)
 986   # Make sure ICONV variables are not in CACHE after ENABLE_ICONV disabled
 987   # (once enabled).
 988   UNSET(HAVE_LOCALE_CHARSET CACHE)
 989   UNSET(HAVE_ICONV CACHE)
 990   UNSET(HAVE_ICONV_libc_ CACHE)
 991   UNSET(HAVE_ICONV_libc_const CACHE)
 992   UNSET(HAVE_ICONV_libiconv_ CACHE)
 993   UNSET(HAVE_ICONV_libiconv_const CACHE)
 994   UNSET(ICONV_INCLUDE_DIR CACHE)
 995   UNSET(LIBICONV_PATH CACHE)
 996   UNSET(LIBICONV_DLL CACHE)
 997   UNSET(LIBICONV_STATIC CACHE)
 998   UNSET(LIBCHARSET_DLL CACHE)
 999   UNSET(LIBCHARSET_STATIC CACHE)
1000 ENDIF(ENABLE_ICONV)
1001
1002 #
1003 # Find Libxml2
1004 #
1005 IF(ENABLE_LIBXML2)
1006   FIND_PACKAGE(LibXml2)
1007 ELSE()
1008   SET(LIBXML2_FOUND FALSE)
1009 ENDIF()
1010 IF(LIBXML2_FOUND)
1011   CMAKE_PUSH_CHECK_STATE()      # Save the state of the variables
1012   INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR})
1013   LIST(APPEND ADDITIONAL_LIBS ${LIBXML2_LIBRARIES})
1014   SET(HAVE_LIBXML2 1)
1015   # libxml2's include files use iconv.h
1016   SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR})
1017   CHECK_INCLUDE_FILES("libxml/xmlreader.h" HAVE_LIBXML_XMLREADER_H)
1018   CHECK_INCLUDE_FILES("libxml/xmlwriter.h" HAVE_LIBXML_XMLWRITER_H)
1019   # Test if a macro is needed for the library.
1020   TRY_MACRO_FOR_LIBRARY(
1021     "${ICONV_INCLUDE_DIR};${LIBXML2_INCLUDE_DIR}"
1022     "ws2_32.lib;${ZLIB_LIBRARIES};${LIBICONV_PATH};${LIBXML2_LIBRARIES}"
1023     COMPILES
1024     "#include <stddef.h>\n#include <libxml/xmlreader.h>\nint main() {return xmlTextReaderRead((xmlTextReaderPtr)(void *)0);}"
1025     "WITHOUT_LIBXML_STATIC;LIBXML_STATIC")
1026   IF(NOT WITHOUT_LIBXML_STATIC AND LIBXML_STATIC)
1027     ADD_DEFINITIONS(-DLIBXML_STATIC)
1028   ENDIF(NOT WITHOUT_LIBXML_STATIC AND LIBXML_STATIC)
1029   CMAKE_POP_CHECK_STATE()       # Restore the state of the variables
1030 ELSE(LIBXML2_FOUND)
1031   #
1032   # Find Expat
1033   #
1034   IF(ENABLE_EXPAT)
1035     FIND_PACKAGE(EXPAT)
1036   ELSE()
1037     SET(EXPAT_FOUND FALSE)
1038   ENDIF()
1039   IF(EXPAT_FOUND)
1040     CMAKE_PUSH_CHECK_STATE()    # Save the state of the variables
1041     INCLUDE_DIRECTORIES(${EXPAT_INCLUDE_DIR})
1042     LIST(APPEND ADDITIONAL_LIBS ${EXPAT_LIBRARIES})
1043     SET(HAVE_LIBEXPAT 1)
1044     LA_CHECK_INCLUDE_FILE("expat.h" HAVE_EXPAT_H)
1045     CMAKE_POP_CHECK_STATE()     # Restore the state of the variables
1046   ENDIF(EXPAT_FOUND)
1047 ENDIF(LIBXML2_FOUND)
1048 MARK_AS_ADVANCED(CLEAR LIBXML2_INCLUDE_DIR)
1049 MARK_AS_ADVANCED(CLEAR LIBXML2_LIBRARIES)
1050
1051 #
1052 # POSIX Regular Expression support
1053 #
1054 IF(POSIX_REGEX_LIB MATCHES "^(AUTO|LIBC|LIBREGEX)$")
1055   #
1056   # If PCREPOSIX is not found or not requested, try using regex
1057   # from libc or libregex
1058   #
1059   FIND_PATH(REGEX_INCLUDE_DIR regex.h)
1060   IF(REGEX_INCLUDE_DIR)
1061     CHECK_FUNCTION_EXISTS_GLIBC(regcomp HAVE_REGCOMP_LIBC)
1062     #
1063     # If libc does not provide regex, find libregex.
1064     #
1065     IF(NOT HAVE_REGCOMP_LIBC)
1066       CMAKE_PUSH_CHECK_STATE()  # Save the state of the variables
1067       FIND_LIBRARY(REGEX_LIBRARY regex)
1068       IF(REGEX_LIBRARY)
1069         SET(CMAKE_REQUIRED_LIBRARIES ${REGEX_LIBRARY})
1070         CHECK_FUNCTION_EXISTS_GLIBC(regcomp HAVE_REGCOMP_LIBREGEX)
1071         IF(HAVE_REGCOMP_LIBREGEX)
1072           LIST(APPEND ADDITIONAL_LIBS ${REGEX_LIBRARY})
1073           #
1074           # If regex.h is not found, retry looking for regex.h at
1075           # REGEX_INCLUDE_DIR
1076           #
1077           IF(NOT HAVE_REGEX_H)
1078             UNSET(HAVE_REGEX_H CACHE)
1079             INCLUDE_DIRECTORIES(${REGEX_INCLUDE_DIR})
1080             SET(CMAKE_REQUIRED_INCLUDES ${REGEX_INCLUDE_DIR})
1081             LA_CHECK_INCLUDE_FILE("regex.h" HAVE_REGEX_H)
1082           ENDIF(NOT HAVE_REGEX_H)
1083           # Test if a macro is needed for the library.
1084           TRY_MACRO_FOR_LIBRARY(
1085             "${REGEX_INCLUDE_DIR}" "${REGEX_LIBRARY}"
1086             COMPILES
1087             "#include <stddef.h>\n#include <regex.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}"
1088             "USE_REGEX_DLL;USE_REGEX_STATIC")
1089           IF(USE_REGEX_DLL)
1090             ADD_DEFINITIONS(-DUSE_REGEX_DLL)
1091           ELSEIF(USE_REGEX_STATIC)
1092             ADD_DEFINITIONS(-DUSE_REGEX_STATIC)
1093           ENDIF(USE_REGEX_DLL)
1094         ENDIF(HAVE_REGCOMP_LIBREGEX)
1095       ENDIF(REGEX_LIBRARY)
1096       CMAKE_POP_CHECK_STATE()   # Restore the state of the variables
1097     ENDIF(NOT HAVE_REGCOMP_LIBC)
1098   ENDIF(REGEX_INCLUDE_DIR)
1099   IF(HAVE_REGCOMP_LIBC OR HAVE_REGCOMP_LIBREGEX)
1100     SET(FOUND_POSIX_REGEX_LIB 1)
1101   ENDIF(HAVE_REGCOMP_LIBC OR HAVE_REGCOMP_LIBREGEX)
1102 ENDIF(POSIX_REGEX_LIB MATCHES "^(AUTO|LIBC|LIBREGEX)$")
1103
1104 IF(NOT FOUND_POSIX_REGEX_LIB AND POSIX_REGEX_LIB MATCHES "^(AUTO|LIBPCREPOSIX)$")
1105   #
1106   # If requested, try finding library for PCREPOSIX
1107   #
1108   IF(ENABLE_LibGCC)
1109     FIND_PACKAGE(LibGCC)
1110   ELSE()
1111     SET(LIBGCC_FOUND FALSE) # Override cached value
1112   ENDIF()
1113   IF(ENABLE_PCREPOSIX)
1114     FIND_PACKAGE(PCREPOSIX)
1115   ELSE()
1116     SET(PCREPOSIX_FOUND FALSE) # Override cached value
1117   ENDIF()
1118   IF(PCREPOSIX_FOUND)
1119     INCLUDE_DIRECTORIES(${PCRE_INCLUDE_DIR})
1120     LIST(APPEND ADDITIONAL_LIBS ${PCREPOSIX_LIBRARIES})
1121     # Test if a macro is needed for the library.
1122     TRY_MACRO_FOR_LIBRARY(
1123       "${PCRE_INCLUDE_DIR}" "${PCREPOSIX_LIBRARIES}"
1124       COMPILES
1125       "#include <pcreposix.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}"
1126       "WITHOUT_PCRE_STATIC;PCRE_STATIC")
1127     IF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1128       ADD_DEFINITIONS(-DPCRE_STATIC)
1129         ELSEIF(NOT WITHOUT_PCRE_STATIC AND NOT PCRE_STATIC AND PCRE_FOUND)
1130           # Determine if pcre static libraries are to be used.
1131       LIST(APPEND ADDITIONAL_LIBS ${PCRE_LIBRARIES})
1132       SET(TMP_LIBRARIES ${PCREPOSIX_LIBRARIES} ${PCRE_LIBRARIES})
1133       MESSAGE(STATUS "trying again with -lpcre included")
1134       TRY_MACRO_FOR_LIBRARY(
1135         "${PCRE_INCLUDE_DIR}" "${TMP_LIBRARIES}"
1136         COMPILES
1137         "#include <pcreposix.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}"
1138         "WITHOUT_PCRE_STATIC;PCRE_STATIC")
1139       IF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1140         ADD_DEFINITIONS(-DPCRE_STATIC)
1141       ELSEIF(NOT WITHOUT_PCRE_STATIC AND NOT PCRE_STATIC AND MSVC AND LIBGCC_FOUND)
1142         # When doing a Visual Studio build using pcre static libraries
1143         # built using the mingw toolchain, -lgcc is needed to resolve
1144         # ___chkstk_ms.
1145         MESSAGE(STATUS "Visual Studio build detected, trying again with -lgcc included")
1146         LIST(APPEND ADDITIONAL_LIBS ${LIBGCC_LIBRARIES})
1147         SET(TMP_LIBRARIES ${PCREPOSIX_LIBRARIES} ${PCRE_LIBRARIES} ${LIBGCC_LIBRARIES})
1148           TRY_MACRO_FOR_LIBRARY(
1149             "${PCRE_INCLUDE_DIR}" "${TMP_LIBRARIES}"
1150             COMPILES
1151             "#include <pcreposix.h>\nint main() {regex_t r;return regcomp(&r, \"\", 0);}"
1152             "WITHOUT_PCRE_STATIC;PCRE_STATIC")
1153           IF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1154             ADD_DEFINITIONS(-DPCRE_STATIC)
1155           ENDIF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1156       ENDIF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1157     ENDIF(NOT WITHOUT_PCRE_STATIC AND PCRE_STATIC)
1158   ENDIF(PCREPOSIX_FOUND)
1159   MARK_AS_ADVANCED(CLEAR PCRE_INCLUDE_DIR)
1160   MARK_AS_ADVANCED(CLEAR PCREPOSIX_LIBRARIES)
1161   MARK_AS_ADVANCED(CLEAR PCRE_LIBRARIES)
1162   MARK_AS_ADVANCED(CLEAR LIBGCC_LIBRARIES)
1163 ENDIF(NOT FOUND_POSIX_REGEX_LIB AND POSIX_REGEX_LIB MATCHES "^(AUTO|LIBPCREPOSIX)$")
1164
1165 #
1166 # Check functions
1167 #
1168 CMAKE_PUSH_CHECK_STATE()        # Save the state of the variables
1169 IF (CMAKE_C_COMPILER_ID MATCHES "^GNU$" OR
1170     CMAKE_C_COMPILER_ID MATCHES "^Clang$")
1171   #
1172   # During checking functions, we should use -fno-builtin to avoid the
1173   # failure of function detection which failure is an error "conflicting
1174   # types for built-in function" caused by using -Werror option.
1175   #
1176   SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fno-builtin")
1177 ENDIF (CMAKE_C_COMPILER_ID MATCHES "^GNU$" OR
1178        CMAKE_C_COMPILER_ID MATCHES "^Clang$")
1179 CHECK_SYMBOL_EXISTS(_CrtSetReportMode "crtdbg.h" HAVE__CrtSetReportMode)
1180 CHECK_FUNCTION_EXISTS_GLIBC(arc4random_buf HAVE_ARC4RANDOM_BUF)
1181 CHECK_FUNCTION_EXISTS_GLIBC(chflags HAVE_CHFLAGS)
1182 CHECK_FUNCTION_EXISTS_GLIBC(chown HAVE_CHOWN)
1183 CHECK_FUNCTION_EXISTS_GLIBC(chroot HAVE_CHROOT)
1184 CHECK_FUNCTION_EXISTS_GLIBC(ctime_r HAVE_CTIME_R)
1185 CHECK_FUNCTION_EXISTS_GLIBC(dirfd HAVE_DIRFD)
1186 CHECK_FUNCTION_EXISTS_GLIBC(fchdir HAVE_FCHDIR)
1187 CHECK_FUNCTION_EXISTS_GLIBC(fchflags HAVE_FCHFLAGS)
1188 CHECK_FUNCTION_EXISTS_GLIBC(fchmod HAVE_FCHMOD)
1189 CHECK_FUNCTION_EXISTS_GLIBC(fchown HAVE_FCHOWN)
1190 CHECK_FUNCTION_EXISTS_GLIBC(fcntl HAVE_FCNTL)
1191 CHECK_FUNCTION_EXISTS_GLIBC(fdopendir HAVE_FDOPENDIR)
1192 CHECK_FUNCTION_EXISTS_GLIBC(fork HAVE_FORK)
1193 CHECK_FUNCTION_EXISTS_GLIBC(fstat HAVE_FSTAT)
1194 CHECK_FUNCTION_EXISTS_GLIBC(fstatat HAVE_FSTATAT)
1195 CHECK_FUNCTION_EXISTS_GLIBC(fstatfs HAVE_FSTATFS)
1196 CHECK_FUNCTION_EXISTS_GLIBC(fstatvfs HAVE_FSTATVFS)
1197 CHECK_FUNCTION_EXISTS_GLIBC(ftruncate HAVE_FTRUNCATE)
1198 CHECK_FUNCTION_EXISTS_GLIBC(futimens HAVE_FUTIMENS)
1199 CHECK_FUNCTION_EXISTS_GLIBC(futimes HAVE_FUTIMES)
1200 CHECK_FUNCTION_EXISTS_GLIBC(futimesat HAVE_FUTIMESAT)
1201 CHECK_FUNCTION_EXISTS_GLIBC(geteuid HAVE_GETEUID)
1202 CHECK_FUNCTION_EXISTS_GLIBC(getgrgid_r HAVE_GETGRGID_R)
1203 CHECK_FUNCTION_EXISTS_GLIBC(getgrnam_r HAVE_GETGRNAM_R)
1204 CHECK_FUNCTION_EXISTS_GLIBC(getpwnam_r HAVE_GETPWNAM_R)
1205 CHECK_FUNCTION_EXISTS_GLIBC(getpwuid_r HAVE_GETPWUID_R)
1206 CHECK_FUNCTION_EXISTS_GLIBC(getpid HAVE_GETPID)
1207 CHECK_FUNCTION_EXISTS_GLIBC(getvfsbyname HAVE_GETVFSBYNAME)
1208 CHECK_FUNCTION_EXISTS_GLIBC(gmtime_r HAVE_GMTIME_R)
1209 CHECK_FUNCTION_EXISTS_GLIBC(lchflags HAVE_LCHFLAGS)
1210 CHECK_FUNCTION_EXISTS_GLIBC(lchmod HAVE_LCHMOD)
1211 CHECK_FUNCTION_EXISTS_GLIBC(lchown HAVE_LCHOWN)
1212 CHECK_FUNCTION_EXISTS_GLIBC(link HAVE_LINK)
1213 CHECK_FUNCTION_EXISTS_GLIBC(localtime_r HAVE_LOCALTIME_R)
1214 CHECK_FUNCTION_EXISTS_GLIBC(lstat HAVE_LSTAT)
1215 CHECK_FUNCTION_EXISTS_GLIBC(lutimes HAVE_LUTIMES)
1216 CHECK_FUNCTION_EXISTS_GLIBC(mbrtowc HAVE_MBRTOWC)
1217 CHECK_FUNCTION_EXISTS_GLIBC(memmove HAVE_MEMMOVE)
1218 CHECK_FUNCTION_EXISTS_GLIBC(mkdir HAVE_MKDIR)
1219 CHECK_FUNCTION_EXISTS_GLIBC(mkfifo HAVE_MKFIFO)
1220 CHECK_FUNCTION_EXISTS_GLIBC(mknod HAVE_MKNOD)
1221 CHECK_FUNCTION_EXISTS_GLIBC(mkstemp HAVE_MKSTEMP)
1222 CHECK_FUNCTION_EXISTS_GLIBC(nl_langinfo HAVE_NL_LANGINFO)
1223 CHECK_FUNCTION_EXISTS_GLIBC(openat HAVE_OPENAT)
1224 CHECK_FUNCTION_EXISTS_GLIBC(pipe HAVE_PIPE)
1225 CHECK_FUNCTION_EXISTS_GLIBC(poll HAVE_POLL)
1226 CHECK_FUNCTION_EXISTS_GLIBC(posix_spawnp HAVE_POSIX_SPAWNP)
1227 CHECK_FUNCTION_EXISTS_GLIBC(readlink HAVE_READLINK)
1228 CHECK_FUNCTION_EXISTS_GLIBC(readpassphrase HAVE_READPASSPHRASE)
1229 CHECK_FUNCTION_EXISTS_GLIBC(select HAVE_SELECT)
1230 CHECK_FUNCTION_EXISTS_GLIBC(setenv HAVE_SETENV)
1231 CHECK_FUNCTION_EXISTS_GLIBC(setlocale HAVE_SETLOCALE)
1232 CHECK_FUNCTION_EXISTS_GLIBC(sigaction HAVE_SIGACTION)
1233 CHECK_FUNCTION_EXISTS_GLIBC(statfs HAVE_STATFS)
1234 CHECK_FUNCTION_EXISTS_GLIBC(statvfs HAVE_STATVFS)
1235 CHECK_FUNCTION_EXISTS_GLIBC(strchr HAVE_STRCHR)
1236 CHECK_FUNCTION_EXISTS_GLIBC(strdup HAVE_STRDUP)
1237 CHECK_FUNCTION_EXISTS_GLIBC(strerror HAVE_STRERROR)
1238 CHECK_FUNCTION_EXISTS_GLIBC(strncpy_s HAVE_STRNCPY_S)
1239 CHECK_FUNCTION_EXISTS_GLIBC(strrchr HAVE_STRRCHR)
1240 CHECK_FUNCTION_EXISTS_GLIBC(symlink HAVE_SYMLINK)
1241 CHECK_FUNCTION_EXISTS_GLIBC(timegm HAVE_TIMEGM)
1242 CHECK_FUNCTION_EXISTS_GLIBC(tzset HAVE_TZSET)
1243 CHECK_FUNCTION_EXISTS_GLIBC(unsetenv HAVE_UNSETENV)
1244 CHECK_FUNCTION_EXISTS_GLIBC(utime HAVE_UTIME)
1245 CHECK_FUNCTION_EXISTS_GLIBC(utimes HAVE_UTIMES)
1246 CHECK_FUNCTION_EXISTS_GLIBC(utimensat HAVE_UTIMENSAT)
1247 CHECK_FUNCTION_EXISTS_GLIBC(vfork HAVE_VFORK)
1248 CHECK_FUNCTION_EXISTS_GLIBC(wcrtomb HAVE_WCRTOMB)
1249 CHECK_FUNCTION_EXISTS_GLIBC(wcscmp HAVE_WCSCMP)
1250 CHECK_FUNCTION_EXISTS_GLIBC(wcscpy HAVE_WCSCPY)
1251 CHECK_FUNCTION_EXISTS_GLIBC(wcslen HAVE_WCSLEN)
1252 CHECK_FUNCTION_EXISTS_GLIBC(wctomb HAVE_WCTOMB)
1253 CHECK_FUNCTION_EXISTS_GLIBC(_ctime64_s HAVE__CTIME64_S)
1254 CHECK_FUNCTION_EXISTS_GLIBC(_fseeki64 HAVE__FSEEKI64)
1255 CHECK_FUNCTION_EXISTS_GLIBC(_get_timezone HAVE__GET_TIMEZONE)
1256 CHECK_FUNCTION_EXISTS_GLIBC(_localtime64_s HAVE__LOCALTIME64_S)
1257 CHECK_FUNCTION_EXISTS_GLIBC(_mkgmtime64 HAVE__MKGMTIME64)
1258
1259 SET(CMAKE_REQUIRED_LIBRARIES "")
1260 CHECK_FUNCTION_EXISTS(cygwin_conv_path HAVE_CYGWIN_CONV_PATH)
1261 CHECK_FUNCTION_EXISTS(fseeko HAVE_FSEEKO)
1262 CHECK_FUNCTION_EXISTS(strerror_r HAVE_STRERROR_R)
1263 CHECK_FUNCTION_EXISTS(strftime HAVE_STRFTIME)
1264 CHECK_FUNCTION_EXISTS(vprintf HAVE_VPRINTF)
1265 CHECK_FUNCTION_EXISTS(wmemcmp HAVE_WMEMCMP)
1266 CHECK_FUNCTION_EXISTS(wmemcpy HAVE_WMEMCPY)
1267 CHECK_FUNCTION_EXISTS(wmemmove HAVE_WMEMMOVE)
1268
1269 CMAKE_POP_CHECK_STATE() # Restore the state of the variables
1270
1271 CHECK_C_SOURCE_COMPILES(
1272   "#include <sys/types.h>\n#include <sys/mount.h>\nint main(void) { struct vfsconf v; return sizeof(v);}"
1273   HAVE_STRUCT_VFSCONF)
1274
1275 CHECK_C_SOURCE_COMPILES(
1276   "#include <sys/types.h>\n#include <sys/mount.h>\nint main(void) { struct xvfsconf v; return sizeof(v);}"
1277   HAVE_STRUCT_XVFSCONF)
1278
1279 # Make sure we have the POSIX version of readdir_r, not the
1280 # older 2-argument version.
1281 CHECK_C_SOURCE_COMPILES(
1282   "#include <dirent.h>\nint main() {DIR *d = opendir(\".\"); struct dirent e,*r; return readdir_r(d,&e,&r);}"
1283   HAVE_READDIR_R)
1284
1285
1286 # Only detect readlinkat() if we also have AT_FDCWD in unistd.h.
1287 # NOTE: linux requires fcntl.h for AT_FDCWD.
1288 CHECK_C_SOURCE_COMPILES(
1289   "#include <fcntl.h>\n#include <unistd.h>\nint main() {char buf[10]; return readlinkat(AT_FDCWD, \"\", buf, 0);}"
1290   HAVE_READLINKAT)
1291
1292
1293 # To verify major(), we need to both include the header
1294 # of interest and verify that the result can be linked.
1295 # CHECK_FUNCTION_EXISTS doesn't accept a header argument,
1296 # CHECK_SYMBOL_EXISTS doesn't test linkage.
1297 CHECK_C_SOURCE_COMPILES(
1298   "#include <sys/mkdev.h>\nint main() { return major(256); }"
1299   MAJOR_IN_MKDEV)
1300 CHECK_C_SOURCE_COMPILES(
1301   "#include <sys/sysmacros.h>\nint main() { return major(256); }"
1302   MAJOR_IN_SYSMACROS)
1303
1304 CHECK_C_SOURCE_COMPILES(
1305   "#include <lzma.h>\n#if LZMA_VERSION < 50020000\n#error unsupported\n#endif\nint main(void){lzma_stream_encoder_mt(0, 0); return 0;}"
1306   HAVE_LZMA_STREAM_ENCODER_MT)
1307
1308 IF(HAVE_STRERROR_R)
1309   SET(HAVE_DECL_STRERROR_R 1)
1310 ENDIF(HAVE_STRERROR_R)
1311
1312 #
1313 # Check defines
1314 #
1315 SET(headers "limits.h")
1316 IF(HAVE_STDINT_H)
1317   LIST(APPEND headers "stdint.h")
1318 ENDIF(HAVE_STDINT_H)
1319 IF(HAVE_INTTYPES_H)
1320   LIST(APPEND headers "inttypes.h")
1321 ENDIF(HAVE_INTTYPES_H)
1322 CHECK_SYMBOL_EXISTS(EFTYPE           "errno.h"    HAVE_EFTYPE)
1323 CHECK_SYMBOL_EXISTS(EILSEQ           "errno.h"    HAVE_EILSEQ)
1324 CHECK_SYMBOL_EXISTS(D_MD_ORDER       "langinfo.h" HAVE_D_MD_ORDER)
1325 CHECK_SYMBOL_EXISTS(INT32_MAX        "${headers}" HAVE_DECL_INT32_MAX)
1326 CHECK_SYMBOL_EXISTS(INT32_MIN        "${headers}" HAVE_DECL_INT32_MIN)
1327 CHECK_SYMBOL_EXISTS(INT64_MAX        "${headers}" HAVE_DECL_INT64_MAX)
1328 CHECK_SYMBOL_EXISTS(INT64_MIN        "${headers}" HAVE_DECL_INT64_MIN)
1329 CHECK_SYMBOL_EXISTS(INTMAX_MAX       "${headers}" HAVE_DECL_INTMAX_MAX)
1330 CHECK_SYMBOL_EXISTS(INTMAX_MIN       "${headers}" HAVE_DECL_INTMAX_MIN)
1331 CHECK_SYMBOL_EXISTS(UINT32_MAX       "${headers}" HAVE_DECL_UINT32_MAX)
1332 CHECK_SYMBOL_EXISTS(UINT64_MAX       "${headers}" HAVE_DECL_UINT64_MAX)
1333 CHECK_SYMBOL_EXISTS(UINTMAX_MAX      "${headers}" HAVE_DECL_UINTMAX_MAX)
1334 CHECK_SYMBOL_EXISTS(SIZE_MAX         "${headers}" HAVE_DECL_SIZE_MAX)
1335 CHECK_SYMBOL_EXISTS(SSIZE_MAX        "limits.h"   HAVE_DECL_SSIZE_MAX)
1336
1337 #
1338 # Check struct members
1339 #
1340 # Check for tm_gmtoff in struct tm
1341 CHECK_STRUCT_HAS_MEMBER("struct tm" tm_gmtoff
1342     "time.h" HAVE_STRUCT_TM_TM_GMTOFF)
1343 CHECK_STRUCT_HAS_MEMBER("struct tm" __tm_gmtoff
1344     "time.h" HAVE_STRUCT_TM___TM_GMTOFF)
1345
1346 # Check for f_namemax in struct statfs
1347 CHECK_STRUCT_HAS_MEMBER("struct statfs" f_namemax
1348     "sys/param.h;sys/mount.h" HAVE_STRUCT_STATFS_F_NAMEMAX)
1349
1350 # Check for birthtime in struct stat
1351 CHECK_STRUCT_HAS_MEMBER("struct stat" st_birthtime
1352     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BIRTHTIME)
1353
1354 # Check for high-resolution timestamps in struct stat
1355 CHECK_STRUCT_HAS_MEMBER("struct stat" st_birthtimespec.tv_nsec
1356     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
1357 CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtimespec.tv_nsec
1358     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC)
1359 CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtim.tv_nsec
1360     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC)
1361 CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtime_n
1362     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIME_N)
1363 CHECK_STRUCT_HAS_MEMBER("struct stat" st_umtime
1364     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_UMTIME)
1365 CHECK_STRUCT_HAS_MEMBER("struct stat" st_mtime_usec
1366     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIME_USEC)
1367 # Check for block size support in struct stat
1368 CHECK_STRUCT_HAS_MEMBER("struct stat" st_blksize
1369     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BLKSIZE)
1370 # Check for st_flags in struct stat (BSD fflags)
1371 CHECK_STRUCT_HAS_MEMBER("struct stat" st_flags
1372     "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_FLAGS)
1373
1374 IF(HAVE_SYS_STATVFS_H)
1375   CHECK_STRUCT_HAS_MEMBER("struct statvfs" f_iosize
1376     "sys/types.h;sys/statvfs.h" HAVE_STRUCT_STATVFS_F_IOSIZE)
1377 ENDIF()
1378
1379 #
1380 #
1381 CHECK_STRUCT_HAS_MEMBER("struct tm" tm_sec
1382     "sys/types.h;sys/time.h;time.h" TIME_WITH_SYS_TIME)
1383
1384 #
1385 # Check for integer types
1386 #
1387 #
1388 CHECK_TYPE_SIZE("short" SIZE_OF_SHORT)
1389 CHECK_TYPE_SIZE("int" SIZE_OF_INT)
1390 CHECK_TYPE_SIZE("long" SIZE_OF_LONG)
1391 CHECK_TYPE_SIZE("long long"     SIZE_OF_LONG_LONG)
1392
1393 CHECK_TYPE_SIZE("unsigned short" SIZE_OF_UNSIGNED_SHORT)
1394 CHECK_TYPE_SIZE("unsigned" SIZE_OF_UNSIGNED)
1395 CHECK_TYPE_SIZE("unsigned long" SIZE_OF_UNSIGNED_LONG)
1396 CHECK_TYPE_SIZE("unsigned long long" SIZE_OF_UNSIGNED_LONG_LONG)
1397
1398 CHECK_TYPE_SIZE("__int64" __INT64)
1399 CHECK_TYPE_SIZE("unsigned __int64" UNSIGNED___INT64)
1400
1401 CHECK_TYPE_SIZE(int16_t INT16_T)
1402 CHECK_TYPE_SIZE(int32_t INT32_T)
1403 CHECK_TYPE_SIZE(int64_t INT64_T)
1404 CHECK_TYPE_SIZE(intmax_t INTMAX_T)
1405 CHECK_TYPE_SIZE(uint8_t UINT8_T)
1406 CHECK_TYPE_SIZE(uint16_t UINT16_T)
1407 CHECK_TYPE_SIZE(uint32_t UINT32_T)
1408 CHECK_TYPE_SIZE(uint64_t UINT64_T)
1409 CHECK_TYPE_SIZE(uintmax_t UINTMAX_T)
1410
1411 CHECK_TYPE_SIZE(dev_t       DEV_T)
1412 IF(NOT HAVE_DEV_T)
1413   IF(MSVC)
1414     SET(dev_t "unsigned int")
1415   ENDIF(MSVC)
1416 ENDIF(NOT HAVE_DEV_T)
1417 #
1418 CHECK_TYPE_SIZE(gid_t       GID_T)
1419 IF(NOT HAVE_GID_T)
1420   IF(WIN32)
1421     SET(gid_t "short")
1422   ELSE(WIN32)
1423     SET(gid_t "unsigned int")
1424   ENDIF(WIN32)
1425 ENDIF(NOT HAVE_GID_T)
1426 #
1427 CHECK_TYPE_SIZE(id_t        ID_T)
1428 IF(NOT HAVE_ID_T)
1429   IF(WIN32)
1430     SET(id_t "short")
1431   ELSE(WIN32)
1432     SET(id_t "unsigned int")
1433   ENDIF(WIN32)
1434 ENDIF(NOT HAVE_ID_T)
1435 #
1436 CHECK_TYPE_SIZE(mode_t      MODE_T)
1437 IF(NOT HAVE_MODE_T)
1438   IF(WIN32)
1439     SET(mode_t "unsigned short")
1440   ELSE(WIN32)
1441     SET(mode_t "int")
1442   ENDIF(WIN32)
1443 ENDIF(NOT HAVE_MODE_T)
1444 #
1445 CHECK_TYPE_SIZE(off_t       OFF_T)
1446 IF(NOT HAVE_OFF_T)
1447   SET(off_t "__int64")
1448 ENDIF(NOT HAVE_OFF_T)
1449 #
1450 CHECK_TYPE_SIZE(size_t      SIZE_T)
1451 IF(NOT HAVE_SIZE_T)
1452   IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1453     SET(size_t "uint64_t")
1454   ELSE("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1455     SET(size_t   "uint32_t")
1456   ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1457 ENDIF(NOT HAVE_SIZE_T)
1458 #
1459 CHECK_TYPE_SIZE(ssize_t     SSIZE_T)
1460 IF(NOT HAVE_SSIZE_T)
1461   IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1462     SET(ssize_t "int64_t")
1463   ELSE("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1464     SET(ssize_t "long")
1465   ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1466 ENDIF(NOT HAVE_SSIZE_T)
1467 #
1468 CHECK_TYPE_SIZE(uid_t       UID_T)
1469 IF(NOT HAVE_UID_T)
1470   IF(WIN32)
1471     SET(uid_t "short")
1472   ELSE(WIN32)
1473     SET(uid_t "unsigned int")
1474   ENDIF(WIN32)
1475 ENDIF(NOT HAVE_UID_T)
1476 #
1477 CHECK_TYPE_SIZE(pid_t       PID_T)
1478 IF(NOT HAVE_PID_T)
1479   IF(WIN32)
1480     SET(pid_t "int")
1481   ELSE(WIN32)
1482     MESSAGE(FATAL_ERROR "pid_t doesn't exist on this platform?")
1483   ENDIF(WIN32)
1484 ENDIF(NOT HAVE_PID_T)
1485 #
1486 CHECK_TYPE_SIZE(intptr_t   INTPTR_T)
1487 IF(NOT HAVE_INTPTR_T)
1488   IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1489     SET(intptr_t "int64_t")
1490   ELSE()
1491     SET(intptr_t "int32_t")
1492   ENDIF()
1493 ENDIF(NOT HAVE_INTPTR_T)
1494 #
1495 CHECK_TYPE_SIZE(uintptr_t   UINTPTR_T)
1496 IF(NOT HAVE_UINTPTR_T)
1497   IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
1498     SET(uintptr_t "uint64_t")
1499   ELSE()
1500     SET(uintptr_t "uint32_t")
1501   ENDIF()
1502 ENDIF(NOT HAVE_UINTPTR_T)
1503 #
1504 CHECK_TYPE_SIZE(wchar_t     SIZEOF_WCHAR_T)
1505 IF(HAVE_SIZEOF_WCHAR_T)
1506   SET(HAVE_WCHAR_T 1)
1507 ENDIF(HAVE_SIZEOF_WCHAR_T)
1508 #
1509 # Check if _FILE_OFFSET_BITS macro needed for large files
1510 #
1511 CHECK_FILE_OFFSET_BITS()
1512
1513 #
1514 # Check for Extended Attribute libraries, headers, and functions
1515 #
1516 IF(ENABLE_XATTR)
1517   LA_CHECK_INCLUDE_FILE(attr/xattr.h     HAVE_ATTR_XATTR_H)
1518   LA_CHECK_INCLUDE_FILE(sys/xattr.h      HAVE_SYS_XATTR_H)
1519   LA_CHECK_INCLUDE_FILE(sys/extattr.h      HAVE_SYS_EXTATTR_H)
1520   CHECK_LIBRARY_EXISTS(attr "setxattr" "" HAVE_LIBATTR)
1521   IF(HAVE_LIBATTR)
1522     SET(CMAKE_REQUIRED_LIBRARIES "attr")
1523   ENDIF(HAVE_LIBATTR)
1524   CHECK_SYMBOL_EXISTS(EXTATTR_NAMESPACE_USER "sys/types.h;sys/extattr.h" HAVE_DECL_EXTATTR_NAMESPACE_USER)
1525   CHECK_FUNCTION_EXISTS_GLIBC(extattr_get_file HAVE_EXTATTR_GET_FILE)
1526   CHECK_FUNCTION_EXISTS_GLIBC(extattr_list_file HAVE_EXTATTR_LIST_FILE)
1527   CHECK_FUNCTION_EXISTS_GLIBC(extattr_set_fd HAVE_EXTATTR_SET_FD)
1528   CHECK_FUNCTION_EXISTS_GLIBC(extattr_set_file HAVE_EXTATTR_SET_FILE)
1529   CHECK_FUNCTION_EXISTS_GLIBC(fgetxattr HAVE_FGETXATTR)
1530   CHECK_FUNCTION_EXISTS_GLIBC(flistxattr HAVE_FLISTXATTR)
1531   CHECK_FUNCTION_EXISTS_GLIBC(fsetxattr HAVE_FSETXATTR)
1532   CHECK_FUNCTION_EXISTS_GLIBC(getxattr HAVE_GETXATTR)
1533   CHECK_FUNCTION_EXISTS_GLIBC(lgetxattr HAVE_LGETXATTR)
1534   CHECK_FUNCTION_EXISTS_GLIBC(listxattr HAVE_LISTXATTR)
1535   CHECK_FUNCTION_EXISTS_GLIBC(llistxattr HAVE_LLISTXATTR)
1536   CHECK_FUNCTION_EXISTS_GLIBC(lsetxattr HAVE_LSETXATTR)
1537   CHECK_FUNCTION_EXISTS_GLIBC(fgetea HAVE_FGETEA)
1538   CHECK_FUNCTION_EXISTS_GLIBC(flistea HAVE_FLISTEA)
1539   CHECK_FUNCTION_EXISTS_GLIBC(fsetea HAVE_FSETEA)
1540   CHECK_FUNCTION_EXISTS_GLIBC(getea HAVE_GETEA)
1541   CHECK_FUNCTION_EXISTS_GLIBC(lgetea HAVE_LGETEA)
1542   CHECK_FUNCTION_EXISTS_GLIBC(listea HAVE_LISTEA)
1543   CHECK_FUNCTION_EXISTS_GLIBC(llistea HAVE_LLISTEA)
1544   CHECK_FUNCTION_EXISTS_GLIBC(lsetea HAVE_LSETEA)
1545 ELSE(ENABLE_XATTR)
1546   SET(HAVE_ATTR_LIB FALSE)
1547   SET(HAVE_ATTR_XATTR_H FALSE)
1548   SET(HAVE_DECL_EXTATTR_NAMESPACE_USER FALSE)
1549   SET(HAVE_EXTATTR_GET_FILE FALSE)
1550   SET(HAVE_EXTATTR_LIST_FILE FALSE)
1551   SET(HAVE_EXTATTR_SET_FD FALSE)
1552   SET(HAVE_EXTATTR_SET_FILE FALSE)
1553   SET(HAVE_FGETEA FALSE)
1554   SET(HAVE_FGETXATTR FALSE)
1555   SET(HAVE_FLISTEA FALSE)
1556   SET(HAVE_FLISTXATTR FALSE)
1557   SET(HAVE_FSETEA FALSE)
1558   SET(HAVE_FSETXATTR FALSE)
1559   SET(HAVE_GETEA FALSE)
1560   SET(HAVE_GETXATTR FALSE)
1561   SET(HAVE_LGETEA FALSE)
1562   SET(HAVE_LGETXATTR FALSE)
1563   SET(HAVE_LISTEA FALSE)
1564   SET(HAVE_LISTXATTR FALSE)
1565   SET(HAVE_LLISTEA FALSE)
1566   SET(HAVE_LLISTXATTR FALSE)
1567   SET(HAVE_LSETEA FALSE)
1568   SET(HAVE_LSETXATTR FALSE)
1569   SET(HAVE_SYS_EXTATTR_H FALSE)
1570   SET(HAVE_SYS_XATTR_H FALSE)
1571 ENDIF(ENABLE_XATTR)
1572
1573 #
1574 # Check for ACL libraries, headers, and functions
1575 #
1576 # The ACL support in libarchive is written against the POSIX1e draft,
1577 # which was never officially approved and varies quite a bit across
1578 # platforms.  Worse, some systems have completely non-POSIX acl functions,
1579 # which makes the following checks rather more complex than I would like.
1580 #
1581 IF(ENABLE_ACL)
1582   CHECK_LIBRARY_EXISTS(acl "acl_get_file" "" HAVE_LIBACL)
1583   IF(HAVE_LIBACL)
1584     SET(CMAKE_REQUIRED_LIBRARIES "acl")
1585     FIND_LIBRARY(ACL_LIBRARY NAMES acl)
1586     LIST(APPEND ADDITIONAL_LIBS ${ACL_LIBRARY})
1587   ENDIF(HAVE_LIBACL)
1588   #
1589   CHECK_FUNCTION_EXISTS_GLIBC(acl_create_entry HAVE_ACL_CREATE_ENTRY)
1590   CHECK_FUNCTION_EXISTS_GLIBC(acl_init HAVE_ACL_INIT)
1591   CHECK_FUNCTION_EXISTS_GLIBC(acl_set_fd HAVE_ACL_SET_FD)
1592   CHECK_FUNCTION_EXISTS_GLIBC(acl_set_fd_np HAVE_ACL_SET_FD_NP)
1593   CHECK_FUNCTION_EXISTS_GLIBC(acl_set_file HAVE_ACL_SET_FILE)
1594   CHECK_TYPE_EXISTS(acl_permset_t "${INCLUDES}"    HAVE_ACL_PERMSET_T)
1595
1596   # The "acl_get_perm()" function was omitted from the POSIX draft.
1597   # (It's a pretty obvious oversight; otherwise, there's no way to
1598   # test for specific permissions in a permset.)  Linux uses the obvious
1599   # name, FreeBSD adds _np to mark it as "non-Posix extension."
1600   # Test for both as a double-check that we really have POSIX-style ACL support.
1601   CHECK_FUNCTION_EXISTS(acl_get_fd_np HAVE_ACL_GET_FD_NP)
1602   CHECK_FUNCTION_EXISTS(acl_get_perm HAVE_ACL_GET_PERM)
1603   CHECK_FUNCTION_EXISTS(acl_get_perm_np HAVE_ACL_GET_PERM_NP)
1604   CHECK_FUNCTION_EXISTS(acl_get_link HAVE_ACL_GET_LINK)
1605   CHECK_FUNCTION_EXISTS(acl_get_link_np HAVE_ACL_GET_LINK_NP)
1606   CHECK_FUNCTION_EXISTS(acl_is_trivial_np HAVE_ACL_IS_TRIVIAL_NP)
1607   CHECK_FUNCTION_EXISTS(acl_set_link_np HAVE_ACL_SET_LINK_NP)
1608   CHECK_SYMBOL_EXISTS(ACL_TYPE_NFS4 "${INCLUDES}" HAVE_ACL_TYPE_NFS4)
1609
1610   # MacOS has an acl.h that isn't POSIX.  It can be detected by
1611   # checking for ACL_USER
1612   CHECK_SYMBOL_EXISTS(ACL_USER "${INCLUDES}" HAVE_ACL_USER)
1613
1614   # Solaris and derivates ACLs
1615   CHECK_LIBRARY_EXISTS(sec "acl_get" "" HAVE_LIBSEC)
1616   IF(HAVE_LIBSEC)
1617     SET(CMAKE_REQUIRED_LIBRARIES "sec")
1618     FIND_LIBRARY(SEC_LIBRARY NAMES sec)
1619     LIST(APPEND ADDITIONAL_LIBS ${SEC_LIBRARY})
1620   ENDIF(HAVE_LIBSEC)
1621   #
1622   CHECK_TYPE_EXISTS(aclent_t "${INCLUDES}" HAVE_ACLENT_T)
1623   CHECK_TYPE_EXISTS(ace_t "${INCLUDES}" HAVE_ACE_T)
1624   CHECK_FUNCTION_EXISTS(acl_get HAVE_FACL_GET)
1625   CHECK_FUNCTION_EXISTS(facl_get HAVE_FACL_GET)
1626   CHECK_FUNCTION_EXISTS(acl_set HAVE_FACL_SET)
1627   CHECK_FUNCTION_EXISTS(facl_set HAVE_FACL_SET)
1628 ELSE(ENABLE_ACL)
1629   # If someone runs cmake, then disables ACL support, we need
1630   # to forcibly override the cached values for these.
1631   SET(HAVE_ACL_CREATE_ENTRY FALSE)
1632   SET(HAVE_ACL_GET_LINK FALSE)
1633   SET(HAVE_ACL_GET_LINK_NP FALSE)
1634   SET(HAVE_ACL_GET_PERM FALSE)
1635   SET(HAVE_ACL_GET_PERM_NP FALSE)
1636   SET(HAVE_ACL_INIT FALSE)
1637   SET(HAVE_ACL_LIB FALSE)
1638   SET(HAVE_ACL_PERMSET_T FALSE)
1639   SET(HAVE_ACL_SET_FD FALSE)
1640   SET(HAVE_ACL_SET_FD_NP FALSE)
1641   SET(HAVE_ACL_SET_FILE FALSE)
1642   SET(HAVE_ACL_TYPE_NFS4 FALSE)
1643   SET(HAVE_ACL_USER FALSE)
1644   SET(HAVE_ACL_GET FALSE)
1645   SET(HAVE_ACLENT_T FALSE)
1646   SET(HAVE_ACE_T FALSE)
1647   SET(HAVE_FACL_GET FALSE)
1648   SET(HAVE_ACL_SET FALSE)
1649   SET(HAVE_FACL_SET FALSE)
1650 ENDIF(ENABLE_ACL)
1651
1652 #
1653 # Check MD5/RMD160/SHA support
1654 # NOTE: Crypto checks must be run last before generating config.h
1655 #
1656 CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" LIBC)
1657 CHECK_CRYPTO("SHA256;SHA384;SHA512" LIBC2)
1658 CHECK_CRYPTO("SHA256;SHA384;SHA512" LIBC3)
1659 CHECK_CRYPTO("MD5;SHA1;SHA256;SHA384;SHA512" LIBSYSTEM)
1660 CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" NETTLE)
1661 CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA384;SHA512" OPENSSL)
1662
1663 # Libmd has to be probed after OpenSSL.
1664 CHECK_CRYPTO("MD5;RMD160;SHA1;SHA256;SHA512" LIBMD)
1665
1666 CHECK_CRYPTO_WIN("MD5;SHA1;SHA256;SHA384;SHA512")
1667
1668 # Generate "config.h" from "build/cmake/config.h.in"
1669 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in
1670         ${CMAKE_CURRENT_BINARY_DIR}/config.h)
1671 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_BINARY_DIR})
1672 ADD_DEFINITIONS(-DHAVE_CONFIG_H)
1673
1674 # Handle generation of the libarchive.pc file for pkg-config
1675 INCLUDE(CreatePkgConfigFile)
1676
1677 #
1678 # Register installation of PDF documents.
1679 #
1680 IF(WIN32 AND NOT CYGWIN)
1681   #
1682   # On Windows platform, It's better that we install PDF documents
1683   # on one's computer.
1684   # These PDF documents are available in the release package.
1685   #
1686   IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf)
1687     INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf
1688             DESTINATION share/man
1689             FILES_MATCHING PATTERN "*.pdf"
1690     )
1691   ENDIF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf)
1692 ENDIF(WIN32 AND NOT CYGWIN)
1693 #
1694 #
1695 #
1696 INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/libarchive)
1697 #
1698 IF(MSVC)
1699   ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
1700 ENDIF(MSVC)
1701
1702 IF(ENABLE_TEST)
1703   ADD_CUSTOM_TARGET(run_all_tests)
1704 ENDIF(ENABLE_TEST)
1705
1706 add_subdirectory(libarchive)
1707 add_subdirectory(cat)
1708 add_subdirectory(tar)
1709 add_subdirectory(cpio)