2009-04-02 09:14:53 -04:00
# cURL/libcurl CMake script
# by [PUT YOUR REAL NAME TETEST!] and Sukender (Benoit Neil)
# TODO:
2009-04-07 17:00:50 -04:00
# The output .so file lacks the soname number which we currently have within the lib/Makefile.am file
2009-04-06 16:44:01 -04:00
# Add full (4 or 5 libs) SSL support
2009-04-07 18:49:02 -04:00
# Add INSTALL target (EXTRA_DIST variables in Makefile.am may be moved to Makefile.inc so that CMake/CPack is aware of what's to include).
2009-04-07 17:00:50 -04:00
# Add CTests(?)
2009-04-06 16:44:01 -04:00
# Check on all possible platforms
# Test with as many configurations possible (With or without any option)
2009-04-07 17:00:50 -04:00
# Create scripts that help keeping the CMake build system up to date (to reduce maintenance). According to Tetetest:
# - lists of headers that 'configure' checks for;
# - curl-specific tests (the ones that are in m4/curl-*.m4 files);
# - (most obvious thing:) curl version numbers.
2009-04-02 09:14:53 -04:00
# Add documentation subproject
2009-04-07 17:00:50 -04:00
#
# To check:
# (From Daniel Stenberg) The cmake build selected to run gcc with -fPIC on my box while the plain configure script did not.
# (From Daniel Stenberg) The gcc command line use neither -g nor any -O options. As a developer, I also treasure our configure scripts's --enable-debug option that sets a long range of "picky" compiler options.
2009-04-02 09:14:53 -04:00
CMAKE_MINIMUM_REQUIRED ( VERSION 2.6.2 FATAL_ERROR )
SET ( CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}" )
project ( CURL C )
SET ( CURL_MAJOR_VERSION 7 )
SET ( CURL_MINOR_VERSION 19 )
SET ( CURL_PATCH_VERSION 4 )
INCLUDE_REGULAR_EXPRESSION ( "^.*$" ) # Sukender: Is it necessary?
# Setup package meta-data
# SET(PACKAGE "curl")
SET ( CURL_VERSION ${ CURL_MAJOR_VERSION } . ${ CURL_MINOR_VERSION } . ${ CURL_PATCH_VERSION } )
# SET(PACKAGE_TARNAME "curl")
# SET(PACKAGE_NAME "curl")
# SET(PACKAGE_VERSION "-")
# SET(PACKAGE_STRING "curl-")
# SET(PACKAGE_BUGREPORT "a suitable curl mailing list => http://curl.haxx.se/mail/")
SET ( OPERATING_SYSTEM "${CMAKE_SYSTEM_NAME}" )
SET ( OS "\" ${ CMAKE_SYSTEM_NAME } \"")
# Make the base headers visible to everything
# IF(NOT ${PROJECT_BINARY_DIR} EQUAL ${PROJECT_SOURCE_DIR})
# INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR}/include)
# ENDIF()
INCLUDE_DIRECTORIES ( ${ CURL_SOURCE_DIR } /include )
# Save C and CXX STD libs (we may need to modify them)
IF ( NOT CURL_CONFIG_HAS_BEEN_RUN_BEFORE )
2009-04-06 15:22:31 -04:00
SET ( CMAKE_CXX_STANDARD_LIBRARIES_INIT ${ CMAKE_CXX_STANDARD_LIBRARIES } CACHE INTERNAL "Initial C++ libs" )
SET ( CMAKE_C_STANDARD_LIBRARIES_INIT ${ CMAKE_C_STANDARD_LIBRARIES } CACHE INTERNAL "Initial C libs" )
2009-04-02 09:14:53 -04:00
ENDIF ( )
IF ( WIN32 )
SET ( NATIVE_WINDOWS ON )
ENDIF ( )
OPTION ( BUILD_CURL_EXE "Set to ON to build cURL executable." ON )
OPTION ( BUILD_CURL_TESTS "Set to ON to build cURL tests." ON )
OPTION ( CURL_STATICLIB "Set to ON to build libcurl with static linking." OFF )
IF ( MSVC )
OPTION ( BUILD_RELEASE_DEBUG_DIRS "Set OFF to build each configuration to a separate directory" OFF )
MARK_AS_ADVANCED ( BUILD_RELEASE_DEBUG_DIRS )
ENDIF ( )
2009-04-07 17:00:50 -04:00
OPTION ( CURL_HIDDEN_SYMBOLS "Set to ON to build libcurl with internal symbols exported." OFF )
MARK_AS_ADVANCED ( CURL_HIDDEN_SYMBOLS )
2009-04-02 09:14:53 -04:00
# IF(WIN32)
# OPTION(CURL_WINDOWS_SSPI "Use windows libraries to allow NTLM authentication without openssl" ON)
# MARK_AS_ADVANCED(CURL_WINDOWS_SSPI)
# ENDIF()
OPTION ( HTTP_ONLY "disables all protocols except HTTP (This overrides all CURL_DISABLE_* options)" OFF )
MARK_AS_ADVANCED ( HTTP_ONLY )
OPTION ( CURL_DISABLE_FTP "disables FTP" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_FTP )
OPTION ( CURL_DISABLE_LDAP "disables LDAP" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_LDAP )
OPTION ( CURL_DISABLE_TELNET "disables Telnet" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_TELNET )
OPTION ( CURL_DISABLE_DICT "disables DICT" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_DICT )
OPTION ( CURL_DISABLE_FILE "disables FILE" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_FILE )
OPTION ( CURL_DISABLE_TFTP "disables TFTP" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_TFTP )
OPTION ( CURL_DISABLE_HTTP "disables HTTP" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_HTTP )
OPTION ( CURL_DISABLE_LDAPS "to disable LDAPS" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_LDAPS )
IF ( WIN32 )
SET ( CURL_LDAP_HYBRID OFF )
OPTION ( CURL_LDAP_WIN "Use W$ LDAP implementation" ON )
MARK_AS_ADVANCED ( CURL_LDAP_WIN )
ELSE ( )
OPTION ( CURL_LDAP_HYBRID "W$ LDAP with non-W$ compiler" OFF )
MARK_AS_ADVANCED ( CURL_LDAP_HYBRID )
SET ( CURL_LDAP_WIN OFF )
ENDIF ( )
IF ( HTTP_ONLY )
SET ( CURL_DISABLE_FTP ON )
SET ( CURL_DISABLE_LDAP ON )
SET ( CURL_DISABLE_TELNET ON )
SET ( CURL_DISABLE_DICT ON )
SET ( CURL_DISABLE_FILE ON )
SET ( CURL_DISABLE_TFTP ON )
ENDIF ( )
OPTION ( CURL_DISABLE_COOKIES "to disable cookies support" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_COOKIES )
OPTION ( CURL_DISABLE_CRYPTO_AUTH "to disable cryptographic authentication" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_CRYPTO_AUTH )
OPTION ( CURL_DISABLE_VERBOSE_STRINGS "to disable verbose strings" OFF )
MARK_AS_ADVANCED ( CURL_DISABLE_VERBOSE_STRINGS )
OPTION ( DISABLED_THREADSAFE "Set to explicitly specify we don't want to use thread-safe functions" OFF )
MARK_AS_ADVANCED ( DISABLED_THREADSAFE )
OPTION ( ENABLE_IPV6 "Define if you want to enable IPv6 support" OFF )
MARK_AS_ADVANCED ( ENABLE_IPV6 )
IF ( WIN32 )
IF ( CURL_DISABLE_LDAP )
#SET(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES} wsock32.lib bufferoverflowu.lib ws2_32.lib" CACHE STRING "" FORCE)
2009-04-06 15:22:31 -04:00
#SET(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES} wsock32.lib bufferoverflowu.lib ws2_32.lib" CACHE STRING "" FORCE)
SET ( CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES} wsock32.lib ws2_32.lib" CACHE STRING "" FORCE )
2009-04-02 09:14:53 -04:00
ELSE ( )
#SET(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES} wsock32.lib bufferoverflowu.lib ws2_32.lib wldap32.lib" CACHE STRING "" FORCE)
2009-04-06 15:22:31 -04:00
#SET(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES} wsock32.lib bufferoverflowu.lib ws2_32.lib wldap32.lib" CACHE STRING "" FORCE)
SET ( CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES} wsock32.lib ws2_32.lib wldap32.lib" CACHE STRING "" FORCE )
2009-04-02 09:14:53 -04:00
ENDIF ( )
ENDIF ( )
# We need ansi c-flags, especially on HP
SET ( CMAKE_C_FLAGS "${CMAKE_ANSI_CFLAGS} ${CMAKE_C_FLAGS}" )
SET ( CMAKE_REQUIRED_FLAGS ${ CMAKE_ANSI_CFLAGS } )
# Disable warnings on Borland to avoid changing 3rd party code.
IF ( BORLAND )
SET ( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w-" )
ENDIF ( BORLAND )
# If we are on AIX, do the _ALL_SOURCE magic
IF ( ${ CMAKE_SYSTEM_NAME } MATCHES AIX )
SET ( _ALL_SOURCE 1 )
ENDIF ( ${ CMAKE_SYSTEM_NAME } MATCHES AIX )
# Include all the necessary files for macros
INCLUDE ( CheckFunctionExists )
INCLUDE ( CheckIncludeFile )
INCLUDE ( CheckIncludeFiles )
INCLUDE ( CheckLibraryExists )
INCLUDE ( CheckSymbolExists )
# if crosscompiling is on, the CHECK_TYPE_SIZE macro coming with cmake uses
# TRY_COMPILE instead of TRY_RUN which makes crosscompiling easier, Alex
IF ( CMAKE_CROSSCOMPILING )
INCLUDE ( "${CMAKE_MODULE_PATH}/CheckTypeSize.cmake" )
ELSE ( CMAKE_CROSSCOMPILING )
INCLUDE ( CheckTypeSize )
ENDIF ( CMAKE_CROSSCOMPILING )
# On windows preload settings
IF ( WIN32 )
INCLUDE ( ${ CMAKE_CURRENT_SOURCE_DIR } /CMake/Platforms/WindowsCache.cmake )
ENDIF ( WIN32 )
# This macro checks if the symbol exists in the library and if it
# does, it appends library to the list.
SET ( CURL_LIBS "" )
MACRO ( CHECK_LIBRARY_EXISTS_CONCAT LIBRARY SYMBOL VARIABLE )
CHECK_LIBRARY_EXISTS ( "${LIBRARY};${CURL_LIBS}" ${ SYMBOL } ""
$ { V A R I A B L E } )
IF ( ${ VARIABLE } )
SET ( CURL_LIBS ${ CURL_LIBS } ${ LIBRARY } )
ENDIF ( ${ VARIABLE } )
ENDMACRO ( CHECK_LIBRARY_EXISTS_CONCAT )
# Check for all needed libraries
CHECK_LIBRARY_EXISTS_CONCAT ( "dl" dlopen HAVE_LIBDL )
#CHECK_LIBRARY_EXISTS_CONCAT("ucb" gethostname HAVE_LIBUCB)
CHECK_LIBRARY_EXISTS_CONCAT ( "socket" connect HAVE_LIBSOCKET )
CHECK_LIBRARY_EXISTS ( "c" gethostbyname "" NOT_NEED_LIBNSL )
# Yellowtab Zeta needs different libraries than BeOS 5.
IF ( BEOS )
SET ( NOT_NEED_LIBNSL 1 )
CHECK_LIBRARY_EXISTS_CONCAT ( "bind" gethostbyname HAVE_LIBBIND )
CHECK_LIBRARY_EXISTS_CONCAT ( "bnetapi" closesocket HAVE_LIBBNETAPI )
ENDIF ( BEOS )
IF ( NOT NOT_NEED_LIBNSL )
CHECK_LIBRARY_EXISTS_CONCAT ( "nsl" gethostbyname HAVE_LIBNSL )
ENDIF ( NOT NOT_NEED_LIBNSL )
CHECK_LIBRARY_EXISTS_CONCAT ( "ws2_32" getch HAVE_LIBWS2_32 )
CHECK_LIBRARY_EXISTS_CONCAT ( "winmm" getch HAVE_LIBWINMM )
# IF(NOT CURL_SPECIAL_LIBZ)
# CHECK_LIBRARY_EXISTS_CONCAT("z" inflateEnd HAVE_LIBZ)
# ENDIF(NOT CURL_SPECIAL_LIBZ)
OPTION ( CMAKE_USE_OPENSSL "Use OpenSSL code. Experimental" ON )
MARK_AS_ADVANCED ( CMAKE_USE_OPENSSL )
IF ( CMAKE_USE_OPENSSL )
2009-04-02 19:12:22 -04:00
IF ( WIN32 )
FIND_PACKAGE ( OpenSSL )
IF ( OPENSSL_FOUND )
SET ( USE_SSLEAY TRUE )
SET ( USE_OPENSSL TRUE )
LIST ( APPEND CURL_LIBS ${ OPENSSL_LIBRARIES } )
ENDIF ( )
#FIND_LIBRARY(LIBEAY NAMES libeay32)
#LIST(APPEND CURL_LIBS ${LIBEAY} )
ELSE ( WIN32 )
CHECK_LIBRARY_EXISTS_CONCAT ( "crypto" CRYPTO_lock HAVE_LIBCRYPTO )
CHECK_LIBRARY_EXISTS_CONCAT ( "ssl" SSL_connect HAVE_LIBSSL )
ENDIF ( WIN32 )
2009-04-02 09:14:53 -04:00
ENDIF ( CMAKE_USE_OPENSSL )
# Check for idn
CHECK_LIBRARY_EXISTS_CONCAT ( "idn" idna_to_ascii_lz HAVE_LIBIDN )
# Check for LDAP
CHECK_LIBRARY_EXISTS_CONCAT ( "ldap" ldap_init HAVE_LIBLDAP )
# if(NOT HAVE_LIBLDAP)
# SET(CURL_DISABLE_LDAP ON)
# endif(NOT HAVE_LIBLDAP)
# Check for symbol dlopen (same as HAVE_LIBDL)
CHECK_LIBRARY_EXISTS ( "${CURL_LIBS}" dlopen "" HAVE_DLOPEN )
# For other tests to use the same libraries
SET ( CMAKE_REQUIRED_LIBRARIES ${ CURL_LIBS } )
OPTION ( CURL_ZLIB "Set to ON to enable building cURL with zlib support." ON )
SET ( HAVE_LIBZ OFF )
SET ( HAVE_ZLIB_H OFF )
SET ( HAVE_ZLIB OFF )
IF ( CURL_ZLIB ) # AND CURL_CONFIG_HAS_BEEN_RUN_BEFORE
FIND_PACKAGE ( ZLIB )
IF ( ZLIB_FOUND )
SET ( HAVE_ZLIB_H ON )
SET ( HAVE_ZLIB ON )
SET ( HAVE_LIBZ ON )
ENDIF ( )
ENDIF ( )
# If we have features.h, then do the _BSD_SOURCE magic
CHECK_INCLUDE_FILE ( "features.h" HAVE_FEATURES_H )
# Check if header file exists and add it to the list.
MACRO ( CHECK_INCLUDE_FILE_CONCAT FILE VARIABLE )
CHECK_INCLUDE_FILES ( "${CURL_INCLUDES};${FILE}" ${ VARIABLE } )
IF ( ${ VARIABLE } )
SET ( CURL_INCLUDES ${ CURL_INCLUDES } ${ FILE } )
SET ( CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -D${VARIABLE}" )
ENDIF ( ${ VARIABLE } )
ENDMACRO ( CHECK_INCLUDE_FILE_CONCAT )
# Check for header files
IF ( NOT UNIX )
CHECK_INCLUDE_FILE_CONCAT ( "ws2tcpip.h" HAVE_WS2TCPIP_H )
CHECK_INCLUDE_FILE_CONCAT ( "winsock2.h" HAVE_WINSOCK2_H )
ENDIF ( NOT UNIX )
CHECK_INCLUDE_FILE_CONCAT ( "stdio.h" HAVE_STDIO_H )
IF ( NOT UNIX )
CHECK_INCLUDE_FILE_CONCAT ( "windows.h" HAVE_WINDOWS_H )
CHECK_INCLUDE_FILE_CONCAT ( "winsock.h" HAVE_WINSOCK_H )
ENDIF ( NOT UNIX )
CHECK_INCLUDE_FILE_CONCAT ( "inttypes.h" HAVE_INTTYPES_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/filio.h" HAVE_SYS_FILIO_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/ioctl.h" HAVE_SYS_IOCTL_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/param.h" HAVE_SYS_PARAM_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/poll.h" HAVE_SYS_POLL_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/resource.h" HAVE_SYS_RESOURCE_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/select.h" HAVE_SYS_SELECT_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/socket.h" HAVE_SYS_SOCKET_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/sockio.h" HAVE_SYS_SOCKIO_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/stat.h" HAVE_SYS_STAT_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/time.h" HAVE_SYS_TIME_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/types.h" HAVE_SYS_TYPES_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/uio.h" HAVE_SYS_UIO_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/un.h" HAVE_SYS_UN_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/utime.h" HAVE_SYS_UTIME_H )
CHECK_INCLUDE_FILE_CONCAT ( "alloca.h" HAVE_ALLOCA_H )
CHECK_INCLUDE_FILE_CONCAT ( "arpa/inet.h" HAVE_ARPA_INET_H )
CHECK_INCLUDE_FILE_CONCAT ( "arpa/tftp.h" HAVE_ARPA_TFTP_H )
CHECK_INCLUDE_FILE_CONCAT ( "assert.h" HAVE_ASSERT_H )
CHECK_INCLUDE_FILE_CONCAT ( "crypto.h" HAVE_CRYPTO_H )
CHECK_INCLUDE_FILE_CONCAT ( "des.h" HAVE_DES_H )
CHECK_INCLUDE_FILE_CONCAT ( "err.h" HAVE_ERR_H )
CHECK_INCLUDE_FILE_CONCAT ( "errno.h" HAVE_ERRNO_H )
CHECK_INCLUDE_FILE_CONCAT ( "fcntl.h" HAVE_FCNTL_H )
CHECK_INCLUDE_FILE_CONCAT ( "gssapi/gssapi.h" HAVE_GSSAPI_GSSAPI_H )
CHECK_INCLUDE_FILE_CONCAT ( "gssapi/gssapi_generic.h" HAVE_GSSAPI_GSSAPI_GENERIC_H )
CHECK_INCLUDE_FILE_CONCAT ( "gssapi/gssapi_krb5.h" HAVE_GSSAPI_GSSAPI_KRB5_H )
CHECK_INCLUDE_FILE_CONCAT ( "idn-free.h" HAVE_IDN_FREE_H )
CHECK_INCLUDE_FILE_CONCAT ( "ifaddrs.h" HAVE_IFADDRS_H )
CHECK_INCLUDE_FILE_CONCAT ( "io.h" HAVE_IO_H )
CHECK_INCLUDE_FILE_CONCAT ( "krb.h" HAVE_KRB_H )
CHECK_INCLUDE_FILE_CONCAT ( "libgen.h" HAVE_LIBGEN_H )
CHECK_INCLUDE_FILE_CONCAT ( "libssh2.h" HAVE_LIBSSH2_H )
CHECK_INCLUDE_FILE_CONCAT ( "limits.h" HAVE_LIMITS_H )
CHECK_INCLUDE_FILE_CONCAT ( "locale.h" HAVE_LOCALE_H )
CHECK_INCLUDE_FILE_CONCAT ( "net/if.h" HAVE_NET_IF_H )
CHECK_INCLUDE_FILE_CONCAT ( "netdb.h" HAVE_NETDB_H )
CHECK_INCLUDE_FILE_CONCAT ( "netinet/in.h" HAVE_NETINET_IN_H )
CHECK_INCLUDE_FILE_CONCAT ( "netinet/tcp.h" HAVE_NETINET_TCP_H )
CHECK_INCLUDE_FILE_CONCAT ( "openssl/crypto.h" HAVE_OPENSSL_CRYPTO_H )
CHECK_INCLUDE_FILE_CONCAT ( "openssl/engine.h" HAVE_OPENSSL_ENGINE_H )
CHECK_INCLUDE_FILE_CONCAT ( "openssl/err.h" HAVE_OPENSSL_ERR_H )
CHECK_INCLUDE_FILE_CONCAT ( "openssl/pem.h" HAVE_OPENSSL_PEM_H )
CHECK_INCLUDE_FILE_CONCAT ( "openssl/pkcs12.h" HAVE_OPENSSL_PKCS12_H )
CHECK_INCLUDE_FILE_CONCAT ( "openssl/rsa.h" HAVE_OPENSSL_RSA_H )
CHECK_INCLUDE_FILE_CONCAT ( "openssl/ssl.h" HAVE_OPENSSL_SSL_H )
CHECK_INCLUDE_FILE_CONCAT ( "openssl/x509.h" HAVE_OPENSSL_X509_H )
CHECK_INCLUDE_FILE_CONCAT ( "pem.h" HAVE_PEM_H )
CHECK_INCLUDE_FILE_CONCAT ( "poll.h" HAVE_POLL_H )
CHECK_INCLUDE_FILE_CONCAT ( "pwd.h" HAVE_PWD_H )
CHECK_INCLUDE_FILE_CONCAT ( "rsa.h" HAVE_RSA_H )
CHECK_INCLUDE_FILE_CONCAT ( "setjmp.h" HAVE_SETJMP_H )
CHECK_INCLUDE_FILE_CONCAT ( "sgtty.h" HAVE_SGTTY_H )
CHECK_INCLUDE_FILE_CONCAT ( "signal.h" HAVE_SIGNAL_H )
CHECK_INCLUDE_FILE_CONCAT ( "ssl.h" HAVE_SSL_H )
CHECK_INCLUDE_FILE_CONCAT ( "stdbool.h" HAVE_STDBOOL_H )
CHECK_INCLUDE_FILE_CONCAT ( "stdint.h" HAVE_STDINT_H )
CHECK_INCLUDE_FILE_CONCAT ( "stdio.h" HAVE_STDIO_H )
CHECK_INCLUDE_FILE_CONCAT ( "stdlib.h" HAVE_STDLIB_H )
CHECK_INCLUDE_FILE_CONCAT ( "string.h" HAVE_STRING_H )
CHECK_INCLUDE_FILE_CONCAT ( "strings.h" HAVE_STRINGS_H )
CHECK_INCLUDE_FILE_CONCAT ( "stropts.h" HAVE_STROPTS_H )
CHECK_INCLUDE_FILE_CONCAT ( "termio.h" HAVE_TERMIO_H )
CHECK_INCLUDE_FILE_CONCAT ( "termios.h" HAVE_TERMIOS_H )
CHECK_INCLUDE_FILE_CONCAT ( "time.h" HAVE_TIME_H )
CHECK_INCLUDE_FILE_CONCAT ( "tld.h" HAVE_TLD_H )
CHECK_INCLUDE_FILE_CONCAT ( "unistd.h" HAVE_UNISTD_H )
CHECK_INCLUDE_FILE_CONCAT ( "utime.h" HAVE_UTIME_H )
CHECK_INCLUDE_FILE_CONCAT ( "x509.h" HAVE_X509_H )
CHECK_INCLUDE_FILE_CONCAT ( "process.h" HAVE_PROCESS_H )
CHECK_INCLUDE_FILE_CONCAT ( "stddef.h" HAVE_STDDEF_H )
CHECK_INCLUDE_FILE_CONCAT ( "dlfcn.h" HAVE_DLFCN_H )
CHECK_INCLUDE_FILE_CONCAT ( "malloc.h" HAVE_MALLOC_H )
CHECK_INCLUDE_FILE_CONCAT ( "memory.h" HAVE_MEMORY_H )
CHECK_INCLUDE_FILE_CONCAT ( "ldap.h" HAVE_LDAP_H )
CHECK_INCLUDE_FILE_CONCAT ( "netinet/if_ether.h" HAVE_NETINET_IF_ETHER_H )
CHECK_INCLUDE_FILE_CONCAT ( "stdint.h" HAVE_STDINT_H )
CHECK_INCLUDE_FILE_CONCAT ( "sockio.h" HAVE_SOCKIO_H )
CHECK_INCLUDE_FILE_CONCAT ( "sys/utsname.h" HAVE_SYS_UTSNAME_H )
CHECK_INCLUDE_FILE_CONCAT ( "idna.h" HAVE_IDNA_H )
IF ( CMAKE_USE_OPENSSL )
CHECK_INCLUDE_FILE_CONCAT ( "openssl/rand.h" HAVE_OPENSSL_RAND_H )
ENDIF ( CMAKE_USE_OPENSSL )
CHECK_TYPE_SIZE ( size_t SIZEOF_SIZE_T )
CHECK_TYPE_SIZE ( ssize_t SIZEOF_SSIZE_T )
CHECK_TYPE_SIZE ( "long long" SIZEOF_LONG_LONG )
CHECK_TYPE_SIZE ( "long" SIZEOF_LONG )
2009-04-07 17:00:50 -04:00
CHECK_TYPE_SIZE ( "int" SIZEOF_INT )
2009-04-02 09:14:53 -04:00
CHECK_TYPE_SIZE ( "__int64" SIZEOF___INT64 )
CHECK_TYPE_SIZE ( "long double" SIZEOF_LONG_DOUBLE )
CHECK_TYPE_SIZE ( "time_t" SIZEOF_TIME_T )
IF ( NOT HAVE_SIZEOF_SSIZE_T )
IF ( SIZEOF_LONG EQUAL SIZEOF_SIZE_T )
SET ( ssize_t long )
ENDIF ( SIZEOF_LONG EQUAL SIZEOF_SIZE_T )
IF ( NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T )
SET ( ssize_t __int64 )
ENDIF ( NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T )
ENDIF ( NOT HAVE_SIZEOF_SSIZE_T )
# Different sizeofs, etc.
# define CURL_SIZEOF_LONG 4
# define CURL_TYPEOF_CURL_OFF_T long long
# define CURL_FORMAT_CURL_OFF_T "lld"
# define CURL_FORMAT_CURL_OFF_TU "llu"
# define CURL_FORMAT_OFF_T "%lld"
# define CURL_SIZEOF_CURL_OFF_T 8
# define CURL_SUFFIX_CURL_OFF_T LL
# define CURL_SUFFIX_CURL_OFF_TU ULL
set ( CURL_SIZEOF_LONG ${ SIZEOF_LONG } )
if ( SIZEOF_LONG EQUAL 8 )
set ( CURL_TYPEOF_CURL_OFF_T long )
set ( CURL_SIZEOF_CURL_OFF_T 8 )
set ( CURL_FORMAT_CURL_OFF_T "ld" )
set ( CURL_FORMAT_CURL_OFF_TU "lu" )
set ( CURL_FORMAT_OFF_T "%ld" )
set ( CURL_SUFFIX_CURL_OFF_T L )
set ( CURL_SUFFIX_CURL_OFF_TU LU )
endif ( SIZEOF_LONG EQUAL 8 )
if ( SIZEOF_LONG_LONG EQUAL 8 )
set ( CURL_TYPEOF_CURL_OFF_T "long long" )
set ( CURL_SIZEOF_CURL_OFF_T 8 )
set ( CURL_FORMAT_CURL_OFF_T "lld" )
set ( CURL_FORMAT_CURL_OFF_TU "llu" )
set ( CURL_FORMAT_OFF_T "%lld" )
set ( CURL_SUFFIX_CURL_OFF_T LL )
set ( CURL_SUFFIX_CURL_OFF_TU LLU )
endif ( SIZEOF_LONG_LONG EQUAL 8 )
if ( NOT CURL_TYPEOF_CURL_OFF_T )
set ( CURL_TYPEOF_CURL_OFF_T ${ ssize_t } )
set ( CURL_SIZEOF_CURL_OFF_T ${ SIZEOF_SSIZE_T } )
# TODO: need adjustment here.
set ( CURL_FORMAT_CURL_OFF_T "ld" )
set ( CURL_FORMAT_CURL_OFF_TU "lu" )
set ( CURL_FORMAT_OFF_T "%ld" )
set ( CURL_SUFFIX_CURL_OFF_T L )
set ( CURL_SUFFIX_CURL_OFF_TU LU )
endif ( NOT CURL_TYPEOF_CURL_OFF_T )
IF ( HAVE_SIZEOF_LONG_LONG )
SET ( HAVE_LONGLONG 1 )
SET ( HAVE_LL 1 )
ENDIF ( HAVE_SIZEOF_LONG_LONG )
FIND_FILE ( RANDOM_FILE urandom /dev )
MARK_AS_ADVANCED ( RANDOM_FILE )
# Check for some functions that are used
CHECK_SYMBOL_EXISTS ( basename "${CURL_INCLUDES}" HAVE_BASENAME )
CHECK_SYMBOL_EXISTS ( socket "${CURL_INCLUDES}" HAVE_SOCKET )
CHECK_SYMBOL_EXISTS ( poll "${CURL_INCLUDES}" HAVE_POLL )
CHECK_SYMBOL_EXISTS ( select "${CURL_INCLUDES}" HAVE_SELECT )
CHECK_SYMBOL_EXISTS ( strdup "${CURL_INCLUDES}" HAVE_STRDUP )
CHECK_SYMBOL_EXISTS ( strstr "${CURL_INCLUDES}" HAVE_STRSTR )
CHECK_SYMBOL_EXISTS ( strtok_r "${CURL_INCLUDES}" HAVE_STRTOK_R )
CHECK_SYMBOL_EXISTS ( strftime "${CURL_INCLUDES}" HAVE_STRFTIME )
CHECK_SYMBOL_EXISTS ( uname "${CURL_INCLUDES}" HAVE_UNAME )
CHECK_SYMBOL_EXISTS ( strcasecmp "${CURL_INCLUDES}" HAVE_STRCASECMP )
CHECK_SYMBOL_EXISTS ( stricmp "${CURL_INCLUDES}" HAVE_STRICMP )
CHECK_SYMBOL_EXISTS ( strcmpi "${CURL_INCLUDES}" HAVE_STRCMPI )
CHECK_SYMBOL_EXISTS ( strncmpi "${CURL_INCLUDES}" HAVE_STRNCMPI )
CHECK_SYMBOL_EXISTS ( alarm "${CURL_INCLUDES}" HAVE_ALARM )
IF ( NOT HAVE_STRNCMPI )
SET ( HAVE_STRCMPI )
ENDIF ( NOT HAVE_STRNCMPI )
CHECK_SYMBOL_EXISTS ( gethostbyaddr "${CURL_INCLUDES}" HAVE_GETHOSTBYADDR )
CHECK_SYMBOL_EXISTS ( gethostbyaddr_r "${CURL_INCLUDES}" HAVE_GETHOSTBYADDR_R )
CHECK_SYMBOL_EXISTS ( gettimeofday "${CURL_INCLUDES}" HAVE_GETTIMEOFDAY )
CHECK_SYMBOL_EXISTS ( inet_addr "${CURL_INCLUDES}" HAVE_INET_ADDR )
CHECK_SYMBOL_EXISTS ( inet_ntoa "${CURL_INCLUDES}" HAVE_INET_NTOA )
CHECK_SYMBOL_EXISTS ( inet_ntoa_r "${CURL_INCLUDES}" HAVE_INET_NTOA_R )
CHECK_SYMBOL_EXISTS ( tcsetattr "${CURL_INCLUDES}" HAVE_TCSETATTR )
CHECK_SYMBOL_EXISTS ( tcgetattr "${CURL_INCLUDES}" HAVE_TCGETATTR )
CHECK_SYMBOL_EXISTS ( perror "${CURL_INCLUDES}" HAVE_PERROR )
CHECK_SYMBOL_EXISTS ( closesocket "${CURL_INCLUDES}" HAVE_CLOSESOCKET )
CHECK_SYMBOL_EXISTS ( setvbuf "${CURL_INCLUDES}" HAVE_SETVBUF )
CHECK_SYMBOL_EXISTS ( sigsetjmp "${CURL_INCLUDES}" HAVE_SIGSETJMP )
CHECK_SYMBOL_EXISTS ( getpass_r "${CURL_INCLUDES}" HAVE_GETPASS_R )
CHECK_SYMBOL_EXISTS ( strlcat "${CURL_INCLUDES}" HAVE_STRLCAT )
CHECK_SYMBOL_EXISTS ( getpwuid "${CURL_INCLUDES}" HAVE_GETPWUID )
CHECK_SYMBOL_EXISTS ( geteuid "${CURL_INCLUDES}" HAVE_GETEUID )
CHECK_SYMBOL_EXISTS ( utime "${CURL_INCLUDES}" HAVE_UTIME )
IF ( CMAKE_USE_OPENSSL )
CHECK_SYMBOL_EXISTS ( RAND_status "${CURL_INCLUDES}" HAVE_RAND_STATUS )
CHECK_SYMBOL_EXISTS ( RAND_screen "${CURL_INCLUDES}" HAVE_RAND_SCREEN )
CHECK_SYMBOL_EXISTS ( RAND_egd "${CURL_INCLUDES}" HAVE_RAND_EGD )
CHECK_SYMBOL_EXISTS ( CRYPTO_cleanup_all_ex_data "${CURL_INCLUDES}"
H A V E _ C R Y P T O _ C L E A N U P _ A L L _ E X _ D A T A )
IF ( HAVE_LIBCRYPTO AND HAVE_LIBSSL )
SET ( USE_OPENSSL 1 )
SET ( USE_SSLEAY 1 )
ENDIF ( HAVE_LIBCRYPTO AND HAVE_LIBSSL )
ENDIF ( CMAKE_USE_OPENSSL )
CHECK_SYMBOL_EXISTS ( gmtime_r "${CURL_INCLUDES}" HAVE_GMTIME_R )
CHECK_SYMBOL_EXISTS ( localtime_r "${CURL_INCLUDES}" HAVE_LOCALTIME_R )
CHECK_SYMBOL_EXISTS ( gethostbyname "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME )
CHECK_SYMBOL_EXISTS ( gethostbyname_r "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME_R )
CHECK_SYMBOL_EXISTS ( signal "${CURL_INCLUDES}" HAVE_SIGNAL_FUNC )
CHECK_SYMBOL_EXISTS ( SIGALRM "${CURL_INCLUDES}" HAVE_SIGNAL_MACRO )
IF ( HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO )
SET ( HAVE_SIGNAL 1 )
ENDIF ( HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO )
CHECK_SYMBOL_EXISTS ( uname "${CURL_INCLUDES}" HAVE_UNAME )
CHECK_SYMBOL_EXISTS ( strtoll "${CURL_INCLUDES}" HAVE_STRTOLL )
CHECK_SYMBOL_EXISTS ( _strtoi64 "${CURL_INCLUDES}" HAVE__STRTOI64 )
CHECK_SYMBOL_EXISTS ( strerror_r "${CURL_INCLUDES}" HAVE_STRERROR_R )
CHECK_SYMBOL_EXISTS ( siginterrupt "${CURL_INCLUDES}" HAVE_SIGINTERRUPT )
CHECK_SYMBOL_EXISTS ( perror "${CURL_INCLUDES}" HAVE_PERROR )
CHECK_SYMBOL_EXISTS ( fork "${CURL_INCLUDES}" HAVE_FORK )
CHECK_SYMBOL_EXISTS ( freeaddrinfo "${CURL_INCLUDES}" HAVE_FREEADDRINFO )
CHECK_SYMBOL_EXISTS ( freeifaddrs "${CURL_INCLUDES}" HAVE_FREEIFADDRS )
CHECK_SYMBOL_EXISTS ( pipe "${CURL_INCLUDES}" HAVE_PIPE )
CHECK_SYMBOL_EXISTS ( ftruncate "${CURL_INCLUDES}" HAVE_FTRUNCATE )
CHECK_SYMBOL_EXISTS ( getprotobyname "${CURL_INCLUDES}" HAVE_GETPROTOBYNAME )
CHECK_SYMBOL_EXISTS ( getrlimit "${CURL_INCLUDES}" HAVE_GETRLIMIT )
CHECK_SYMBOL_EXISTS ( idn_free "${CURL_INCLUDES}" HAVE_IDN_FREE )
CHECK_SYMBOL_EXISTS ( idna_strerror "${CURL_INCLUDES}" HAVE_IDNA_STRERROR )
CHECK_SYMBOL_EXISTS ( tld_strerror "${CURL_INCLUDES}" HAVE_TLD_STRERROR )
CHECK_SYMBOL_EXISTS ( setlocale "${CURL_INCLUDES}" HAVE_SETLOCALE )
CHECK_SYMBOL_EXISTS ( setrlimit "${CURL_INCLUDES}" HAVE_SETRLIMIT )
CHECK_SYMBOL_EXISTS ( fcntl "${CURL_INCLUDES}" HAVE_FCNTL )
CHECK_SYMBOL_EXISTS ( ioctl "${CURL_INCLUDES}" HAVE_IOCTL )
CHECK_SYMBOL_EXISTS ( setsockopt "${CURL_INCLUDES}" HAVE_SETSOCKOPT )
# symbol exists in win32, but function does not.
CHECK_FUNCTION_EXISTS ( inet_pton HAVE_INET_PTON )
# sigaction and sigsetjmp are special. Use special mechanism for
# detecting those, but only if previous attempt failed.
IF ( HAVE_SIGNAL_H )
CHECK_SYMBOL_EXISTS ( sigaction "signal.h" HAVE_SIGACTION )
ENDIF ( HAVE_SIGNAL_H )
IF ( NOT HAVE_SIGSETJMP )
IF ( HAVE_SETJMP_H )
CHECK_SYMBOL_EXISTS ( sigsetjmp "setjmp.h" HAVE_MACRO_SIGSETJMP )
IF ( HAVE_MACRO_SIGSETJMP )
SET ( HAVE_SIGSETJMP 1 )
ENDIF ( HAVE_MACRO_SIGSETJMP )
ENDIF ( HAVE_SETJMP_H )
ENDIF ( NOT HAVE_SIGSETJMP )
# If there is no stricmp(), do not allow LDAP to parse URLs
if ( NOT HAVE_STRICMP )
SET ( HAVE_LDAP_URL_PARSE 1 )
endif ( NOT HAVE_STRICMP )
# For other curl specific tests, use this macro.
MACRO ( CURL_INTERNAL_TEST CURL_TEST )
IF ( "${CURL_TEST}" MATCHES "^${CURL_TEST}$" )
SET ( MACRO_CHECK_FUNCTION_DEFINITIONS
" - D $ { C U R L _ T E S T } $ { C U R L _ T E S T _ D E F I N E S } $ { C M A K E _ R E Q U I R E D _ F L A G S } " )
IF ( CMAKE_REQUIRED_LIBRARIES )
SET ( CURL_TEST_ADD_LIBRARIES
" - D L I N K _ L I B R A R I E S : S T R I N G = $ { C M A K E _ R E Q U I R E D _ L I B R A R I E S } " )
ENDIF ( CMAKE_REQUIRED_LIBRARIES )
MESSAGE ( STATUS "Performing Curl Test ${CURL_TEST}" )
TRY_COMPILE ( ${ CURL_TEST }
$ { C M A K E _ B I N A R Y _ D I R }
$ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / C M a k e / C u r l T e s t s . c
C M A K E _ F L A G S - D C O M P I L E _ D E F I N I T I O N S : S T R I N G = $ { M A C R O _ C H E C K _ F U N C T I O N _ D E F I N I T I O N S }
" $ { C U R L _ T E S T _ A D D _ L I B R A R I E S } "
O U T P U T _ V A R I A B L E O U T P U T )
IF ( ${ CURL_TEST } )
SET ( ${ CURL_TEST } 1 CACHE INTERNAL "Curl test ${FUNCTION}" )
MESSAGE ( STATUS "Performing Curl Test ${CURL_TEST} - Success" )
FILE ( APPEND ${ CMAKE_BINARY_DIR } ${ CMAKE_FILES_DIRECTORY } /CMakeOutput.log
" P e r f o r m i n g C u r l T e s t $ { C U R L _ T E S T } p a s s e d w i t h t h e f o l l o w i n g o u t p u t : \ n "
" $ { O U T P U T } \ n " )
ELSE ( ${ CURL_TEST } )
MESSAGE ( STATUS "Performing Curl Test ${CURL_TEST} - Failed" )
SET ( ${ CURL_TEST } "" CACHE INTERNAL "Curl test ${FUNCTION}" )
FILE ( APPEND ${ CMAKE_BINARY_DIR } ${ CMAKE_FILES_DIRECTORY } /CMakeError.log
" P e r f o r m i n g C u r l T e s t $ { C U R L _ T E S T } f a i l e d w i t h t h e f o l l o w i n g o u t p u t : \ n "
" $ { O U T P U T } \ n " )
ENDIF ( ${ CURL_TEST } )
ENDIF ( "${CURL_TEST}" MATCHES "^${CURL_TEST}$" )
ENDMACRO ( CURL_INTERNAL_TEST )
MACRO ( CURL_INTERNAL_TEST_RUN CURL_TEST )
IF ( "${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$" )
SET ( MACRO_CHECK_FUNCTION_DEFINITIONS
" - D $ { C U R L _ T E S T } $ { C M A K E _ R E Q U I R E D _ F L A G S } " )
IF ( CMAKE_REQUIRED_LIBRARIES )
SET ( CURL_TEST_ADD_LIBRARIES
" - D L I N K _ L I B R A R I E S : S T R I N G = $ { C M A K E _ R E Q U I R E D _ L I B R A R I E S } " )
ENDIF ( CMAKE_REQUIRED_LIBRARIES )
MESSAGE ( STATUS "Performing Curl Test ${CURL_TEST}" )
TRY_RUN ( ${ CURL_TEST } ${ CURL_TEST } _COMPILE
$ { C M A K E _ B I N A R Y _ D I R }
$ { C M A K E _ C U R R E N T _ S O U R C E _ D I R } / C M a k e / C u r l T e s t s . c
C M A K E _ F L A G S - D C O M P I L E _ D E F I N I T I O N S : S T R I N G = $ { M A C R O _ C H E C K _ F U N C T I O N _ D E F I N I T I O N S }
" $ { C U R L _ T E S T _ A D D _ L I B R A R I E S } "
O U T P U T _ V A R I A B L E O U T P U T )
IF ( ${ CURL_TEST } _COMPILE AND NOT ${ CURL_TEST } )
SET ( ${ CURL_TEST } 1 CACHE INTERNAL "Curl test ${FUNCTION}" )
MESSAGE ( STATUS "Performing Curl Test ${CURL_TEST} - Success" )
ELSE ( ${ CURL_TEST } _COMPILE AND NOT ${ CURL_TEST } )
MESSAGE ( STATUS "Performing Curl Test ${CURL_TEST} - Failed" )
SET ( ${ CURL_TEST } "" CACHE INTERNAL "Curl test ${FUNCTION}" )
FILE ( APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
" P e r f o r m i n g C u r l T e s t $ { C U R L _ T E S T } f a i l e d w i t h t h e f o l l o w i n g o u t p u t : \ n "
" $ { O U T P U T } " )
IF ( ${ CURL_TEST } _COMPILE )
FILE ( APPEND
" $ { C M A K E _ B I N A R Y _ D I R } $ { C M A K E _ F I L E S _ D I R E C T O R Y } / C M a k e E r r o r . l o g "
" T h e r e w a s a p r o b l e m r u n n i n g t h i s t e s t \ n " )
ENDIF ( ${ CURL_TEST } _COMPILE )
FILE ( APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
" \ n \ n " )
ENDIF ( ${ CURL_TEST } _COMPILE AND NOT ${ CURL_TEST } )
ENDIF ( "${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$" )
ENDMACRO ( CURL_INTERNAL_TEST_RUN )
# Do curl specific tests
FOREACH ( CURL_TEST
H A V E _ F C N T L _ O _ N O N B L O C K
H A V E _ I O C T L S O C K E T
H A V E _ I O C T L S O C K E T _ C A M E L
H A V E _ I O C T L S O C K E T _ C A M E L _ F I O N B I O
H A V E _ I O C T L S O C K E T _ F I O N B I O
H A V E _ I O C T L _ F I O N B I O
H A V E _ I O C T L _ S I O C G I F A D D R
H A V E _ S E T S O C K O P T _ S O _ N O N B L O C K
H A V E _ S O C K A D D R _ I N 6 _ S I N 6 _ S C O P E _ I D
T I M E _ W I T H _ S Y S _ T I M E
H A V E _ O _ N O N B L O C K
H A V E _ G E T H O S T B Y A D D R _ R _ 5
H A V E _ G E T H O S T B Y A D D R _ R _ 7
H A V E _ G E T H O S T B Y A D D R _ R _ 8
H A V E _ G E T H O S T B Y A D D R _ R _ 5 _ R E E N T R A N T
H A V E _ G E T H O S T B Y A D D R _ R _ 7 _ R E E N T R A N T
H A V E _ G E T H O S T B Y A D D R _ R _ 8 _ R E E N T R A N T
H A V E _ G E T H O S T B Y N A M E _ R _ 3
H A V E _ G E T H O S T B Y N A M E _ R _ 5
H A V E _ G E T H O S T B Y N A M E _ R _ 6
H A V E _ G E T H O S T B Y N A M E _ R _ 3 _ R E E N T R A N T
H A V E _ G E T H O S T B Y N A M E _ R _ 5 _ R E E N T R A N T
H A V E _ G E T H O S T B Y N A M E _ R _ 6 _ R E E N T R A N T
H A V E _ S O C K L E N _ T
H A V E _ I N _ A D D R _ T
H A V E _ B O O L _ T
S T D C _ H E A D E R S
R E T S I G T Y P E _ T E S T
H A V E _ I N E T _ N T O A _ R _ D E C L
H A V E _ I N E T _ N T O A _ R _ D E C L _ R E E N T R A N T
H A V E _ G E T A D D R I N F O
H A V E _ F I L E _ O F F S E T _ B I T S
)
CURL_INTERNAL_TEST ( ${ CURL_TEST } )
ENDFOREACH ( CURL_TEST )
IF ( HAVE_FILE_OFFSET_BITS )
SET ( _FILE_OFFSET_BITS 64 )
ENDIF ( HAVE_FILE_OFFSET_BITS )
FOREACH ( CURL_TEST
H A V E _ G L I B C _ S T R E R R O R _ R
H A V E _ P O S I X _ S T R E R R O R _ R
)
CURL_INTERNAL_TEST_RUN ( ${ CURL_TEST } )
ENDFOREACH ( CURL_TEST )
# Check for reentrant
FOREACH ( CURL_TEST
H A V E _ G E T H O S T B Y A D D R _ R _ 5
H A V E _ G E T H O S T B Y A D D R _ R _ 7
H A V E _ G E T H O S T B Y A D D R _ R _ 8
H A V E _ G E T H O S T B Y N A M E _ R _ 3
H A V E _ G E T H O S T B Y N A M E _ R _ 5
H A V E _ G E T H O S T B Y N A M E _ R _ 6
H A V E _ I N E T _ N T O A _ R _ D E C L _ R E E N T R A N T )
IF ( NOT ${ CURL_TEST } )
IF ( ${ CURL_TEST } _REENTRANT )
SET ( NEED_REENTRANT 1 )
ENDIF ( ${ CURL_TEST } _REENTRANT )
ENDIF ( NOT ${ CURL_TEST } )
ENDFOREACH ( CURL_TEST )
IF ( NEED_REENTRANT )
FOREACH ( CURL_TEST
H A V E _ G E T H O S T B Y A D D R _ R _ 5
H A V E _ G E T H O S T B Y A D D R _ R _ 7
H A V E _ G E T H O S T B Y A D D R _ R _ 8
H A V E _ G E T H O S T B Y N A M E _ R _ 3
H A V E _ G E T H O S T B Y N A M E _ R _ 5
H A V E _ G E T H O S T B Y N A M E _ R _ 6 )
SET ( ${ CURL_TEST } 0 )
IF ( ${ CURL_TEST } _REENTRANT )
SET ( ${ CURL_TEST } 1 )
ENDIF ( ${ CURL_TEST } _REENTRANT )
ENDFOREACH ( CURL_TEST )
ENDIF ( NEED_REENTRANT )
IF ( HAVE_INET_NTOA_R_DECL_REENTRANT )
SET ( HAVE_INET_NTOA_R_DECL 1 )
SET ( NEED_REENTRANT 1 )
ENDIF ( HAVE_INET_NTOA_R_DECL_REENTRANT )
# Some other minor tests
IF ( NOT HAVE_SOCKLEN_T )
SET ( socklen_t "int" )
ENDIF ( NOT HAVE_SOCKLEN_T )
IF ( NOT HAVE_IN_ADDR_T )
SET ( in_addr_t "unsigned long" )
ENDIF ( NOT HAVE_IN_ADDR_T )
# Fix libz / zlib.h
IF ( NOT CURL_SPECIAL_LIBZ )
IF ( NOT HAVE_LIBZ )
SET ( HAVE_ZLIB_H 0 )
ENDIF ( NOT HAVE_LIBZ )
IF ( NOT HAVE_ZLIB_H )
SET ( HAVE_LIBZ 0 )
ENDIF ( NOT HAVE_ZLIB_H )
ENDIF ( NOT CURL_SPECIAL_LIBZ )
IF ( _FILE_OFFSET_BITS )
SET ( _FILE_OFFSET_BITS 64 )
ENDIF ( _FILE_OFFSET_BITS )
SET ( CMAKE_REQUIRED_FLAGS "-D_FILE_OFFSET_BITS=64" )
SET ( CMAKE_EXTRA_INCLUDE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/curl/curl.h" )
CHECK_TYPE_SIZE ( "curl_off_t" SIZEOF_CURL_OFF_T )
SET ( CMAKE_EXTRA_INCLUDE_FILES )
SET ( CMAKE_REQUIRED_FLAGS )
# Check for nonblocking
SET ( HAVE_DISABLED_NONBLOCKING 1 )
IF ( HAVE_FIONBIO OR
H A V E _ I O C T L S O C K E T O R
H A V E _ I O C T L S O C K E T _ C A S E O R
H A V E _ O _ N O N B L O C K )
SET ( HAVE_DISABLED_NONBLOCKING )
ENDIF ( HAVE_FIONBIO OR
H A V E _ I O C T L S O C K E T O R
H A V E _ I O C T L S O C K E T _ C A S E O R
H A V E _ O _ N O N B L O C K )
IF ( RETSIGTYPE_TEST )
SET ( RETSIGTYPE void )
ELSE ( RETSIGTYPE_TEST )
SET ( RETSIGTYPE int )
ENDIF ( RETSIGTYPE_TEST )
IF ( CMAKE_COMPILER_IS_GNUCC AND APPLE )
INCLUDE ( CheckCCompilerFlag )
CHECK_C_COMPILER_FLAG ( -Wno-long-double HAVE_C_FLAG_Wno_long_double )
IF ( HAVE_C_FLAG_Wno_long_double )
# The Mac version of GCC warns about use of long double. Disable it.
GET_SOURCE_FILE_PROPERTY ( MPRINTF_COMPILE_FLAGS mprintf.c COMPILE_FLAGS )
IF ( MPRINTF_COMPILE_FLAGS )
SET ( MPRINTF_COMPILE_FLAGS "${MPRINTF_COMPILE_FLAGS} -Wno-long-double" )
ELSE ( MPRINTF_COMPILE_FLAGS )
SET ( MPRINTF_COMPILE_FLAGS "-Wno-long-double" )
ENDIF ( MPRINTF_COMPILE_FLAGS )
SET_SOURCE_FILES_PROPERTIES ( mprintf.c PROPERTIES
C O M P I L E _ F L A G S $ { M P R I N T F _ C O M P I L E _ F L A G S } )
ENDIF ( HAVE_C_FLAG_Wno_long_double )
ENDIF ( CMAKE_COMPILER_IS_GNUCC AND APPLE )
INCLUDE ( CMake/OtherTests.cmake )
2009-04-06 16:44:01 -04:00
ADD_DEFINITIONS ( -DHAVE_CONFIG_H )
2009-04-02 09:14:53 -04:00
# For windows, do not allow the compiler to use default target (Vista).
IF ( WIN32 )
ADD_DEFINITIONS ( -D_WIN32_WINNT=0x0501 )
ENDIF ( WIN32 )
2009-04-06 15:22:31 -04:00
IF ( MSVC )
ADD_DEFINITIONS ( -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE )
ENDIF ( MSVC )
2009-04-02 09:14:53 -04:00
2009-04-06 17:05:44 -04:00
# Sets up the dependencies (zlib, OpenSSL, etc.) of a cURL subproject according to options.
# TODO This is far to be complete!
FUNCTION ( SETUP_CURL_DEPENDENCIES TARGET_NAME )
IF ( CURL_ZLIB AND ZLIB_FOUND )
INCLUDE_DIRECTORIES ( ${ ZLIB_INCLUDE_DIR } )
ENDIF ( )
IF ( CURL_ZLIB AND ZLIB_FOUND )
TARGET_LINK_LIBRARIES ( ${ TARGET_NAME } ${ ZLIB_LIBRARIES } )
#ADD_DEFINITIONS( -DHAVE_ZLIB_H -DHAVE_ZLIB -DHAVE_LIBZ )
ENDIF ( )
IF ( CMAKE_USE_OPENSSL AND OPENSSL_FOUND )
INCLUDE_DIRECTORIES ( ${ OPENSSL_INCLUDE_DIR } )
ENDIF ( )
IF ( CURL_SSL AND CURL_CONFIG_HAS_BEEN_RUN_BEFORE )
TARGET_LINK_LIBRARIES ( ${ TARGET_NAME } ${ OPENSSL_LIBRARIES } )
#ADD_DEFINITIONS( -DUSE_SSLEAY )
ENDIF ( )
ENDFUNCTION ( )
2009-04-06 18:45:17 -04:00
# Ugly (but functional) way to include "Makefile.inc" by transforming it (= regenerate it).
FUNCTION ( TRANSFORM_MAKEFILE_INC INPUT_FILE OUTPUT_FILE )
FILE ( READ ${ INPUT_FILE } MAKEFILE_INC_TEXT )
2009-04-07 17:59:15 -04:00
STRING ( REPLACE "$(top_srcdir)" "\${CURL_SOURCE_DIR}" MAKEFILE_INC_TEXT ${ MAKEFILE_INC_TEXT } )
STRING ( REPLACE "$(top_builddir)" "\${CURL_BINARY_DIR}" MAKEFILE_INC_TEXT ${ MAKEFILE_INC_TEXT } )
2009-04-06 18:45:17 -04:00
STRING ( REGEX REPLACE "\\\\\n" "<22> !<21> " MAKEFILE_INC_TEXT ${ MAKEFILE_INC_TEXT } )
STRING ( REGEX REPLACE "([a-zA-Z_][a-zA-Z0-9_]*)[\t ]*=[\t ]*([^\n]*\n)" "SET(\\1 \\2)\n" MAKEFILE_INC_TEXT ${ MAKEFILE_INC_TEXT } )
STRING ( REPLACE "<22> !<21> " "\n" MAKEFILE_INC_TEXT ${ MAKEFILE_INC_TEXT } )
2009-04-07 17:59:15 -04:00
STRING ( REGEX REPLACE "\\$\\(([a-zA-Z_][a-zA-Z0-9_]*)\\)" "\${\\1}" MAKEFILE_INC_TEXT ${ MAKEFILE_INC_TEXT } ) # Replace $() with ${}
STRING ( REGEX REPLACE "@([a-zA-Z_][a-zA-Z0-9_]*)@" "\${\\1}" MAKEFILE_INC_TEXT ${ MAKEFILE_INC_TEXT } ) # Replace @@ with ${}, even if that may not be read by CMake scripts.
2009-04-06 18:45:17 -04:00
FILE ( WRITE ${ OUTPUT_FILE } ${ MAKEFILE_INC_TEXT } )
### BUGGY METHOD 1
# FILE(STRINGS Makefile.inc MAKEFILE_INC_TEXT)
# STRING(REPLACE "# ./lib/Makefile.inc" "" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
# STRING(REPLACE " " " " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT}) # Replace tabs with spaces
# #STRING(REGEX MATCH "CSOURCES *=" AAA ${MAKEFILE_INC_TEXT})
# #MESSAGE(STATUS ${AAA})
# STRING(REPLACE "CSOURCES =" "" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
# STRING(REPLACE "HHEADERS =" "" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
# STRING(REGEX REPLACE "[^ ]+\\.c" "" ${HEADERS_VAR} ${MAKEFILE_INC_TEXT}) # Remove source files and store into headers var
# STRING(REGEX REPLACE " +" " " ${HEADERS_VAR} ${${HEADERS_VAR}})
# STRING(REGEX REPLACE " " ";" ${HEADERS_VAR} ${${HEADERS_VAR}})
# STRING(REGEX REPLACE "[^ ]+\\.h" "" ${SOURCES_VAR} ${MAKEFILE_INC_TEXT}) # Remove headers and store into source files var
# STRING(REGEX REPLACE " +" " " ${SOURCES_VAR} ${${SOURCES_VAR}})
# STRING(REGEX REPLACE " " ";" ${SOURCES_VAR} ${${SOURCES_VAR}})
# SET(${HEADERS_VAR} ${${HEADERS_VAR}} PARENT_SCOPE)
# SET(${SOURCES_VAR} ${${SOURCES_VAR}} PARENT_SCOPE)
### BUGGY METHOD 2
# FILE(READ Makefile.inc MAKEFILE_INC_TEXT)
# #STRING(REPLACE "\t" " " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT}) # Replace tabs with spaces
# #STRING(REGEX REPLACE "\n+" "\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT}) # Remove empty lines (allow a simplification in the script)
# STRING(REGEX REPLACE "([A-Z]+)[\t ]*=[\t ]*" "SET(\\1 " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
# #STRING(REGEX REPLACE "^(.*)[\t ]*[^\\]$" ")" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
# STRING(REGEX REPLACE "([^\\])\n" "\\1)\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
# # STRING(REGEX REPLACE "CSOURCES *=" "SET(libCurl_SRCS " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
# # STRING(REGEX REPLACE "HHEADERS *=" "SET(libCurl_HEADERS " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
# FILE(WRITE Makefile.inc.cmake ${MAKEFILE_INC_TEXT})
ENDFUNCTION ( )
2009-04-06 15:22:31 -04:00
ADD_SUBDIRECTORY ( lib )
2009-04-06 17:05:44 -04:00
IF ( BUILD_CURL_EXE )
ADD_SUBDIRECTORY ( src )
ENDIF ( )
IF ( BUILD_CURL_TESTS )
ADD_SUBDIRECTORY ( tests )
ENDIF ( )
2009-04-02 09:14:53 -04:00
2009-04-07 07:23:23 -04:00
OPTION ( BUILD_DASHBOARD_REPORTS "Set to ON to activate reporting of cURL builds here http://www.cdash.org/CDashPublic/index.php?project=CURL" OFF )
IF ( BUILD_DASHBOARD_REPORTS )
INCLUDE ( Dart )
#INCLUDE(CTest)
ENDIF ( BUILD_DASHBOARD_REPORTS )
2009-04-02 09:14:53 -04:00
# This needs to be run very last so other parts of the scripts can take advantage of this.
IF ( NOT CURL_CONFIG_HAS_BEEN_RUN_BEFORE )
SET ( CURL_CONFIG_HAS_BEEN_RUN_BEFORE 1 CACHE INTERNAL "Flag to track whether this is the first time running CMake or if CMake has been configured before" )
ENDIF ( )
