projects / thirdparty / libarchive.git / blame
| Commit | Line | Data |
|---|---|---|
| 8b7ba998 TK |
1 | # |
| 2 | # | |
| fccf5c27 | 3 | PROJECT(libarchive C) |
| 8b7ba998 | 4 | # |
| d8dabfb7 | 5 | CMAKE_MINIMUM_REQUIRED(VERSION 2.6.3 FATAL_ERROR) |
| dd63f1c5 | 6 | SET(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/build/cmake") |
| 5cd96832 TK |
7 | if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY) |
| 8 | set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${libarchive_BINARY_DIR}/bin) | |
| 9 | endif() | |
| d935c741 | 10 | SET(CMAKE_BUILD_TYPE "Debug") |
| 5cd96832 | 11 | |
| 8b7ba998 TK |
12 | # |
| 13 | # Version - read from 'version' file. | |
| 14 | # | |
| dd63f1c5 | 15 | FILE(STRINGS ${CMAKE_CURRENT_SOURCE_DIR}/build/version _version) |
| 8b7ba998 | 16 | STRING(REGEX REPLACE |
| 97b032b7 | 17 | "^([0-9])[0-9][0-9][0-9][0-9][0-9][0-9][a-z]?$" "\\1" _major ${_version}) |
| 8b7ba998 | 18 | STRING(REGEX REPLACE |
| 97b032b7 | 19 | "^[0-9]([0-9][0-9][0-9])[0-9][0-9][0-9][a-z]?$" "\\1" _minor ${_version}) |
| 8b7ba998 | 20 | STRING(REGEX REPLACE |
| 97b032b7 | 21 | "^[0-9][0-9][0-9][0-9]([0-9][0-9][0-9])[a-z]?$" "\\1" _revision ${_version}) |
| 8b7ba998 | 22 | STRING(REGEX REPLACE |
| 97b032b7 | 23 | "^[0-9][0-9][0-9][0-9][0-9][0-9][0-9]([a-z]?)$" "\\1" _quality ${_version}) |
| 8b7ba998 | 24 | SET(_version_number ${_major}${_minor}${_revision}) |
| d00ef4e5 TK |
25 | STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_minor ${_minor}) |
| 26 | STRING(REGEX REPLACE "[0]*([^0]*[0-9])$" "\\1" _trimmed_revision ${_revision}) | |
| 8b7ba998 | 27 | # |
| d00ef4e5 | 28 | SET(VERSION "${_major}.${_trimmed_minor}.${_trimmed_revision}${_quality}") |
| 806025f2 | 29 | SET(BSDCPIO_VERSION_STRING "${VERSION}") |
| 8b7ba998 TK |
30 | SET(BSDTAR_VERSION_STRING "${VERSION}") |
| 31 | SET(LIBARCHIVE_VERSION_NUMBER "${_version_number}") | |
| 32 | SET(LIBARCHIVE_VERSION_STRING "${VERSION}") | |
| d6cd0cbd MN |
33 | # Shared library number |
| 34 | SET(SOVERSION 8) | |
| 806025f2 | 35 | |
| 50fd7f6c TK |
36 | # Especially for early development, we want to be a little |
| 37 | # aggressive about diagnosing build problems; this can get | |
| 38 | # relaxed somewhat in final shipping versions. | |
| 39 | IF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$") | |
| 40 | ADD_DEFINITIONS(-Wall -Werror) | |
| 41 | SET(CMAKE_REQUIRED_FLAGS "-Wall -Werror") | |
| 42 | ENDIF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$") | |
| 43 | ||
| 787a5ff7 TK |
44 | # Enable CTest/CDash support |
| 45 | include(CTest) | |
| 46 | ||
| 09a663f1 BK |
47 | # Provide ADD_TEST_28 macro to approximate CMake 2.8 ADD_TEST(NAME). |
| 48 | # TODO: Require CMake 2.8 and drop this workaround (perhaps late 2010). | |
| 49 | INCLUDE(AddTest28) | |
| 50 | ||
| 5aafacca MN |
51 | # Set default value for option. |
| 52 | # Do not use SET() to option variables. it doest not correctly work on GUI. | |
| 53 | IF(WIN32 AND NOT CYGWIN) | |
| 54 | # Currently, dynamic build only. | |
| 55 | SET(TAR_DEFAULT OFF) | |
| 56 | SET(TAR_SHARED_DEFAULT ON) | |
| 57 | SET(CPIO_DEFAULT OFF) | |
| 58 | SET(CPIO_SHARED_DEFAULT ON) | |
| 59 | # Not tested. | |
| 60 | SET(ICONV_DEFAULT OFF) | |
| 61 | ELSE(WIN32 AND NOT CYGWIN) | |
| 62 | SET(TAR_DEFAULT ON) | |
| 63 | SET(TAR_SHARED_DEFAULT FALSE) | |
| 64 | SET(CPIO_DEFAULT ON) | |
| 65 | SET(CPIO_SHARED_DEFAULT FALSE) | |
| 66 | SET(ICONV_DEFAULT ON) | |
| 67 | ENDIF(WIN32 AND NOT CYGWIN) | |
| 68 | ||
| fc239d4a | 69 | OPTION(ENABLE_OPENSSL "Enable use of OpenSSL" ON) |
| 5aafacca MN |
70 | OPTION(ENABLE_TAR "Enable tar building" ${TAR_DEFAULT}) |
| 71 | OPTION(ENABLE_TAR_SHARED "Enable dynamic build of tar" ${TAR_SHARED_DEFAULT}) | |
| 72 | OPTION(ENABLE_CPIO "Enable cpio building" ${CPIO_DEFAULT}) | |
| 73 | OPTION(ENABLE_CPIO_SHARED "Enable dynamic build of cpio" ${CPIO_SHARED_DEFAULT}) | |
| 806025f2 TK |
74 | OPTION(ENABLE_XATTR "Enable extended attribute support" ON) |
| 75 | OPTION(ENABLE_ACL "Enable ACL support" ON) | |
| 5aafacca | 76 | OPTION(ENABLE_ICONV "Enable iconv support" ${ICONV_DEFAULT}) |
| 806025f2 TK |
77 | OPTION(ENABLE_TEST "Enable unit and regression tests" ON) |
| 78 | ||
| 79 | IF(ENABLE_TEST) | |
| 80 | ENABLE_TESTING() | |
| 81 | ENDIF(ENABLE_TEST) | |
| 82 | ||
| 197cc2d1 CW |
83 | IF(WIN32) |
| 84 | SET(_WIN32_WINNT 0x0500 CACHE INTERNAL "Setting _WIN32_WINNT to 0x0500 for Windows 2000 APIs") | |
| 85 | SET(WINVER 0x0500 CACHE INTERNAL "Setting WINVER to 0x0500 for Windows 2000 APIs") | |
| 86 | ENDIF(WIN32) | |
| 87 | ||
| 8b7ba998 | 88 | # |
| ca58a31d | 89 | INCLUDE(CheckCSourceCompiles) |
| 794a00f4 | 90 | INCLUDE(CheckCSourceRuns) |
| 968a8126 | 91 | INCLUDE(CheckFileOffsetBits) |
| 8b7ba998 | 92 | INCLUDE(CheckFuncs) |
| 8b7ba998 | 93 | INCLUDE(CheckHeaderDirent) |
| 8b7ba998 | 94 | INCLUDE(CheckIncludeFile) |
| 72f559e7 | 95 | INCLUDE(CheckIncludeFiles) |
| 968a8126 | 96 | INCLUDE(CheckLibraryExists) |
| 8b7ba998 TK |
97 | INCLUDE(CheckStructMember) |
| 98 | INCLUDE(CheckSymbolExists) | |
| 99 | INCLUDE(CheckTypeExists) | |
| 100 | INCLUDE(CheckTypeSize) | |
| 87b05751 | 101 | |
| 8b7ba998 TK |
102 | # |
| 103 | # Generate list.h | |
| 104 | # | |
| 13cc0fb9 MN |
105 | MACRO (GENERATE_LIST_H _listfile _cmlist __list_sources) |
| 106 | SET(_argv ${ARGV}) | |
| 107 | # Remove _listfile and _cmlist from _argv | |
| 108 | LIST(REMOVE_AT _argv 0 1) | |
| 8b7ba998 | 109 | IF (NOT EXISTS "${_listfile}" OR |
| 13cc0fb9 | 110 | ${_cmlist} IS_NEWER_THAN "${_listfile}") |
| 8b7ba998 TK |
111 | |
| 112 | MESSAGE(STATUS "Generating ${_listfile}") | |
| 113 | FILE(WRITE ${_listfile} "") | |
| 13cc0fb9 | 114 | FOREACH (testfile ${_argv}) |
| 968a8126 | 115 | IF (testfile MATCHES "^test_[^/]+[.]c$") |
| 8b7ba998 TK |
116 | FILE(STRINGS ${testfile} testvar REGEX "^DEFINE_TEST") |
| 117 | FOREACH (deftest ${testvar}) | |
| 118 | FILE(APPEND ${_listfile} "${deftest}\n") | |
| 119 | ENDFOREACH (deftest) | |
| 968a8126 | 120 | ENDIF (testfile MATCHES "^test_[^/]+[.]c$") |
| 8b7ba998 TK |
121 | ENDFOREACH (testfile) |
| 122 | ||
| 123 | ENDIF (NOT EXISTS "${_listfile}" OR | |
| 13cc0fb9 | 124 | ${_cmlist} IS_NEWER_THAN "${_listfile}") |
| 8b7ba998 | 125 | ENDMACRO (GENERATE_LIST_H) |
| 1c2e5b54 MN |
126 | # |
| 127 | # Generate installation rules for man pages. | |
| 128 | # | |
| 129 | MACRO (INSTALL_MAN __mans) | |
| 130 | FOREACH (_man ${ARGV}) | |
| 131 | STRING(REGEX REPLACE "^.+[.]([1-9])" "\\1" _mansect ${_man}) | |
| 132 | INSTALL(FILES ${_man} DESTINATION "share/man/man${_mansect}") | |
| 133 | ENDFOREACH (_man) | |
| 134 | ENDMACRO (INSTALL_MAN __mans) | |
| 8b7ba998 TK |
135 | |
| 136 | # | |
| 137 | # Check compress/decompress libraries | |
| 138 | # | |
| 72881599 MN |
139 | IF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN) |
| 140 | # GnuWin32 is only for Win32, not Win64. | |
| 141 | SET(__GNUWIN32PATH "C:/Program Files/GnuWin32") | |
| 142 | ENDIF(WIN32 AND NOT CMAKE_CL_64 AND NOT CYGWIN) | |
| 143 | IF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}") | |
| 0c4a6ac2 | 144 | # You have to add a path availabel DLL file into PATH environment variable. |
| be4c3c3c | 145 | # Maybe DLL path is "C:/Program Files/GnuWin32/bin". |
| 0c4a6ac2 MN |
146 | # The zlib and the bzip2 Setup program have installed programs and DLLs into |
| 147 | # "C:/Program Files/GnuWin32" by default. | |
| 148 | # This is convenience setting for Windows. | |
| 149 | SET(CMAKE_PREFIX_PATH ${__GNUWIN32PATH} $(CMAKE_PREFIX_PATH)) | |
| 150 | # | |
| 151 | # If you didn't use Setup program or installed into nonstandard path, | |
| 152 | # cmake cannot find out your zlib or bzip2 libraries and include files, | |
| 153 | # you should execute cmake with -DCMAKE_PREFIX_PATH option. | |
| 154 | # e.g. | |
| 76241b4c | 155 | # cmake -DCMAKE_PREFIX_PATH=<your-GnuWin32-path> <path-to-source> |
| 0c4a6ac2 MN |
156 | # |
| 157 | # If compiling error occured in zconf.h, You may need patch to zconf.h. | |
| 158 | #--- zconf.h.orig 2005-07-21 00:40:26.000000000 | |
| 159 | #+++ zconf.h 2009-01-19 11:39:10.093750000 | |
| be4c3c3c MN |
160 | #@@ -286,7 +286,7 @@ |
| 161 | # | |
| 162 | # #if 1 /* HAVE_UNISTD_H -- this line is updated by ./configure */ | |
| 163 | # # include <sys/types.h> /* for off_t */ | |
| 164 | #-# include <unistd.h> /* for SEEK_* and off_t */ | |
| 165 | #+# include <stdio.h> /* for SEEK_* and off_t */ | |
| 166 | # # ifdef VMS | |
| 167 | # # include <unixio.h> /* for off_t */ | |
| 168 | # # endif | |
| 72881599 | 169 | ENDIF(DEFINED __GNUWIN32PATH AND EXISTS "${__GNUWIN32PATH}") |
| 8b7ba998 TK |
170 | |
| 171 | SET(ADDITIONAL_LIBS "") | |
| 172 | # | |
| 173 | # Find ZLIB | |
| 174 | # | |
| 175 | FIND_PACKAGE(ZLIB) | |
| 176 | IF(ZLIB_FOUND) | |
| 177 | SET(HAVE_LIBZ 1) | |
| 178 | SET(HAVE_ZLIB_H 1) | |
| 179 | INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR}) | |
| 180 | LIST(APPEND ADDITIONAL_LIBS ${ZLIB_LIBRARIES}) | |
| 181 | ENDIF(ZLIB_FOUND) | |
| 38d31061 TK |
182 | MARK_AS_ADVANCED(CLEAR ZLIB_INCLUDE_DIR) |
| 183 | MARK_AS_ADVANCED(CLEAR ZLIB_LIBRARY) | |
| 8b7ba998 TK |
184 | # |
| 185 | # Find BZip2 | |
| 186 | # | |
| 187 | FIND_PACKAGE(BZip2) | |
| 188 | IF(BZIP2_FOUND) | |
| 189 | SET(HAVE_LIBBZ2 1) | |
| 190 | SET(HAVE_BZLIB_H 1) | |
| 191 | INCLUDE_DIRECTORIES(${BZIP2_INCLUDE_DIR}) | |
| 192 | LIST(APPEND ADDITIONAL_LIBS ${BZIP2_LIBRARIES}) | |
| 193 | ENDIF(BZIP2_FOUND) | |
| 38d31061 TK |
194 | MARK_AS_ADVANCED(CLEAR BZIP2_INCLUDE_DIR) |
| 195 | MARK_AS_ADVANCED(CLEAR BZIP2_LIBRARY) | |
| 8b7ba998 TK |
196 | # |
| 197 | # Find LZMA | |
| 198 | # | |
| 199 | FIND_PACKAGE(LZMA) | |
| 200 | IF(LZMA_FOUND) | |
| c25e0da2 MN |
201 | SET(HAVE_LIBLZMA 1) |
| 202 | SET(HAVE_LZMA_H 1) | |
| 8b7ba998 TK |
203 | INCLUDE_DIRECTORIES(${LZMA_INCLUDE_DIR}) |
| 204 | LIST(APPEND ADDITIONAL_LIBS ${LZMA_LIBRARIES}) | |
| 38d31061 TK |
205 | MARK_AS_ADVANCED(CLEAR LZMA_INCLUDE_DIR) |
| 206 | MARK_AS_ADVANCED(CLEAR LZMA_LIBRARY) | |
| c25e0da2 MN |
207 | ELSEIF(LZMADEC_FOUND) |
| 208 | SET(HAVE_LIBLZMADEC 1) | |
| 209 | SET(HAVE_LZMADEC_H 1) | |
| 210 | INCLUDE_DIRECTORIES(${LZMADEC_INCLUDE_DIR}) | |
| 211 | LIST(APPEND ADDITIONAL_LIBS ${LZMADEC_LIBRARIES}) | |
| 38d31061 TK |
212 | MARK_AS_ADVANCED(CLEAR LZMADEC_INCLUDE_DIR) |
| 213 | MARK_AS_ADVANCED(CLEAR LZMADEC_LIBRARY) | |
| 214 | ELSE(LZMA_FOUND) | |
| 215 | MARK_AS_ADVANCED(CLEAR LZMA_INCLUDE_DIR) | |
| 216 | MARK_AS_ADVANCED(CLEAR LZMA_LIBRARY) | |
| 8b7ba998 TK |
217 | ENDIF(LZMA_FOUND) |
| 218 | ||
| 219 | # | |
| 220 | # Check headers | |
| 221 | # | |
| 8b7ba998 | 222 | CHECK_HEADER_DIRENT() |
| 8b7ba998 | 223 | |
| 79150845 TK |
224 | SET(INCLUDES "") |
| 225 | MACRO (LA_CHECK_INCLUDE_FILE header var) | |
| 226 | CHECK_INCLUDE_FILES("${INCLUDES};${header}" ${var}) | |
| 227 | IF (${var}) | |
| 228 | SET(INCLUDES ${INCLUDES} ${header}) | |
| 229 | ENDIF (${var}) | |
| 230 | ENDMACRO (LA_CHECK_INCLUDE_FILE) | |
| 231 | ||
| d935c741 | 232 | # Some FreeBSD headers assume sys/types.h was already included. |
| 79150845 TK |
233 | LA_CHECK_INCLUDE_FILE("sys/types.h" HAVE_SYS_TYPES_H) |
| 234 | ||
| 235 | # Alphabetize the rest unless there's a compelling reason | |
| 236 | LA_CHECK_INCLUDE_FILE("acl/libacl.h" HAVE_ACL_LIBACL_H) | |
| 79150845 | 237 | LA_CHECK_INCLUDE_FILE("ctype.h" HAVE_CTYPE_H) |
| dc3047d5 | 238 | LA_CHECK_INCLUDE_FILE("copyfile.h" HAVE_COPYFILE_H) |
| 79150845 TK |
239 | LA_CHECK_INCLUDE_FILE("direct.h" HAVE_DIRECT_H) |
| 240 | LA_CHECK_INCLUDE_FILE("dlfcn.h" HAVE_DLFCN_H) | |
| 241 | LA_CHECK_INCLUDE_FILE("errno.h" HAVE_ERRNO_H) | |
| 242 | LA_CHECK_INCLUDE_FILE("ext2fs/ext2_fs.h" HAVE_EXT2FS_EXT2_FS_H) | |
| 243 | LA_CHECK_INCLUDE_FILE("fcntl.h" HAVE_FCNTL_H) | |
| 244 | LA_CHECK_INCLUDE_FILE("grp.h" HAVE_GRP_H) | |
| 245 | LA_CHECK_INCLUDE_FILE("inttypes.h" HAVE_INTTYPES_H) | |
| 246 | LA_CHECK_INCLUDE_FILE("io.h" HAVE_IO_H) | |
| 247 | LA_CHECK_INCLUDE_FILE("langinfo.h" HAVE_LANGINFO_H) | |
| 248 | LA_CHECK_INCLUDE_FILE("limits.h" HAVE_LIMITS_H) | |
| d216d028 | 249 | LA_CHECK_INCLUDE_FILE("linux/fiemap.h" HAVE_LINUX_FIEMAP_H) |
| 79150845 | 250 | LA_CHECK_INCLUDE_FILE("linux/fs.h" HAVE_LINUX_FS_H) |
| 996334f3 | 251 | LA_CHECK_INCLUDE_FILE("linux/magic.h" HAVE_LINUX_MAGIC_H) |
| 79150845 TK |
252 | LA_CHECK_INCLUDE_FILE("locale.h" HAVE_LOCALE_H) |
| 253 | LA_CHECK_INCLUDE_FILE("memory.h" HAVE_MEMORY_H) | |
| 254 | LA_CHECK_INCLUDE_FILE("paths.h" HAVE_PATHS_H) | |
| 255 | LA_CHECK_INCLUDE_FILE("poll.h" HAVE_POLL_H) | |
| 256 | LA_CHECK_INCLUDE_FILE("process.h" HAVE_PROCESS_H) | |
| 257 | LA_CHECK_INCLUDE_FILE("pwd.h" HAVE_PWD_H) | |
| 258 | LA_CHECK_INCLUDE_FILE("regex.h" HAVE_REGEX_H) | |
| 259 | LA_CHECK_INCLUDE_FILE("signal.h" HAVE_SIGNAL_H) | |
| 260 | LA_CHECK_INCLUDE_FILE("stdarg.h" HAVE_STDARG_H) | |
| 261 | LA_CHECK_INCLUDE_FILE("stdint.h" HAVE_STDINT_H) | |
| 262 | LA_CHECK_INCLUDE_FILE("stdlib.h" HAVE_STDLIB_H) | |
| 263 | LA_CHECK_INCLUDE_FILE("string.h" HAVE_STRING_H) | |
| 264 | LA_CHECK_INCLUDE_FILE("strings.h" HAVE_STRINGS_H) | |
| 265 | LA_CHECK_INCLUDE_FILE("sys/acl.h" HAVE_SYS_ACL_H) | |
| 5eec93b7 | 266 | LA_CHECK_INCLUDE_FILE("sys/cdefs.h" HAVE_SYS_CDEFS_H) |
| 79150845 TK |
267 | LA_CHECK_INCLUDE_FILE("sys/ioctl.h" HAVE_SYS_IOCTL_H) |
| 268 | LA_CHECK_INCLUDE_FILE("sys/mkdev.h" HAVE_SYS_MKDEV_H) | |
| e3d450a7 | 269 | LA_CHECK_INCLUDE_FILE("sys/mount.h" HAVE_SYS_MOUNT_H) |
| 79150845 TK |
270 | LA_CHECK_INCLUDE_FILE("sys/param.h" HAVE_SYS_PARAM_H) |
| 271 | LA_CHECK_INCLUDE_FILE("sys/poll.h" HAVE_SYS_POLL_H) | |
| 272 | LA_CHECK_INCLUDE_FILE("sys/select.h" HAVE_SYS_SELECT_H) | |
| 273 | LA_CHECK_INCLUDE_FILE("sys/stat.h" HAVE_SYS_STAT_H) | |
| 0cb2837d | 274 | LA_CHECK_INCLUDE_FILE("sys/statfs.h" HAVE_SYS_STATFS_H) |
| 8161d987 | 275 | LA_CHECK_INCLUDE_FILE("sys/statvfs.h" HAVE_SYS_STATVFS_H) |
| 79150845 TK |
276 | LA_CHECK_INCLUDE_FILE("sys/time.h" HAVE_SYS_TIME_H) |
| 277 | LA_CHECK_INCLUDE_FILE("sys/utime.h" HAVE_SYS_UTIME_H) | |
| d216d028 | 278 | LA_CHECK_INCLUDE_FILE("sys/utsname.h" HAVE_SYS_UTSNAME_H) |
| 996334f3 | 279 | LA_CHECK_INCLUDE_FILE("sys/vfs.h" HAVE_SYS_VFS_H) |
| 79150845 TK |
280 | LA_CHECK_INCLUDE_FILE("sys/wait.h" HAVE_SYS_WAIT_H) |
| 281 | LA_CHECK_INCLUDE_FILE("time.h" HAVE_TIME_H) | |
| 282 | LA_CHECK_INCLUDE_FILE("unistd.h" HAVE_UNISTD_H) | |
| 283 | LA_CHECK_INCLUDE_FILE("utime.h" HAVE_UTIME_H) | |
| 284 | LA_CHECK_INCLUDE_FILE("wchar.h" HAVE_WCHAR_H) | |
| 285 | LA_CHECK_INCLUDE_FILE("wctype.h" HAVE_WCTYPE_H) | |
| 286 | LA_CHECK_INCLUDE_FILE("windows.h" HAVE_WINDOWS_H) | |
| d216d028 | 287 | LA_CHECK_INCLUDE_FILE("winioctl.h" HAVE_WINIOCTL_H) |
| 72f559e7 | 288 | |
| a0f5fe6e MN |
289 | # |
| 290 | # Check whether use of __EXTENSIONS__ is safe. | |
| 291 | # We need some macro such as _GNU_SOURCE to use extension functions. | |
| 292 | # | |
| 293 | SET(_INCLUDE_FILES) | |
| 294 | FOREACH (it ${_HEADER}) | |
| 295 | SET(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n") | |
| 296 | ENDFOREACH (it) | |
| 297 | ||
| 298 | CHECK_C_SOURCE_COMPILES( | |
| 299 | "#define __EXTENSIONS__ 1 | |
| 300 | ${_INCLUDE_FILES} | |
| 301 | int main() { return 0;}" | |
| 302 | SAFE_TO_DEFINE_EXTENSIONS) | |
| 9cc27fc3 | 303 | |
| 10e5183c MN |
304 | # |
| 305 | # Find OpenSSL | |
| 306 | # | |
| fc239d4a BK |
307 | IF(ENABLE_OPENSSL) |
| 308 | FIND_PACKAGE(OpenSSL) | |
| f6464b03 TK |
309 | ELSE() |
| 310 | SET(OPENSSL_FOUND FALSE) # Override cached value | |
| fc239d4a | 311 | ENDIF() |
| 2ce66f4b | 312 | |
| a8c22d8a MN |
313 | # |
| 314 | # How to prove that HASH functions, which have several names on various | |
| 315 | # platforms, can be mapped to archive_{hash name}_init, | |
| 316 | # archive_{hash name}_update and archive_{hash name}_final through | |
| 317 | # archive_hash.h | |
| 318 | # | |
| 2ce66f4b | 319 | MACRO(CHECK_MD HASH IMPLEMENTATIONS) |
| f7420cf3 MN |
320 | IF(HAVE_SYS_TYPES_H) |
| 321 | SET(HASH_HEADER_CONFIG "#define HAVE_SYS_TYPES_H 1\n") | |
| 322 | ELSE(HAVE_SYS_TYPES_H) | |
| 323 | SET(HASH_HEADER_CONFIG "") | |
| 324 | ENDIF(HAVE_SYS_TYPES_H) | |
| 4d49cfcf TK |
325 | STRING(TOLOWER "${HASH}" lower_hash) |
| 326 | STRING(TOUPPER "${HASH}" hash) | |
| f7420cf3 | 327 | |
| 2ce66f4b | 328 | FOREACH(IMPLEMENTATION ${IMPLEMENTATIONS}) |
| f6464b03 TK |
329 | IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND) |
| 330 | SET(ARCHIVE_HASH_${HASH}_${IMPLEMENTATION} FALSE) | |
| 331 | ENDIF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND NOT OPENSSL_FOUND) | |
| 2066ed56 | 332 | IF(NOT DEFINED ARCHIVE_HASH_${HASH}_${IMPLEMENTATION}) |
| 4d49cfcf TK |
333 | # Probe the local implementation for whether this |
| 334 | # hash implementation is available on this platform. | |
| fcc0dfeb MN |
335 | SET(TRY_HASH_REQUIRED_INCLUDES |
| 336 | "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_CURRENT_SOURCE_DIR}/libarchive") | |
| fcc0dfeb | 337 | SET(TRY_HASH_REQUIRED_LIBS) |
| 2ce66f4b | 338 | IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND) |
| fcc0dfeb MN |
339 | SET(TRY_HASH_REQUIRED_INCLUDES |
| 340 | "${TRY_HASH_REQUIRED_INCLUDES};${OPENSSL_INCLUDE_DIR}") | |
| fcc0dfeb MN |
341 | SET(TRY_HASH_REQUIRED_LIBS |
| 342 | "-DLINK_LIBRARIES:STRING=${OPENSSL_LIBRARIES}") | |
| 2ce66f4b JS |
343 | ENDIF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND) |
| 344 | ||
| 345 | SET(SOURCE "#define ${hash}_COMPILE_TEST | |
| 346 | #define ARCHIVE_HASH_${hash}_${IMPLEMENTATION} | |
| 347 | #define __LIBARCHIVE_BUILD | |
| f7420cf3 | 348 | ${HASH_HEADER_CONFIG} |
| 2ce66f4b JS |
349 | #include \"archive_hash.h\" |
| 350 | ||
| 351 | int | |
| 352 | main(int argc, char **argv) | |
| 353 | { | |
| 354 | archive_${lower_hash}_ctx ctx; | |
| 355 | ||
| 356 | archive_${lower_hash}_init(&ctx); | |
| 357 | archive_${lower_hash}_update(&ctx, *argv, argc); | |
| 358 | archive_${lower_hash}_final(&ctx, *argv); | |
| 359 | return 0; | |
| 360 | } | |
| 361 | ") | |
| 362 | ||
| a8c22d8a | 363 | FILE(WRITE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_hash_md.c" "${SOURCE}") |
| 2ce66f4b JS |
364 | MESSAGE(STATUS "Checking support for ARCHIVE_HASH_${HASH}_${IMPLEMENTATION}") |
| 365 | ||
| 51c3d02d | 366 | TRY_COMPILE(ARCHIVE_HASH_${HASH}_${IMPLEMENTATION} |
| 2ce66f4b | 367 | ${CMAKE_BINARY_DIR} |
| a8c22d8a | 368 | ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_hash_md.c |
| fcc0dfeb MN |
369 | CMAKE_FLAGS |
| 370 | "${TRY_HASH_REQUIRED_LIBS}" | |
| 371 | "${TRY_HASH_REQUIRED_INCLUDES}" | |
| 2ce66f4b JS |
372 | OUTPUT_VARIABLE OUTPUT) |
| 373 | ||
| 4d49cfcf TK |
374 | # Inform user whether or not we found it; if not, log why we didn't. |
| 375 | IF (ARCHIVE_HASH_${HASH}_${IMPLEMENTATION}) | |
| 376 | MESSAGE(STATUS "Checking support for ARCHIVE_HASH_${HASH}_${IMPLEMENTATION} -- found") | |
| 377 | ELSE (ARCHIVE_HASH_${HASH}_${IMPLEMENTATION}) | |
| 378 | MESSAGE(STATUS "Checking support for ARCHIVE_HASH_${HASH}_${IMPLEMENTATION} -- not found") | |
| 379 | FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log | |
| 2ce66f4b JS |
380 | "Checking support for ARCHIVE_HASH_${HASH}_${IMPLEMENTATION} failed with the following output:\n" |
| 381 | "${OUTPUT}\n" | |
| 382 | "Source file was:\n${SOURCE}\n") | |
| 4d49cfcf | 383 | ENDIF (ARCHIVE_HASH_${HASH}_${IMPLEMENTATION}) |
| 2066ed56 | 384 | ENDIF(NOT DEFINED ARCHIVE_HASH_${HASH}_${IMPLEMENTATION}) |
| 4d49cfcf TK |
385 | |
| 386 | # Add appropriate libs/includes depending on whether the implementation | |
| 387 | # was found on this platform. | |
| 388 | IF (ARCHIVE_HASH_${HASH}_${IMPLEMENTATION}) | |
| 389 | IF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND) | |
| 390 | INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR}) | |
| 391 | LIST(APPEND ADDITIONAL_LIBS ${OPENSSL_LIBRARIES}) | |
| 392 | LIST(REMOVE_DUPLICATES ADDITIONAL_LIBS) | |
| 393 | ENDIF ("${IMPLEMENTATION}" MATCHES "^OPENSSL$" AND OPENSSL_FOUND) | |
| 394 | ENDIF (ARCHIVE_HASH_${HASH}_${IMPLEMENTATION}) | |
| 2ce66f4b JS |
395 | ENDFOREACH(IMPLEMENTATION) |
| 396 | ENDMACRO(CHECK_MD HASH IMPLEMENTATIONS) | |
| 79150845 | 397 | |
| a8c22d8a MN |
398 | # |
| 399 | # HASH functions on Windows is defined at archive_windows.c, thus we do not | |
| 400 | # need the test what the functions can be mapped to archive_{hash name}_init, | |
| 401 | # archive_{hash name}_update and archive_{hash name}_final. | |
| 402 | # The functions on Windows use CALG_{hash name} macro to create a crypt object | |
| 403 | # and then we need to know what CALG_{hash name} macros is available to show | |
| 404 | # ARCHIVE_HASH_{hash name}_WIN macros because Windows 2000 and earlier version | |
| 405 | # of Windows XP do not support SHA256, SHA384 and SHA512. | |
| 406 | # | |
| 407 | MACRO(CHECK_HASH_WIN HASH_LIST) | |
| 408 | IF(WIN32 AND NOT CYGWIN) | |
| 409 | FOREACH(HASH ${HASH_LIST}) | |
| 410 | IF(NOT DEFINED ARCHIVE_HASH_${HASH}_WIN) | |
| 411 | STRING(TOUPPER "${HASH}" hash) | |
| 412 | SET(ALGID "") | |
| 413 | IF ("${HASH}" MATCHES "^MD5$") | |
| 414 | SET(ALGID "CALG_MD5") | |
| 415 | ENDIF ("${HASH}" MATCHES "^MD5$") | |
| 416 | IF ("${HASH}" MATCHES "^SHA1$") | |
| 417 | SET(ALGID "CALG_SHA1") | |
| 418 | ENDIF ("${HASH}" MATCHES "^SHA1$") | |
| 419 | IF ("${HASH}" MATCHES "^SHA256$") | |
| 420 | SET(ALGID "CALG_SHA_256") | |
| 421 | ENDIF ("${HASH}" MATCHES "^SHA256$") | |
| 422 | IF ("${HASH}" MATCHES "^SHA384$") | |
| 423 | SET(ALGID "CALG_SHA_384") | |
| 424 | ENDIF ("${HASH}" MATCHES "^SHA384$") | |
| 425 | IF ("${HASH}" MATCHES "^SHA512$") | |
| 426 | SET(ALGID "CALG_SHA_512") | |
| 427 | ENDIF ("${HASH}" MATCHES "^SHA512$") | |
| 428 | ||
| 429 | SET(SOURCE "#define ${hash}_COMPILE_TEST | |
| 430 | #define _WIN32_WINNT ${_WIN32_WINNT} | |
| 431 | #define WINVER ${WINVER} | |
| 432 | #include <windows.h> | |
| 765a5d3f | 433 | #include <wincrypt.h> |
| a8c22d8a MN |
434 | |
| 435 | int | |
| 436 | main(int argc, char **argv) | |
| 437 | { | |
| 438 | return ${ALGID}; | |
| 439 | } | |
| 440 | ") | |
| 441 | SET(SOURCE_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/check_hash_win.c") | |
| 442 | ||
| 443 | FILE(WRITE "${SOURCE_FILE}" "${SOURCE}") | |
| 444 | MESSAGE(STATUS "Checking support for ARCHIVE_HASH_${HASH}_WIN") | |
| 445 | ||
| 446 | TRY_COMPILE(ARCHIVE_HASH_${HASH}_WIN | |
| 447 | ${CMAKE_BINARY_DIR} | |
| 448 | ${SOURCE_FILE} | |
| 449 | CMAKE_FLAGS "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_CURRENT_SOURCE_DIR}/libarchive" | |
| 450 | OUTPUT_VARIABLE OUTPUT) | |
| 451 | ||
| 452 | IF (ARCHIVE_HASH_${HASH}_WIN) | |
| 453 | MESSAGE(STATUS | |
| 454 | "Checking support for ARCHIVE_HASH_${HASH}_WIN -- found") | |
| 455 | ELSE (ARCHIVE_HASH_${HASH}_WIN) | |
| 456 | MESSAGE(STATUS | |
| 457 | "Checking support for ARCHIVE_HASH_${HASH}_WIN -- not found") | |
| 458 | FILE(APPEND | |
| 459 | ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log | |
| 460 | "Checking support for ARCHIVE_HASH_${HASH}_WIN failed with the following output:\n" | |
| 461 | "${OUTPUT}\n" | |
| 462 | "Source file was:\n${SOURCE}\n") | |
| 463 | ENDIF (ARCHIVE_HASH_${HASH}_WIN) | |
| 464 | ||
| 465 | ENDIF(NOT DEFINED ARCHIVE_HASH_${HASH}_WIN) | |
| 466 | ENDFOREACH(HASH) | |
| 467 | ENDIF(WIN32 AND NOT CYGWIN) | |
| 468 | ENDMACRO(CHECK_HASH_WIN HASH_LIST) | |
| 469 | ||
| 16151528 | 470 | # |
| 2ce66f4b | 471 | # Check MD5/RMD160/SHA support |
| 2846d884 | 472 | # |
| 8be5e0fa | 473 | CHECK_MD(MD5 "LIBC;LIBSYSTEM;OPENSSL") |
| a8c22d8a | 474 | CHECK_MD(RMD160 "LIBC;OPENSSL") |
| 8be5e0fa MN |
475 | CHECK_MD(SHA1 "LIBC;LIBSYSTEM;OPENSSL") |
| 476 | CHECK_MD(SHA256 "LIBC;LIBC2;LIBC3;LIBSYSTEM;OPENSSL") | |
| 477 | CHECK_MD(SHA384 "LIBC;LIBC2;LIBC3;LIBSYSTEM;OPENSSL") | |
| 478 | CHECK_MD(SHA512 "LIBC;LIBC2;LIBC3;LIBSYSTEM;OPENSSL") | |
| a8c22d8a | 479 | CHECK_HASH_WIN("MD5;SHA1;SHA256;SHA384;SHA512") |
| 22b1a517 | 480 | |
| d1899374 TK |
481 | # |
| 482 | # Find iconv | |
| 5289fb9b TK |
483 | # POSIX defines the second arg as const char ** |
| 484 | # and requires it to be in libc. But we can accept | |
| 485 | # a non-const argument here and can support iconv() | |
| 486 | # being in libiconv. | |
| d1899374 | 487 | # |
| 5aafacca MN |
488 | IF(ENABLE_ICONV) |
| 489 | FIND_PATH(ICONV_INCLUDE_DIR iconv.h) | |
| 490 | IF(ICONV_INCLUDE_DIR) | |
| 491 | INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR}) | |
| 492 | SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR}) | |
| 493 | #SET(INCLUDES ${INCLUDES} "iconv.h") | |
| 494 | SET(HAVE_ICONV_H 1) | |
| 495 | ||
| 496 | # Try POSIX-conforming iconv() in libc | |
| 5289fb9b | 497 | CHECK_C_SOURCE_COMPILES( |
| 78c22260 MN |
498 | "#include <stdlib.h> |
| 499 | #include <iconv.h> | |
| 500 | int main() {const char *ccp; iconv_t cd = iconv_open(\"\", \"\"); | |
| 5289fb9b | 501 | iconv(cd, &ccp, (size_t *)0, (char **)0, (size_t *)0); |
| 78c22260 | 502 | iconv_close(cd); |
| 5289fb9b | 503 | return 0;}" |
| 5aafacca MN |
504 | HAVE_POSIX_ICONV_IN_LIBC) |
| 505 | IF(HAVE_POSIX_ICONV_IN_LIBC) | |
| 5289fb9b | 506 | SET(HAVE_ICONV true) |
| 5aafacca MN |
507 | SET(ICONV_CONST "const") |
| 508 | ELSE(HAVE_POSIX_ICONV_IN_LIBC) | |
| 5289fb9b | 509 | |
| 5aafacca MN |
510 | # Try non-POSIX-conforming iconv() in libc |
| 511 | CHECK_C_SOURCE_COMPILES( | |
| 78c22260 MN |
512 | "#include <stdlib.h> |
| 513 | #include <iconv.h> | |
| 514 | int main() {char *ccp; iconv_t cd = iconv_open(\"\", \"\"); | |
| 5aafacca | 515 | iconv(cd, &ccp, (size_t *)0, (char **)0, (size_t *)0); |
| 78c22260 | 516 | iconv_close(cd); |
| 5aafacca MN |
517 | return 0;}" |
| 518 | HAVE_NONPOSIX_ICONV_IN_LIBC) | |
| 519 | IF(HAVE_NONPOSIX_ICONV_IN_LIBC) | |
| 520 | SET(HAVE_ICONV true) | |
| 521 | SET(ICONV_CONST "") | |
| 522 | ELSE(HAVE_NONPOSIX_ICONV_IN_LIBC) | |
| 523 | ||
| 524 | # iconv isn't in libc, try libiconv | |
| 525 | FIND_LIBRARY(LIBICONV_PATH iconv) | |
| 526 | IF(LIBICONV_PATH) | |
| 527 | SET(CMAKE_REQUIRED_LIBRARIES ${LIBICONV_PATH}) | |
| 528 | ENDIF(LIBICONV_PATH) | |
| 5289fb9b | 529 | CHECK_C_SOURCE_COMPILES( |
| 78c22260 MN |
530 | "#include <stdlib.h> |
| 531 | #include <iconv.h> | |
| 532 | int main() {const char *ccp; iconv_t cd = iconv_open(\"\", \"\"); | |
| 5289fb9b | 533 | iconv(cd, &ccp, (size_t *)0, (char **)0, (size_t *)0); |
| 78c22260 | 534 | iconv_close(cd); |
| 5289fb9b | 535 | return 0;}" |
| 5aafacca MN |
536 | HAVE_POSIX_ICONV_IN_LIBICONV) |
| 537 | IF(HAVE_POSIX_ICONV_IN_LIBICONV) | |
| 5289fb9b | 538 | SET(HAVE_ICONV true) |
| 5aafacca | 539 | SET(ICONV_CONST "const") |
| 2e51ac6a | 540 | LIST(APPEND ADDITIONAL_LIBS ${LIBICONV_PATH}) |
| 5aafacca MN |
541 | ELSE(HAVE_POSIX_ICONV_IN_LIBICONV) |
| 542 | ||
| 543 | CHECK_C_SOURCE_COMPILES( | |
| 78c22260 MN |
544 | "#include <stdlib.h> |
| 545 | #include <iconv.h> | |
| 546 | int main() {char *ccp; iconv_t cd = iconv_open(\"\", \"\"); | |
| 5aafacca | 547 | iconv(cd, &ccp, (size_t *)0, (char **)0, (size_t *)0); |
| 78c22260 | 548 | iconv_close(cd); |
| 5aafacca MN |
549 | return 0;}" |
| 550 | HAVE_NONPOSIX_ICONV_IN_LIBICONV) | |
| 551 | IF(HAVE_NONPOSIX_ICONV_IN_LIBICONV) | |
| 552 | SET(HAVE_ICONV true) | |
| 553 | SET(ICONV_CONST "") | |
| 554 | LIST(APPEND ADDITIONAL_LIBS ${LIBICONV_PATH}) | |
| 555 | ENDIF(HAVE_NONPOSIX_ICONV_IN_LIBICONV) | |
| 556 | ENDIF(HAVE_POSIX_ICONV_IN_LIBICONV) | |
| 557 | ENDIF(HAVE_NONPOSIX_ICONV_IN_LIBC) | |
| 558 | ENDIF(HAVE_POSIX_ICONV_IN_LIBC) | |
| 559 | ENDIF(ICONV_INCLUDE_DIR) | |
| 560 | # | |
| 561 | # Find locale_charset() for libiconv. | |
| 562 | # | |
| 563 | IF(LIBICONV_PATH) | |
| 564 | CHECK_INCLUDE_FILES("localcharset.h" HAVE_LOCALCHARSET_H) | |
| 565 | CHECK_FUNCTION_EXISTS_GLIBC(locale_charset HAVE_LOCALE_CHARSET) | |
| 566 | IF(NOT HAVE_LOCALE_CHARSET) | |
| 567 | FIND_LIBRARY(LIBCHARSET_PATH charset) | |
| 568 | IF(LIBCHARSET_PATH) | |
| 569 | SET(CMAKE_REQUIRED_LIBRARIES ${LIBCHARSET_PATH}) | |
| 570 | CHECK_FUNCTION_EXISTS_GLIBC(locale_charset HAVE_LOCALE_CHARSET) | |
| 571 | IF(HAVE_LOCALE_CHARSET) | |
| 572 | LIST(APPEND ADDITIONAL_LIBS ${LIBCHARSET_PATH}) | |
| 573 | ENDIF(HAVE_LOCALE_CHARSET) | |
| 574 | ENDIF(LIBCHARSET_PATH) | |
| 575 | ENDIF(NOT HAVE_LOCALE_CHARSET) | |
| 576 | ENDIF(LIBICONV_PATH) | |
| 577 | ENDIF(ENABLE_ICONV) | |
| d1899374 | 578 | |
| d2c0930d MN |
579 | # |
| 580 | # Find Libxml2 | |
| 581 | # | |
| 582 | FIND_PACKAGE(LibXml2) | |
| 583 | IF(LIBXML2_FOUND) | |
| 584 | INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR}) | |
| 585 | LIST(APPEND ADDITIONAL_LIBS ${LIBXML2_LIBRARIES}) | |
| 586 | SET(HAVE_LIBXML2 1) | |
| 587 | # libxml2's include files use iconv.h | |
| d2c0930d | 588 | SET(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR}) |
| 6b8c67f2 | 589 | CHECK_INCLUDE_FILES("libxml/xmlreader.h" HAVE_LIBXML_XMLREADER_H) |
| b7115a7d | 590 | CHECK_INCLUDE_FILES("libxml/xmlwriter.h" HAVE_LIBXML_XMLWRITER_H) |
| d2c0930d MN |
591 | SET(CMAKE_REQUIRED_INCLUDES "") |
| 592 | ELSE(LIBXML2_FOUND) | |
| 593 | # | |
| 594 | # Find Expat | |
| 595 | # | |
| aa5b327f MN |
596 | FIND_PACKAGE(EXPAT) |
| 597 | IF(EXPAT_FOUND) | |
| 598 | INCLUDE_DIRECTORIES(${EXPAT_INCLUDE_DIR}) | |
| 599 | LIST(APPEND ADDITIONAL_LIBS ${EXPAT_LIBRARIES}) | |
| ffb72cae | 600 | SET(HAVE_LIBEXPAT 1) |
| aa5b327f MN |
601 | LA_CHECK_INCLUDE_FILE("expat.h" HAVE_EXPAT_H) |
| 602 | ENDIF(EXPAT_FOUND) | |
| d2c0930d MN |
603 | ENDIF(LIBXML2_FOUND) |
| 604 | ||
| 8b7ba998 TK |
605 | # |
| 606 | # Check functions | |
| 607 | # | |
| a1d8db29 MN |
608 | IF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$") |
| 609 | # | |
| 610 | # During checking functions, we should use -fno-builtin to avoid the | |
| 611 | # failure of function detection which failure is an error "conflicting | |
| 612 | # types for built-in function" caused by using -Werror option. | |
| 613 | # | |
| 614 | SET(SAVE_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS}) | |
| 615 | SET(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -fno-builtin") | |
| 616 | ENDIF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$") | |
| 3f7c4c64 | 617 | CHECK_SYMBOL_EXISTS(_CrtSetReportMode "crtdbg.h" HAVE__CrtSetReportMode) |
| 950a18b3 TK |
618 | CHECK_FUNCTION_EXISTS_GLIBC(chflags HAVE_CHFLAGS) |
| 619 | CHECK_FUNCTION_EXISTS_GLIBC(chown HAVE_CHOWN) | |
| 620 | CHECK_FUNCTION_EXISTS_GLIBC(chroot HAVE_CHROOT) | |
| 411d7de8 | 621 | CHECK_FUNCTION_EXISTS_GLIBC(ctime_r HAVE_CTIME_R) |
| 950a18b3 TK |
622 | CHECK_FUNCTION_EXISTS_GLIBC(fchdir HAVE_FCHDIR) |
| 623 | CHECK_FUNCTION_EXISTS_GLIBC(fchflags HAVE_FCHFLAGS) | |
| 624 | CHECK_FUNCTION_EXISTS_GLIBC(fchmod HAVE_FCHMOD) | |
| 625 | CHECK_FUNCTION_EXISTS_GLIBC(fchown HAVE_FCHOWN) | |
| 626 | CHECK_FUNCTION_EXISTS_GLIBC(fcntl HAVE_FCNTL) | |
| ba463cc3 | 627 | CHECK_FUNCTION_EXISTS_GLIBC(fdopendir HAVE_FDOPENDIR) |
| 950a18b3 TK |
628 | CHECK_FUNCTION_EXISTS_GLIBC(fork HAVE_FORK) |
| 629 | CHECK_FUNCTION_EXISTS_GLIBC(fstat HAVE_FSTAT) | |
| ba23ec82 MN |
630 | CHECK_FUNCTION_EXISTS_GLIBC(fstatat HAVE_FSTATAT) |
| 631 | CHECK_FUNCTION_EXISTS_GLIBC(fstatfs HAVE_FSTATFS) | |
| 632 | CHECK_FUNCTION_EXISTS_GLIBC(fstatvfs HAVE_FSTATVFS) | |
| 950a18b3 | 633 | CHECK_FUNCTION_EXISTS_GLIBC(ftruncate HAVE_FTRUNCATE) |
| c9ad879b | 634 | CHECK_FUNCTION_EXISTS_GLIBC(futimens HAVE_FUTIMENS) |
| 950a18b3 | 635 | CHECK_FUNCTION_EXISTS_GLIBC(futimes HAVE_FUTIMES) |
| 4f1939c9 | 636 | CHECK_FUNCTION_EXISTS_GLIBC(futimesat HAVE_FUTIMESAT) |
| 950a18b3 | 637 | CHECK_FUNCTION_EXISTS_GLIBC(geteuid HAVE_GETEUID) |
| 2730e1cb | 638 | CHECK_FUNCTION_EXISTS_GLIBC(getgrgid_r HAVE_GETGRGID_R) |
| d45151bf JS |
639 | CHECK_FUNCTION_EXISTS_GLIBC(getgrnam_r HAVE_GETGRNAM_R) |
| 640 | CHECK_FUNCTION_EXISTS_GLIBC(getpwnam_r HAVE_GETPWNAM_R) | |
| 2730e1cb | 641 | CHECK_FUNCTION_EXISTS_GLIBC(getpwuid_r HAVE_GETPWUID_R) |
| 950a18b3 | 642 | CHECK_FUNCTION_EXISTS_GLIBC(getpid HAVE_GETPID) |
| a3b61f44 | 643 | CHECK_FUNCTION_EXISTS_GLIBC(getvfsbyname HAVE_GETVFSBYNAME) |
| b7115a7d | 644 | CHECK_FUNCTION_EXISTS_GLIBC(gmtime_r HAVE_GMTIME_R) |
| 950a18b3 TK |
645 | CHECK_FUNCTION_EXISTS_GLIBC(lchflags HAVE_LCHFLAGS) |
| 646 | CHECK_FUNCTION_EXISTS_GLIBC(lchmod HAVE_LCHMOD) | |
| 647 | CHECK_FUNCTION_EXISTS_GLIBC(lchown HAVE_LCHOWN) | |
| 648 | CHECK_FUNCTION_EXISTS_GLIBC(link HAVE_LINK) | |
| 593c0d35 | 649 | CHECK_FUNCTION_EXISTS_GLIBC(localtime_r HAVE_LOCALTIME_R) |
| 950a18b3 TK |
650 | CHECK_FUNCTION_EXISTS_GLIBC(lstat HAVE_LSTAT) |
| 651 | CHECK_FUNCTION_EXISTS_GLIBC(lutimes HAVE_LUTIMES) | |
| 9d72ea76 | 652 | CHECK_FUNCTION_EXISTS_GLIBC(mbrtowc HAVE_MBRTOWC) |
| 496b1876 | 653 | CHECK_FUNCTION_EXISTS_GLIBC(mbsnrtowcs HAVE_MBSNRTOWCS) |
| 950a18b3 | 654 | CHECK_FUNCTION_EXISTS_GLIBC(memmove HAVE_MEMMOVE) |
| 950a18b3 TK |
655 | CHECK_FUNCTION_EXISTS_GLIBC(mkdir HAVE_MKDIR) |
| 656 | CHECK_FUNCTION_EXISTS_GLIBC(mkfifo HAVE_MKFIFO) | |
| 657 | CHECK_FUNCTION_EXISTS_GLIBC(mknod HAVE_MKNOD) | |
| 68fb45a1 | 658 | CHECK_FUNCTION_EXISTS_GLIBC(mkstemp HAVE_MKSTEMP) |
| 950a18b3 | 659 | CHECK_FUNCTION_EXISTS_GLIBC(nl_langinfo HAVE_NL_LANGINFO) |
| ba23ec82 | 660 | CHECK_FUNCTION_EXISTS_GLIBC(openat HAVE_OPENAT) |
| 950a18b3 TK |
661 | CHECK_FUNCTION_EXISTS_GLIBC(pipe HAVE_PIPE) |
| 662 | CHECK_FUNCTION_EXISTS_GLIBC(poll HAVE_POLL) | |
| 663 | CHECK_FUNCTION_EXISTS_GLIBC(readlink HAVE_READLINK) | |
| 664 | CHECK_FUNCTION_EXISTS_GLIBC(select HAVE_SELECT) | |
| 665 | CHECK_FUNCTION_EXISTS_GLIBC(setenv HAVE_SETENV) | |
| 666 | CHECK_FUNCTION_EXISTS_GLIBC(setlocale HAVE_SETLOCALE) | |
| b5bae8ca | 667 | CHECK_FUNCTION_EXISTS_GLIBC(sigaction HAVE_SIGACTION) |
| 4ba1f7d7 | 668 | CHECK_FUNCTION_EXISTS_GLIBC(statfs HAVE_STATFS) |
| 8161d987 | 669 | CHECK_FUNCTION_EXISTS_GLIBC(statvfs HAVE_STATVFS) |
| 950a18b3 TK |
670 | CHECK_FUNCTION_EXISTS_GLIBC(strchr HAVE_STRCHR) |
| 671 | CHECK_FUNCTION_EXISTS_GLIBC(strdup HAVE_STRDUP) | |
| 672 | CHECK_FUNCTION_EXISTS_GLIBC(strerror HAVE_STRERROR) | |
| 125047fc | 673 | CHECK_FUNCTION_EXISTS_GLIBC(strncpy_s HAVE_STRNCPY_S) |
| 950a18b3 TK |
674 | CHECK_FUNCTION_EXISTS_GLIBC(strrchr HAVE_STRRCHR) |
| 675 | CHECK_FUNCTION_EXISTS_GLIBC(symlink HAVE_SYMLINK) | |
| 676 | CHECK_FUNCTION_EXISTS_GLIBC(timegm HAVE_TIMEGM) | |
| 677 | CHECK_FUNCTION_EXISTS_GLIBC(tzset HAVE_TZSET) | |
| 678 | CHECK_FUNCTION_EXISTS_GLIBC(unsetenv HAVE_UNSETENV) | |
| 679 | CHECK_FUNCTION_EXISTS_GLIBC(utime HAVE_UTIME) | |
| 680 | CHECK_FUNCTION_EXISTS_GLIBC(utimes HAVE_UTIMES) | |
| 3b73222c | 681 | CHECK_FUNCTION_EXISTS_GLIBC(utimensat HAVE_UTIMENSAT) |
| 950a18b3 TK |
682 | CHECK_FUNCTION_EXISTS_GLIBC(vfork HAVE_VFORK) |
| 683 | CHECK_FUNCTION_EXISTS_GLIBC(wcrtomb HAVE_WCRTOMB) | |
| 86eb88d7 | 684 | CHECK_FUNCTION_EXISTS_GLIBC(wcscmp HAVE_WCSCMP) |
| 950a18b3 TK |
685 | CHECK_FUNCTION_EXISTS_GLIBC(wcscpy HAVE_WCSCPY) |
| 686 | CHECK_FUNCTION_EXISTS_GLIBC(wcslen HAVE_WCSLEN) | |
| 7a4bf769 | 687 | CHECK_FUNCTION_EXISTS_GLIBC(wcsnrtombs HAVE_WCSNRTOMBS) |
| 950a18b3 | 688 | CHECK_FUNCTION_EXISTS_GLIBC(wctomb HAVE_WCTOMB) |
| 411d7de8 | 689 | CHECK_FUNCTION_EXISTS_GLIBC(_ctime64_s HAVE__CTIME64_S) |
| 7e7bb70e | 690 | CHECK_FUNCTION_EXISTS_GLIBC(_fseeki64 HAVE__FSEEKI64) |
| 411d7de8 MN |
691 | CHECK_FUNCTION_EXISTS_GLIBC(_get_timezone HAVE__GET_TIMEZONE) |
| 692 | CHECK_FUNCTION_EXISTS_GLIBC(_localtime64_s HAVE__LOCALTIME64_S) | |
| f16db747 | 693 | CHECK_FUNCTION_EXISTS_GLIBC(_mkgmtime64 HAVE__MKGMTIME64) |
| 8b7ba998 TK |
694 | |
| 695 | SET(CMAKE_REQUIRED_LIBRARIES "") | |
| ca58a31d TK |
696 | CHECK_FUNCTION_EXISTS(cygwin_conv_path HAVE_CYGWIN_CONV_PATH) |
| 697 | CHECK_FUNCTION_EXISTS(fseeko HAVE_FSEEKO) | |
| 698 | CHECK_FUNCTION_EXISTS(strerror_r HAVE_STRERROR_R) | |
| 699 | CHECK_FUNCTION_EXISTS(strftime HAVE_STRFTIME) | |
| 700 | CHECK_FUNCTION_EXISTS(vprintf HAVE_VPRINTF) | |
| 701 | CHECK_FUNCTION_EXISTS(wmemcmp HAVE_WMEMCMP) | |
| 702 | CHECK_FUNCTION_EXISTS(wmemcpy HAVE_WMEMCPY) | |
| 703 | ||
| a1d8db29 MN |
704 | # Restore CMAKE_REQUIRED_FLAGS |
| 705 | IF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$") | |
| 706 | SET(CMAKE_REQUIRED_FLAGS ${SAVE_CMAKE_REQUIRED_FLAGS}) | |
| 707 | ENDIF ("CMAKE_C_COMPILER_ID" MATCHES "^GNU$") | |
| 708 | ||
| c8f97841 TK |
709 | # Make sure we have the POSIX version of readdir_r, not the |
| 710 | # older 2-argument version. | |
| 711 | CHECK_C_SOURCE_COMPILES( | |
| 86cda81d | 712 | "#include <dirent.h>\nint main() {DIR *d = opendir(\".\"); struct dirent e,*r; return readdir_r(d,&e,&r);}" |
| c8f97841 TK |
713 | HAVE_READDIR_R) |
| 714 | ||
| df401b4a TK |
715 | |
| 716 | # Only detect readlinkat() if we also have AT_FDCWD in unistd.h. | |
| 717 | CHECK_C_SOURCE_COMPILES( | |
| 718 | "#include <unistd.h>\nint main() {return readlinkat(AT_FDCWD, NULL, 0);}" | |
| 719 | HAVE_READLINKAT) | |
| 720 | ||
| 721 | ||
| ca58a31d TK |
722 | # To verify major(), we need to both include the header |
| 723 | # of interest and verify that the result can be linked. | |
| 724 | # CHECK_FUNCTION_EXISTS doesn't accept a header argument, | |
| 725 | # CHECK_SYMBOL_EXISTS doesn't test linkage. | |
| 726 | CHECK_C_SOURCE_COMPILES( | |
| 727 | "#include <sys/mkdev.h>\nint main() { return major(256); }" | |
| 728 | MAJOR_IN_MKDEV) | |
| 729 | CHECK_C_SOURCE_COMPILES( | |
| 730 | "#include <sys/sysmacros.h>\nint main() { return major(256); }" | |
| 731 | MAJOR_IN_SYSMACROS) | |
| 003ae2f2 | 732 | |
| 8b7ba998 TK |
733 | IF(HAVE_STRERROR_R) |
| 734 | SET(HAVE_DECL_STRERROR_R 1) | |
| 735 | ENDIF(HAVE_STRERROR_R) | |
| 736 | ||
| 737 | # | |
| 738 | # Check defines | |
| 739 | # | |
| 159c809b BK |
740 | SET(headers "limits.h") |
| 741 | IF(HAVE_STDINT_H) | |
| 742 | LIST(APPEND headers "stdint.h") | |
| 743 | ENDIF(HAVE_STDINT_H) | |
| 744 | IF(HAVE_INTTYPES_H) | |
| 745 | LIST(APPEND headers "inttypes.h") | |
| 746 | ENDIF(HAVE_INTTYPES_H) | |
| 8b7ba998 TK |
747 | CHECK_SYMBOL_EXISTS(EFTYPE "errno.h" HAVE_EFTYPE) |
| 748 | CHECK_SYMBOL_EXISTS(EILSEQ "errno.h" HAVE_EILSEQ) | |
| 749 | CHECK_SYMBOL_EXISTS(D_MD_ORDER "langinfo.h" HAVE_D_MD_ORDER) | |
| 159c809b BK |
750 | CHECK_SYMBOL_EXISTS(INT64_MAX "${headers}" HAVE_DECL_INT64_MAX) |
| 751 | CHECK_SYMBOL_EXISTS(INT64_MIN "${headers}" HAVE_DECL_INT64_MIN) | |
| 752 | CHECK_SYMBOL_EXISTS(UINT32_MAX "${headers}" HAVE_DECL_UINT32_MAX) | |
| 753 | CHECK_SYMBOL_EXISTS(UINT64_MAX "${headers}" HAVE_DECL_UINT64_MAX) | |
| 754 | CHECK_SYMBOL_EXISTS(SIZE_MAX "${headers}" HAVE_DECL_SIZE_MAX) | |
| 8b7ba998 TK |
755 | CHECK_SYMBOL_EXISTS(SSIZE_MAX "limits.h" HAVE_DECL_SSIZE_MAX) |
| 756 | ||
| 757 | # | |
| 758 | # Check struct members | |
| 759 | # | |
| 9d72ea76 MN |
760 | # Check for tm_gmtoff in struct tm |
| 761 | CHECK_STRUCT_MEMBER("struct tm" tm_gmtoff | |
| 762 | "time.h" HAVE_STRUCT_TM_TM_GMTOFF) | |
| 763 | CHECK_STRUCT_MEMBER("struct tm" __tm_gmtoff | |
| 764 | "time.h" HAVE_STRUCT_TM___TM_GMTOFF) | |
| 765 | ||
| a3b61f44 MN |
766 | # Check for f_namemax in struct statfs |
| 767 | CHECK_STRUCT_MEMBER("struct statfs" f_namemax | |
| 768 | "sys/param.h;sys/mount.h" HAVE_STRUCT_STATFS_F_NAMEMAX) | |
| 769 | ||
| 8b7ba998 TK |
770 | # Check for birthtime in struct stat |
| 771 | CHECK_STRUCT_MEMBER("struct stat" st_birthtime | |
| 772 | "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BIRTHTIME) | |
| 773 | ||
| 774 | # Check for high-resolution timestamps in struct stat | |
| 775 | CHECK_STRUCT_MEMBER("struct stat" st_birthtimespec.tv_nsec | |
| 776 | "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC) | |
| 777 | CHECK_STRUCT_MEMBER("struct stat" st_mtimespec.tv_nsec | |
| 778 | "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC) | |
| 779 | CHECK_STRUCT_MEMBER("struct stat" st_mtim.tv_nsec | |
| 780 | "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC) | |
| d3c720f3 MN |
781 | CHECK_STRUCT_MEMBER("struct stat" st_mtime_n |
| 782 | "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIME_N) | |
| 783 | CHECK_STRUCT_MEMBER("struct stat" st_umtime | |
| 784 | "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_UMTIME) | |
| a101fb70 MN |
785 | CHECK_STRUCT_MEMBER("struct stat" st_mtime_usec |
| 786 | "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_MTIME_USEC) | |
| 8b7ba998 TK |
787 | # Check for block size support in struct stat |
| 788 | CHECK_STRUCT_MEMBER("struct stat" st_blksize | |
| 789 | "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_BLKSIZE) | |
| 790 | # Check for st_flags in struct stat (BSD fflags) | |
| 791 | CHECK_STRUCT_MEMBER("struct stat" st_flags | |
| 792 | "sys/types.h;sys/stat.h" HAVE_STRUCT_STAT_ST_FLAGS) | |
| 793 | # | |
| 794 | # | |
| 795 | CHECK_STRUCT_MEMBER("struct tm" tm_sec | |
| 796 | "sys/types.h;sys/time.h;time.h" TIME_WITH_SYS_TIME) | |
| 797 | ||
| 798 | # | |
| 87b05751 TK |
799 | # Check for integer types |
| 800 | # | |
| 8b7ba998 | 801 | # |
| 17e08238 TK |
802 | CHECK_TYPE_SIZE("short" SIZE_OF_SHORT) |
| 803 | CHECK_TYPE_SIZE("int" SIZE_OF_INT) | |
| 804 | CHECK_TYPE_SIZE("long" SIZE_OF_LONG) | |
| 805 | CHECK_TYPE_SIZE("long long" SIZE_OF_LONG_LONG) | |
| 806 | ||
| 807 | CHECK_TYPE_SIZE("unsigned short" SIZE_OF_UNSIGNED_SHORT) | |
| 808 | CHECK_TYPE_SIZE("unsigned" SIZE_OF_UNSIGNED) | |
| 809 | CHECK_TYPE_SIZE("unsigned long" SIZE_OF_UNSIGNED_LONG) | |
| 810 | CHECK_TYPE_SIZE("unsigned long long" SIZE_OF_UNSIGNED_LONG_LONG) | |
| 811 | ||
| 812 | CHECK_TYPE_SIZE("__int64" __INT64) | |
| 813 | CHECK_TYPE_SIZE("unsigned __int64" UNSIGNED___INT64) | |
| 814 | ||
| 815 | CHECK_TYPE_SIZE(int16_t INT16_T) | |
| 816 | CHECK_TYPE_SIZE(int32_t INT32_T) | |
| 817 | CHECK_TYPE_SIZE(int64_t INT64_T) | |
| 818 | CHECK_TYPE_SIZE(intmax_t INTMAX_T) | |
| 819 | CHECK_TYPE_SIZE(uint16_t UINT16_T) | |
| 820 | CHECK_TYPE_SIZE(uint32_t UINT32_T) | |
| 821 | CHECK_TYPE_SIZE(uint64_t UINT64_T) | |
| 822 | CHECK_TYPE_SIZE(uintmax_t UINTMAX_T) | |
| 8b7ba998 | 823 | |
| 8b7ba998 TK |
824 | CHECK_TYPE_SIZE(dev_t DEV_T) |
| 825 | IF(NOT HAVE_DEV_T) | |
| 826 | IF(MSVC) | |
| 827 | SET(dev_t "unsigned int") | |
| 828 | ENDIF(MSVC) | |
| 829 | ENDIF(NOT HAVE_DEV_T) | |
| 830 | # | |
| 831 | CHECK_TYPE_SIZE(gid_t GID_T) | |
| 832 | IF(NOT HAVE_GID_T) | |
| 833 | IF(WIN32) | |
| 1e202fe1 | 834 | SET(gid_t "short") |
| 2566a7ab | 835 | ELSE(WIN32) |
| 1e202fe1 | 836 | SET(gid_t "unsigned int") |
| 8b7ba998 TK |
837 | ENDIF(WIN32) |
| 838 | ENDIF(NOT HAVE_GID_T) | |
| 839 | # | |
| 840 | CHECK_TYPE_SIZE(id_t ID_T) | |
| 841 | IF(NOT HAVE_ID_T) | |
| 1e202fe1 TK |
842 | IF(WIN32) |
| 843 | SET(id_t "short") | |
| 2566a7ab | 844 | ELSE(WIN32) |
| 1e202fe1 TK |
845 | SET(id_t "unsigned int") |
| 846 | ENDIF(WIN32) | |
| 8b7ba998 TK |
847 | ENDIF(NOT HAVE_ID_T) |
| 848 | # | |
| 8b7ba998 TK |
849 | CHECK_TYPE_SIZE(mode_t MODE_T) |
| 850 | IF(NOT HAVE_MODE_T) | |
| 2566a7ab | 851 | IF(WIN32) |
| 8b7ba998 | 852 | SET(mode_t "unsigned short") |
| 2566a7ab | 853 | ELSE(WIN32) |
| 8b7ba998 | 854 | SET(mode_t "int") |
| 2566a7ab | 855 | ENDIF(WIN32) |
| 8b7ba998 TK |
856 | ENDIF(NOT HAVE_MODE_T) |
| 857 | # | |
| 858 | CHECK_TYPE_SIZE(off_t OFF_T) | |
| 859 | IF(NOT HAVE_OFF_T) | |
| 2566a7ab | 860 | SET(off_t "__int64") |
| 8b7ba998 TK |
861 | ENDIF(NOT HAVE_OFF_T) |
| 862 | # | |
| 8b7ba998 TK |
863 | CHECK_TYPE_SIZE(size_t SIZE_T) |
| 864 | IF(NOT HAVE_SIZE_T) | |
| e0f0abf0 BK |
865 | IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) |
| 866 | SET(size_t "uint64_t") | |
| 867 | ELSE("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) | |
| 868 | SET(size_t "uint32_t") | |
| 869 | ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) | |
| 8b7ba998 TK |
870 | ENDIF(NOT HAVE_SIZE_T) |
| 871 | # | |
| 872 | CHECK_TYPE_SIZE(ssize_t SSIZE_T) | |
| 873 | IF(NOT HAVE_SSIZE_T) | |
| e0f0abf0 BK |
874 | IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) |
| 875 | SET(ssize_t "int64_t") | |
| 876 | ELSE("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) | |
| 877 | SET(ssize_t "long") | |
| 878 | ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) | |
| 8b7ba998 TK |
879 | ENDIF(NOT HAVE_SSIZE_T) |
| 880 | # | |
| 881 | CHECK_TYPE_SIZE(uid_t UID_T) | |
| 882 | IF(NOT HAVE_UID_T) | |
| 883 | IF(WIN32) | |
| 1e202fe1 | 884 | SET(uid_t "short") |
| 2566a7ab | 885 | ELSE(WIN32) |
| 1e202fe1 | 886 | SET(uid_t "unsigned int") |
| 8b7ba998 TK |
887 | ENDIF(WIN32) |
| 888 | ENDIF(NOT HAVE_UID_T) | |
| 889 | # | |
| e1932819 TK |
890 | CHECK_TYPE_SIZE(pid_t PID_T) |
| 891 | IF(NOT HAVE_PID_T) | |
| 892 | IF(WIN32) | |
| 893 | SET(pid_t "int") | |
| 894 | ELSE(WIN32) | |
| 895 | MESSAGE(FATAL_ERROR "pid_t doesn't exist on this platform?") | |
| 896 | ENDIF(WIN32) | |
| 897 | ENDIF(NOT HAVE_PID_T) | |
| 898 | # | |
| be2f791b BK |
899 | CHECK_TYPE_SIZE(intptr_t INTPTR_T) |
| 900 | IF(NOT HAVE_INTPTR_T) | |
| 901 | IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) | |
| 902 | SET(intptr_t "int64_t") | |
| 903 | ELSE() | |
| 904 | SET(intptr_t "int32_t") | |
| 905 | ENDIF() | |
| 906 | ENDIF(NOT HAVE_INTPTR_T) | |
| 907 | # | |
| 908 | CHECK_TYPE_SIZE(uintptr_t UINTPTR_T) | |
| 909 | IF(NOT HAVE_UINTPTR_T) | |
| 910 | IF("${CMAKE_SIZEOF_VOID_P}" EQUAL 8) | |
| 911 | SET(uintptr_t "uint64_t") | |
| 912 | ELSE() | |
| 913 | SET(uintptr_t "uint32_t") | |
| 914 | ENDIF() | |
| 915 | ENDIF(NOT HAVE_UINTPTR_T) | |
| 916 | # | |
| 778a496c | 917 | CHECK_TYPE_SIZE(wchar_t SIZEOF_WCHAR_T) |
| 1b7e93f0 MN |
918 | IF(HAVE_SIZEOF_WCHAR_T) |
| 919 | SET(HAVE_WCHAR_T 1) | |
| 920 | ENDIF(HAVE_SIZEOF_WCHAR_T) | |
| 778a496c | 921 | # |
| 19a8ead1 MN |
922 | # Check if _FILE_OFFSET_BITS macro needed for large files |
| 923 | # | |
| 924 | CHECK_FILE_OFFSET_BITS() | |
| 8b7ba998 TK |
925 | |
| 926 | # | |
| 87b05751 | 927 | # Check for Extended Attribute libraries, headers, and functions |
| 8b7ba998 | 928 | # |
| 806025f2 | 929 | IF(ENABLE_XATTR) |
| 79150845 TK |
930 | LA_CHECK_INCLUDE_FILE(attr/xattr.h HAVE_ATTR_XATTR_H) |
| 931 | LA_CHECK_INCLUDE_FILE(sys/xattr.h HAVE_SYS_XATTR_H) | |
| d935c741 | 932 | LA_CHECK_INCLUDE_FILE(sys/extattr.h HAVE_SYS_EXTATTR_H) |
| 4c2b2c54 MN |
933 | CHECK_LIBRARY_EXISTS(attr "setxattr" "" HAVE_LIBATTR) |
| 934 | IF(HAVE_LIBATTR) | |
| 8b7ba998 | 935 | SET(CMAKE_REQUIRED_LIBRARIES "attr") |
| 4c2b2c54 | 936 | ENDIF(HAVE_LIBATTR) |
| d935c741 | 937 | CHECK_SYMBOL_EXISTS(EXTATTR_NAMESPACE_USER "sys/types.h;sys/extattr.h" HAVE_DECL_EXTATTR_NAMESPACE_USER) |
| 950a18b3 TK |
938 | CHECK_FUNCTION_EXISTS_GLIBC(extattr_get_file HAVE_EXTATTR_GET_FILE) |
| 939 | CHECK_FUNCTION_EXISTS_GLIBC(extattr_list_file HAVE_EXTATTR_LIST_FILE) | |
| 940 | CHECK_FUNCTION_EXISTS_GLIBC(extattr_set_fd HAVE_EXTATTR_SET_FD) | |
| 941 | CHECK_FUNCTION_EXISTS_GLIBC(extattr_set_file HAVE_EXTATTR_SET_FILE) | |
| 0f5b79c8 MN |
942 | CHECK_FUNCTION_EXISTS_GLIBC(fgetxattr HAVE_FGETXATTR) |
| 943 | CHECK_FUNCTION_EXISTS_GLIBC(flistxattr HAVE_FLISTXATTR) | |
| 950a18b3 TK |
944 | CHECK_FUNCTION_EXISTS_GLIBC(fsetxattr HAVE_FSETXATTR) |
| 945 | CHECK_FUNCTION_EXISTS_GLIBC(getxattr HAVE_GETXATTR) | |
| 946 | CHECK_FUNCTION_EXISTS_GLIBC(lgetxattr HAVE_LGETXATTR) | |
| 947 | CHECK_FUNCTION_EXISTS_GLIBC(listxattr HAVE_LISTXATTR) | |
| 948 | CHECK_FUNCTION_EXISTS_GLIBC(llistxattr HAVE_LLISTXATTR) | |
| 949 | CHECK_FUNCTION_EXISTS_GLIBC(lsetxattr HAVE_LSETXATTR) | |
| ba00b023 BJ |
950 | CHECK_FUNCTION_EXISTS_GLIBC(fgetea HAVE_FGETEA) |
| 951 | CHECK_FUNCTION_EXISTS_GLIBC(flistea HAVE_FLISTEA) | |
| 952 | CHECK_FUNCTION_EXISTS_GLIBC(fsetea HAVE_FSETEA) | |
| 953 | CHECK_FUNCTION_EXISTS_GLIBC(getea HAVE_GETEA) | |
| 954 | CHECK_FUNCTION_EXISTS_GLIBC(lgetea HAVE_LGETEA) | |
| 955 | CHECK_FUNCTION_EXISTS_GLIBC(listea HAVE_LISTEA) | |
| 956 | CHECK_FUNCTION_EXISTS_GLIBC(llistea HAVE_LLISTEA) | |
| 957 | CHECK_FUNCTION_EXISTS_GLIBC(lsetea HAVE_LSETEA) | |
| 6e6742c7 TK |
958 | ELSE(ENABLE_XATTR) |
| 959 | SET(HAVE_ATTR_LIB FALSE) | |
| 960 | SET(HAVE_ATTR_XATTR_H FALSE) | |
| 961 | SET(HAVE_DECL_EXTATTR_NAMESPACE_USER FALSE) | |
| 962 | SET(HAVE_EXTATTR_GET_FILE FALSE) | |
| 963 | SET(HAVE_EXTATTR_LIST_FILE FALSE) | |
| 964 | SET(HAVE_EXTATTR_SET_FD FALSE) | |
| 965 | SET(HAVE_EXTATTR_SET_FILE FALSE) | |
| 966 | SET(HAVE_FGETEA FALSE) | |
| 967 | SET(HAVE_FGETXATTR FALSE) | |
| 968 | SET(HAVE_FLISTEA FALSE) | |
| 969 | SET(HAVE_FLISTXATTR FALSE) | |
| 970 | SET(HAVE_FSETEA FALSE) | |
| 971 | SET(HAVE_FSETXATTR FALSE) | |
| 972 | SET(HAVE_GETEA FALSE) | |
| 973 | SET(HAVE_GETXATTR FALSE) | |
| 974 | SET(HAVE_LGETEA FALSE) | |
| 975 | SET(HAVE_LGETXATTR FALSE) | |
| 976 | SET(HAVE_LISTEA FALSE) | |
| 977 | SET(HAVE_LISTXATTR FALSE) | |
| 978 | SET(HAVE_LLISTEA FALSE) | |
| 979 | SET(HAVE_LLISTXATTR FALSE) | |
| 980 | SET(HAVE_LSETEA FALSE) | |
| 981 | SET(HAVE_LSETXATTR FALSE) | |
| 982 | SET(HAVE_SYS_EXTATTR_H FALSE) | |
| 983 | SET(HAVE_SYS_XATTR_H FALSE) | |
| 806025f2 | 984 | ENDIF(ENABLE_XATTR) |
| 8b7ba998 TK |
985 | |
| 986 | # | |
| 87b05751 | 987 | # Check for ACL libraries, headers, and functions |
| 8b7ba998 TK |
988 | # |
| 989 | # The ACL support in libarchive is written against the POSIX1e draft, | |
| 990 | # which was never officially approved and varies quite a bit across | |
| 991 | # platforms. Worse, some systems have completely non-POSIX acl functions, | |
| 992 | # which makes the following checks rather more complex than I would like. | |
| 993 | # | |
| 806025f2 | 994 | IF(ENABLE_ACL) |
| 4c2b2c54 MN |
995 | CHECK_LIBRARY_EXISTS(acl "acl_get_file" "" HAVE_LIBACL) |
| 996 | IF(HAVE_LIBACL) | |
| 8b7ba998 | 997 | SET(CMAKE_REQUIRED_LIBRARIES "acl") |
| 79150845 TK |
998 | FIND_LIBRARY(ACL_LIBRARY NAMES acl) |
| 999 | LIST(APPEND ADDITIONAL_LIBS ${ACL_LIBRARY}) | |
| 4c2b2c54 | 1000 | ENDIF(HAVE_LIBACL) |
| 8b7ba998 | 1001 | # |
| 950a18b3 TK |
1002 | CHECK_FUNCTION_EXISTS_GLIBC(acl_create_entry HAVE_ACL_CREATE_ENTRY) |
| 1003 | CHECK_FUNCTION_EXISTS_GLIBC(acl_init HAVE_ACL_INIT) | |
| 1004 | CHECK_FUNCTION_EXISTS_GLIBC(acl_set_fd HAVE_ACL_SET_FD) | |
| 1005 | CHECK_FUNCTION_EXISTS_GLIBC(acl_set_fd_np HAVE_ACL_SET_FD_NP) | |
| 1006 | CHECK_FUNCTION_EXISTS_GLIBC(acl_set_file HAVE_ACL_SET_FILE) | |
| 79150845 | 1007 | CHECK_TYPE_EXISTS(acl_permset_t "${INCLUDES}" HAVE_ACL_PERMSET_T) |
| 8b7ba998 TK |
1008 | |
| 1009 | # The "acl_get_perm()" function was omitted from the POSIX draft. | |
| 1010 | # (It's a pretty obvious oversight; otherwise, there's no way to | |
| 1011 | # test for specific permissions in a permset.) Linux uses the obvious | |
| 1012 | # name, FreeBSD adds _np to mark it as "non-Posix extension." | |
| 1013 | # Test for both as a double-check that we really have POSIX-style ACL support. | |
| ca58a31d TK |
1014 | CHECK_FUNCTION_EXISTS(acl_get_perm HAVE_ACL_GET_PERM) |
| 1015 | CHECK_FUNCTION_EXISTS(acl_get_perm_np HAVE_ACL_GET_PERM_NP) | |
| 1016 | CHECK_FUNCTION_EXISTS(acl_get_link HAVE_ACL_GET_LINK) | |
| 1017 | CHECK_FUNCTION_EXISTS(acl_get_link_np HAVE_ACL_GET_LINK_NP) | |
| 8b7ba998 TK |
1018 | |
| 1019 | # MacOS has an acl.h that isn't POSIX. It can be detected by | |
| 1020 | # checking for ACL_USER | |
| 79150845 | 1021 | CHECK_SYMBOL_EXISTS(ACL_USER "${INCLUDES}" HAVE_ACL_USER) |
| 6e6742c7 TK |
1022 | ELSE(ENABLE_ACL) |
| 1023 | # If someone runs cmake, then disables ACL support, we need | |
| 1024 | # to forcibly override the cached values for these. | |
| 1025 | SET(HAVE_ACL_CREATE_ENTRY FALSE) | |
| 1026 | SET(HAVE_ACL_GET_LINK FALSE) | |
| 1027 | SET(HAVE_ACL_GET_LINK_NP FALSE) | |
| 1028 | SET(HAVE_ACL_GET_PERM FALSE) | |
| 1029 | SET(HAVE_ACL_GET_PERM_NP FALSE) | |
| 1030 | SET(HAVE_ACL_INIT FALSE) | |
| 1031 | SET(HAVE_ACL_LIB FALSE) | |
| 1032 | SET(HAVE_ACL_PERMSET_T FALSE) | |
| 1033 | SET(HAVE_ACL_SET_FD FALSE) | |
| 1034 | SET(HAVE_ACL_SET_FD_NP FALSE) | |
| 1035 | SET(HAVE_ACL_SET_FILE FALSE) | |
| 1036 | SET(HAVE_ACL_USER FALSE) | |
| 806025f2 | 1037 | ENDIF(ENABLE_ACL) |
| 8b7ba998 | 1038 | |
| 968a8126 | 1039 | # Generate "config.h" from "build/cmake/config.h.in" |
| 23c96a24 | 1040 | CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/cmake/config.h.in |
| 806025f2 | 1041 | ${CMAKE_CURRENT_BINARY_DIR}/config.h) |
| 5a1e844e | 1042 | INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_BINARY_DIR}) |
| 3133e6d6 | 1043 | ADD_DEFINITIONS(-DHAVE_CONFIG_H) |
| 8b7ba998 | 1044 | |
| 2753f77f MN |
1045 | # |
| 1046 | # Register installation of PDF documents. | |
| 1047 | # | |
| 1048 | IF(WIN32 AND NOT CYGWIN) | |
| 1049 | # | |
| 1050 | # On Windows platform, It's better that we install PDF documents | |
| 1051 | # on one's computer. | |
| 1052 | # These PDF documents are available in the release package. | |
| 1053 | # | |
| 1054 | IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf) | |
| 1055 | INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf | |
| 1056 | DESTINATION share/man | |
| 1057 | FILES_MATCHING PATTERN "*.pdf" | |
| 1058 | ) | |
| 1059 | ENDIF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doc/pdf) | |
| 1060 | ENDIF(WIN32 AND NOT CYGWIN) | |
| 8b7ba998 | 1061 | # |
| 8b7ba998 | 1062 | # |
| 968a8126 | 1063 | # |
| d5dd1e70 | 1064 | INCLUDE_DIRECTORIES(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/libarchive) |
| 8b7ba998 TK |
1065 | # |
| 1066 | IF(MSVC) | |
| 63bbbfa2 | 1067 | ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE) |
| 8b7ba998 | 1068 | ENDIF(MSVC) |
| 8b7ba998 | 1069 | |
| 29e7a83d | 1070 | # We need CoreServices on Mac OS. |
| 3def082c | 1071 | IF(APPLE) |
| 29e7a83d | 1072 | LIST(APPEND ADDITIONAL_LIBS "-framework CoreServices") |
| 3def082c MN |
1073 | ENDIF(APPLE) |
| 1074 | ||
| 4427c8a5 | 1075 | IF(ENABLE_TEST) |
| df401b4a | 1076 | ADD_CUSTOM_TARGET(run_all_tests) |
| 4427c8a5 | 1077 | ENDIF(ENABLE_TEST) |
| 0f7a479b | 1078 | |
| 968a8126 MN |
1079 | add_subdirectory(libarchive) |
| 1080 | add_subdirectory(tar) | |
| 1081 | add_subdirectory(cpio) |