generic-library/curl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ENH: lower case cmake functions and remove tabs and re-indent cmake code

Browse Source
This commit is contained in:
Bill Hoffman 2009-06-09 17:29:16 +00:00
parent 8740d147c9
commit 744dceaffe
14 changed files with 1197 additions and 1187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
CMake/CheckTypeSize.cmake
View File

@ -6,51 +6,51 @@
# VARIABLE - variable to store size if the type exists. # VARIABLE - variable to store size if the type exists.
# HAVE_${VARIABLE} - does the variable exists or not # HAVE_${VARIABLE} - does the variable exists or not
MACRO(CHECK_TYPE_SIZE TYPE VARIABLE) macro(CHECK_TYPE_SIZE TYPE VARIABLE)
SET(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS 1) set(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS 1)
IF(NOT DEFINED ${VARIABLE}) if(NOT DEFINED ${VARIABLE})
IF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$") if("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$")
SET(CHECK_TYPE_SIZE_TYPE "${TYPE}") set(CHECK_TYPE_SIZE_TYPE "${TYPE}")
SET(MACRO_CHECK_TYPE_SIZE_FLAGS set(MACRO_CHECK_TYPE_SIZE_FLAGS
"${CMAKE_REQUIRED_FLAGS}") "${CMAKE_REQUIRED_FLAGS}")
FOREACH(def HAVE_SYS_TYPES_H HAVE_STDINT_H HAVE_STDDEF_H) foreach(def HAVE_SYS_TYPES_H HAVE_STDINT_H HAVE_STDDEF_H)
IF("${def}") if("${def}")
SET(MACRO_CHECK_TYPE_SIZE_FLAGS set(MACRO_CHECK_TYPE_SIZE_FLAGS
"${MACRO_CHECK_TYPE_SIZE_FLAGS} -D${def}") "${MACRO_CHECK_TYPE_SIZE_FLAGS} -D${def}")
ENDIF("${def}") endif("${def}")
ENDFOREACH(def) endforeach(def)
SET(CHECK_TYPE_SIZE_PREMAIN) set(CHECK_TYPE_SIZE_PREMAIN)
FOREACH(def ${CMAKE_EXTRA_INCLUDE_FILES}) foreach(def ${CMAKE_EXTRA_INCLUDE_FILES})
SET(CHECK_TYPE_SIZE_PREMAIN "${CHECK_TYPE_SIZE_PREMAIN}#include \"${def}\"\n") set(CHECK_TYPE_SIZE_PREMAIN "${CHECK_TYPE_SIZE_PREMAIN}#include \"${def}\"\n")
ENDFOREACH(def) endforeach(def)
CONFIGURE_FILE( configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/CMake/CheckTypeSize.c.in" "${CMAKE_CURRENT_SOURCE_DIR}/CMake/CheckTypeSize.c.in"
"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSize.c" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSize.c"
IMMEDIATE @ONLY) IMMEDIATE @ONLY)
FILE(READ file(READ
"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSize.c" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSize.c"
CHECK_TYPE_SIZE_FILE_CONTENT) CHECK_TYPE_SIZE_FILE_CONTENT)
MESSAGE(STATUS "Check size of ${TYPE}") message(STATUS "Check size of ${TYPE}")
IF(CMAKE_REQUIRED_LIBRARIES) if(CMAKE_REQUIRED_LIBRARIES)
SET(CHECK_TYPE_SIZE_ADD_LIBRARIES set(CHECK_TYPE_SIZE_ADD_LIBRARIES
"-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}") "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
ENDIF(CMAKE_REQUIRED_LIBRARIES) endif(CMAKE_REQUIRED_LIBRARIES)
TRY_RUN(${VARIABLE} HAVE_${VARIABLE} try_run(${VARIABLE} HAVE_${VARIABLE}
${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}
"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSize.c" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSize.c"
CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_TYPE_SIZE_FLAGS} CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_TYPE_SIZE_FLAGS}
"${CHECK_TYPE_SIZE_ADD_LIBRARIES}" "${CHECK_TYPE_SIZE_ADD_LIBRARIES}"
OUTPUT_VARIABLE OUTPUT) OUTPUT_VARIABLE OUTPUT)
IF(HAVE_${VARIABLE}) if(HAVE_${VARIABLE})
MESSAGE(STATUS "Check size of ${TYPE} - done") message(STATUS "Check size of ${TYPE} - done")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Determining size of ${TYPE} passed with the following output:\n${OUTPUT}\n\n") "Determining size of ${TYPE} passed with the following output:\n${OUTPUT}\n\n")
ELSE(HAVE_${VARIABLE}) else(HAVE_${VARIABLE})
MESSAGE(STATUS "Check size of ${TYPE} - failed") message(STATUS "Check size of ${TYPE} - failed")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
"Determining size of ${TYPE} failed with the following output:\n${OUTPUT}\nCheckTypeSize.c:\n${CHECK_TYPE_SIZE_FILE_CONTENT}\n\n") "Determining size of ${TYPE} failed with the following output:\n${OUTPUT}\nCheckTypeSize.c:\n${CHECK_TYPE_SIZE_FILE_CONTENT}\n\n")
ENDIF(HAVE_${VARIABLE}) endif(HAVE_${VARIABLE})
ENDIF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$") endif("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$")
ENDIF(NOT DEFINED ${VARIABLE}) endif(NOT DEFINED ${VARIABLE})
SET(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS ) set(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS )
ENDMACRO(CHECK_TYPE_SIZE) endmacro(CHECK_TYPE_SIZE)

80
CMake/CurlCheckCSourceCompiles.cmake
View File

@ -12,43 +12,43 @@
# CMAKE_REQUIRED_INCLUDES = list of include directories # CMAKE_REQUIRED_INCLUDES = list of include directories
# CMAKE_REQUIRED_LIBRARIES = list of libraries to link # CMAKE_REQUIRED_LIBRARIES = list of libraries to link
MACRO(CURL_CHECK_C_SOURCE_COMPILES SOURCE VAR) macro(CURL_CHECK_C_SOURCE_COMPILES SOURCE VAR)
IF("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN") if("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
SET(message "${VAR}") set(message "${VAR}")
# If the number of arguments is greater than 2 (SOURCE VAR) # If the number of arguments is greater than 2 (SOURCE VAR)
IF(${ARGC} GREATER 2) if(${ARGC} GREATER 2)
# then add the third argument as a message # then add the third argument as a message
SET(message "${ARGV2} (${VAR})") set(message "${ARGV2} (${VAR})")
ENDIF(${ARGC} GREATER 2) endif(${ARGC} GREATER 2)
SET(MACRO_CHECK_FUNCTION_DEFINITIONS set(MACRO_CHECK_FUNCTION_DEFINITIONS
"-D${VAR} ${CMAKE_REQUIRED_FLAGS}") "-D${VAR} ${CMAKE_REQUIRED_FLAGS}")
IF(CMAKE_REQUIRED_LIBRARIES) if(CMAKE_REQUIRED_LIBRARIES)
SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES set(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES
"-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}") "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
ELSE(CMAKE_REQUIRED_LIBRARIES) else(CMAKE_REQUIRED_LIBRARIES)
SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES) set(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES)
ENDIF(CMAKE_REQUIRED_LIBRARIES) endif(CMAKE_REQUIRED_LIBRARIES)
IF(CMAKE_REQUIRED_INCLUDES) if(CMAKE_REQUIRED_INCLUDES)
SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES set(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES
"-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}") "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
ELSE(CMAKE_REQUIRED_INCLUDES) else(CMAKE_REQUIRED_INCLUDES)
SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES) set(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES)
ENDIF(CMAKE_REQUIRED_INCLUDES) endif(CMAKE_REQUIRED_INCLUDES)
SET(src "") set(src "")
FOREACH(def ${EXTRA_DEFINES}) foreach(def ${EXTRA_DEFINES})
SET(src "${src}#define ${def} 1\n") set(src "${src}#define ${def} 1\n")
ENDFOREACH(def) endforeach(def)
FOREACH(inc ${HEADER_INCLUDES}) foreach(inc ${HEADER_INCLUDES})
SET(src "${src}#include <${inc}>\n") set(src "${src}#include <${inc}>\n")
ENDFOREACH(inc) endforeach(inc)
SET(src "${src}\nint main() { ${SOURCE} ; return 0; }") set(src "${src}\nint main() { ${SOURCE} ; return 0; }")
SET(CMAKE_CONFIGURABLE_FILE_CONTENT "${src}") set(CMAKE_CONFIGURABLE_FILE_CONTENT "${src}")
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/CMake/CMakeConfigurableFile.in configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CMake/CMakeConfigurableFile.in
"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c"
IMMEDIATE) IMMEDIATE)
MESSAGE(STATUS "Performing Test ${message}") message(STATUS "Performing Test ${message}")
TRY_COMPILE(${VAR} try_compile(${VAR}
${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c
COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
@ -56,20 +56,20 @@ MACRO(CURL_CHECK_C_SOURCE_COMPILES SOURCE VAR)
"${CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES}" "${CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES}"
"${CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES}" "${CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES}"
OUTPUT_VARIABLE OUTPUT) OUTPUT_VARIABLE OUTPUT)
IF(${VAR}) if(${VAR})
SET(${VAR} 1 CACHE INTERNAL "Test ${message}") set(${VAR} 1 CACHE INTERNAL "Test ${message}")
MESSAGE(STATUS "Performing Test ${message} - Success") message(STATUS "Performing Test ${message} - Success")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Performing C SOURCE FILE Test ${message} succeded with the following output:\n" "Performing C SOURCE FILE Test ${message} succeded with the following output:\n"
"${OUTPUT}\n" "${OUTPUT}\n"
"Source file was:\n${src}\n") "Source file was:\n${src}\n")
ELSE(${VAR}) else(${VAR})
MESSAGE(STATUS "Performing Test ${message} - Failed") message(STATUS "Performing Test ${message} - Failed")
SET(${VAR} "" CACHE INTERNAL "Test ${message}") set(${VAR} "" CACHE INTERNAL "Test ${message}")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
"Performing C SOURCE FILE Test ${message} failed with the following output:\n" "Performing C SOURCE FILE Test ${message} failed with the following output:\n"
"${OUTPUT}\n" "${OUTPUT}\n"
"Source file was:\n${src}\n") "Source file was:\n${src}\n")
ENDIF(${VAR}) endif(${VAR})
ENDIF("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN") endif("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
ENDMACRO(CURL_CHECK_C_SOURCE_COMPILES) endmacro(CURL_CHECK_C_SOURCE_COMPILES)

88
CMake/CurlCheckCSourceRuns.cmake
View File

@ -12,43 +12,43 @@
# CMAKE_REQUIRED_INCLUDES = list of include directories # CMAKE_REQUIRED_INCLUDES = list of include directories
# CMAKE_REQUIRED_LIBRARIES = list of libraries to link # CMAKE_REQUIRED_LIBRARIES = list of libraries to link
MACRO(CURL_CHECK_C_SOURCE_RUNS SOURCE VAR) macro(CURL_CHECK_C_SOURCE_RUNS SOURCE VAR)
IF("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN") if("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
SET(message "${VAR}") set(message "${VAR}")
# If the number of arguments is greater than 2 (SOURCE VAR) # If the number of arguments is greater than 2 (SOURCE VAR)
IF(${ARGC} GREATER 2) if(${ARGC} GREATER 2)
# then add the third argument as a message # then add the third argument as a message
SET(message "${ARGV2} (${VAR})") set(message "${ARGV2} (${VAR})")
ENDIF(${ARGC} GREATER 2) endif(${ARGC} GREATER 2)
SET(MACRO_CHECK_FUNCTION_DEFINITIONS set(MACRO_CHECK_FUNCTION_DEFINITIONS
"-D${VAR} ${CMAKE_REQUIRED_FLAGS}") "-D${VAR} ${CMAKE_REQUIRED_FLAGS}")
IF(CMAKE_REQUIRED_LIBRARIES) if(CMAKE_REQUIRED_LIBRARIES)
SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES set(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES
"-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}") "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
ELSE(CMAKE_REQUIRED_LIBRARIES) else(CMAKE_REQUIRED_LIBRARIES)
SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES) set(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES)
ENDIF(CMAKE_REQUIRED_LIBRARIES) endif(CMAKE_REQUIRED_LIBRARIES)
IF(CMAKE_REQUIRED_INCLUDES) if(CMAKE_REQUIRED_INCLUDES)
SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES set(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES
"-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}") "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
ELSE(CMAKE_REQUIRED_INCLUDES) else(CMAKE_REQUIRED_INCLUDES)
SET(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES) set(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES)
ENDIF(CMAKE_REQUIRED_INCLUDES) endif(CMAKE_REQUIRED_INCLUDES)
SET(src "") set(src "")
FOREACH(def ${EXTRA_DEFINES}) foreach(def ${EXTRA_DEFINES})
SET(src "${src}#define ${def} 1\n") set(src "${src}#define ${def} 1\n")
ENDFOREACH(def) endforeach(def)
FOREACH(inc ${HEADER_INCLUDES}) foreach(inc ${HEADER_INCLUDES})
SET(src "${src}#include <${inc}>\n") set(src "${src}#include <${inc}>\n")
ENDFOREACH(inc) endforeach(inc)
SET(src "${src}\nint main() { ${SOURCE} ; return 0; }") set(src "${src}\nint main() { ${SOURCE} ; return 0; }")
SET(CMAKE_CONFIGURABLE_FILE_CONTENT "${src}") set(CMAKE_CONFIGURABLE_FILE_CONTENT "${src}")
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/CMake/CMakeConfigurableFile.in configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CMake/CMakeConfigurableFile.in
"${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c" "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c"
IMMEDIATE) IMMEDIATE)
MESSAGE(STATUS "Performing Test ${message}") message(STATUS "Performing Test ${message}")
TRY_RUN(${VAR} ${VAR}_COMPILED try_run(${VAR} ${VAR}_COMPILED
${CMAKE_BINARY_DIR} ${CMAKE_BINARY_DIR}
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c
COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}
@ -57,27 +57,27 @@ MACRO(CURL_CHECK_C_SOURCE_RUNS SOURCE VAR)
"${CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES}" "${CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES}"
OUTPUT_VARIABLE OUTPUT) OUTPUT_VARIABLE OUTPUT)
# if it did not compile make the return value fail code of 1 # if it did not compile make the return value fail code of 1
IF(NOT ${VAR}_COMPILED) if(NOT ${VAR}_COMPILED)
SET(${VAR} 1) set(${VAR} 1)
ENDIF(NOT ${VAR}_COMPILED) endif(NOT ${VAR}_COMPILED)
# if the return value was 0 then it worked # if the return value was 0 then it worked
SET(result_var ${${VAR}}) set(result_var ${${VAR}})
IF("${result_var}" EQUAL 0) if("${result_var}" EQUAL 0)
SET(${VAR} 1 CACHE INTERNAL "Test ${message}") set(${VAR} 1 CACHE INTERNAL "Test ${message}")
MESSAGE(STATUS "Performing Test ${message} - Success") message(STATUS "Performing Test ${message} - Success")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Performing C SOURCE FILE Test ${message} succeded with the following output:\n" "Performing C SOURCE FILE Test ${message} succeded with the following output:\n"
"${OUTPUT}\n" "${OUTPUT}\n"
"Return value: ${${VAR}}\n" "Return value: ${${VAR}}\n"
"Source file was:\n${src}\n") "Source file was:\n${src}\n")
ELSE("${result_var}" EQUAL 0) else("${result_var}" EQUAL 0)
MESSAGE(STATUS "Performing Test ${message} - Failed") message(STATUS "Performing Test ${message} - Failed")
SET(${VAR} "" CACHE INTERNAL "Test ${message}") set(${VAR} "" CACHE INTERNAL "Test ${message}")
FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
"Performing C SOURCE FILE Test ${message} failed with the following output:\n" "Performing C SOURCE FILE Test ${message} failed with the following output:\n"
"${OUTPUT}\n" "${OUTPUT}\n"
"Return value: ${result_var}\n" "Return value: ${result_var}\n"
"Source file was:\n${src}\n") "Source file was:\n${src}\n")
ENDIF("${result_var}" EQUAL 0) endif("${result_var}" EQUAL 0)
ENDIF("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN") endif("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
ENDMACRO(CURL_CHECK_C_SOURCE_RUNS) endmacro(CURL_CHECK_C_SOURCE_RUNS)

24
CMake/FindOpenSSL.cmake
View File

@ -1,19 +1,19 @@
# Extension of the standard FindOpenSSL.cmake # Extension of the standard FindOpenSSL.cmake
# Adds OPENSSL_INCLUDE_DIRS and libeay32 # Adds OPENSSL_INCLUDE_DIRS and libeay32
INCLUDE("${CMAKE_ROOT}/Modules/FindOpenSSL.cmake") include("${CMAKE_ROOT}/Modules/FindOpenSSL.cmake")
# Bill Hoffman told that libeay32 is necessary for him: # Bill Hoffman told that libeay32 is necessary for him:
FIND_LIBRARY(SSL_LIBEAY NAMES libeay32) find_library(SSL_LIBEAY NAMES libeay32)
IF(OPENSSL_FOUND) if(OPENSSL_FOUND)
IF(SSL_LIBEAY) if(SSL_LIBEAY)
LIST(APPEND OPENSSL_LIBRARIES ${SSL_LIBEAY}) list(APPEND OPENSSL_LIBRARIES ${SSL_LIBEAY})
ELSE() else()
SET(OPENSSL_FOUND FALSE) set(OPENSSL_FOUND FALSE)
ENDIF() endif()
ENDIF() endif()
IF(OPENSSL_FOUND) if(OPENSSL_FOUND)
SET(OPENSSL_INCLUDE_DIRS ${OPENSSL_INCLUDE_DIR}) set(OPENSSL_INCLUDE_DIRS ${OPENSSL_INCLUDE_DIR})
ENDIF() endif()

10
CMake/FindZLIB.cmake
View File

@ -1,8 +1,8 @@
# Locate zlib # Locate zlib
INCLUDE("${CMAKE_ROOT}/Modules/FindZLIB.cmake") include("${CMAKE_ROOT}/Modules/FindZLIB.cmake")
FIND_LIBRARY(ZLIB_LIBRARY_DEBUG NAMES zd zlibd zdlld zlib1d ) find_library(ZLIB_LIBRARY_DEBUG NAMES zd zlibd zdlld zlib1d )
IF(ZLIB_FOUND AND ZLIB_LIBRARY_DEBUG) if(ZLIB_FOUND AND ZLIB_LIBRARY_DEBUG)
SET( ZLIB_LIBRARIES optimized "${ZLIB_LIBRARY}" debug ${ZLIB_LIBRARY_DEBUG}) set( ZLIB_LIBRARIES optimized "${ZLIB_LIBRARY}" debug ${ZLIB_LIBRARY_DEBUG})
ENDIF() endif()

334
CMake/OtherTests.cmake
View File

@ -1,50 +1,50 @@
INCLUDE(CurlCheckCSourceCompiles) include(CurlCheckCSourceCompiles)
SET(EXTRA_DEFINES "__unused1\n#undef inline\n#define __unused2") set(EXTRA_DEFINES "__unused1\n#undef inline\n#define __unused2")
SET(HEADER_INCLUDES) set(HEADER_INCLUDES)
SET(headers_hack) set(headers_hack)
MACRO(add_header_include check header) macro(add_header_include check header)
IF(${check}) if(${check})
SET(headers_hack set(headers_hack
"${headers_hack}\n#include <${header}>") "${headers_hack}\n#include <${header}>")
#SET(HEADER_INCLUDES #SET(HEADER_INCLUDES
# ${HEADER_INCLUDES} # ${HEADER_INCLUDES}
# "${header}") # "${header}")
ENDIF(${check}) endif(${check})
ENDMACRO(add_header_include) endmacro(add_header_include)
SET(signature_call_conv) set(signature_call_conv)
IF(HAVE_WINDOWS_H) if(HAVE_WINDOWS_H)
add_header_include(HAVE_WINDOWS_H "windows.h") add_header_include(HAVE_WINDOWS_H "windows.h")
add_header_include(HAVE_WINSOCK2_H "winsock2.h") add_header_include(HAVE_WINSOCK2_H "winsock2.h")
add_header_include(HAVE_WINSOCK_H "winsock.h") add_header_include(HAVE_WINSOCK_H "winsock.h")
SET(EXTRA_DEFINES ${EXTRA_DEFINES} set(EXTRA_DEFINES ${EXTRA_DEFINES}
"__unused7\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif\n#define __unused3") "__unused7\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif\n#define __unused3")
SET(signature_call_conv "PASCAL") set(signature_call_conv "PASCAL")
ELSE(HAVE_WINDOWS_H) else(HAVE_WINDOWS_H)
add_header_include(HAVE_SYS_TYPES_H "sys/types.h") add_header_include(HAVE_SYS_TYPES_H "sys/types.h")
add_header_include(HAVE_SYS_SOCKET_H "sys/socket.h") add_header_include(HAVE_SYS_SOCKET_H "sys/socket.h")
ENDIF(HAVE_WINDOWS_H) endif(HAVE_WINDOWS_H)
SET(EXTRA_DEFINES_BACKUP "${EXTRA_DEFINES}") set(EXTRA_DEFINES_BACKUP "${EXTRA_DEFINES}")
SET(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5") set(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5")
CURL_CHECK_C_SOURCE_COMPILES("recv(0, 0, 0, 0)" curl_cv_recv) curl_check_c_source_compiles("recv(0, 0, 0, 0)" curl_cv_recv)
IF(curl_cv_recv) if(curl_cv_recv)
# AC_CACHE_CHECK([types of arguments and return type for recv], # AC_CACHE_CHECK([types of arguments and return type for recv],
#[curl_cv_func_recv_args], [ #[curl_cv_func_recv_args], [
#SET(curl_cv_func_recv_args "unknown") #SET(curl_cv_func_recv_args "unknown")
#for recv_retv in 'int' 'ssize_t'; do #for recv_retv in 'int' 'ssize_t'; do
IF(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown") if(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")
FOREACH(recv_retv "int" "ssize_t" ) foreach(recv_retv "int" "ssize_t" )
FOREACH(recv_arg1 "int" "ssize_t" "SOCKET") foreach(recv_arg1 "int" "ssize_t" "SOCKET")
FOREACH(recv_arg2 "void *" "char *") foreach(recv_arg2 "void *" "char *")
FOREACH(recv_arg3 "size_t" "int" "socklen_t" "unsigned int") foreach(recv_arg3 "size_t" "int" "socklen_t" "unsigned int")
FOREACH(recv_arg4 "int" "unsigned int") foreach(recv_arg4 "int" "unsigned int")
IF(NOT curl_cv_func_recv_done) if(NOT curl_cv_func_recv_done)
SET(curl_cv_func_recv_test "UNKNOWN") set(curl_cv_func_recv_test "UNKNOWN")
SET(extern_line "extern ${recv_retv} ${signature_call_conv} recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4})\;") set(extern_line "extern ${recv_retv} ${signature_call_conv} recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4})\;")
SET(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5") set(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5")
CURL_CHECK_C_SOURCE_COMPILES(" curl_check_c_source_compiles("
${recv_arg1} s=0; ${recv_arg1} s=0;
${recv_arg2} buf=0; ${recv_arg2} buf=0;
${recv_arg3} len=0; ${recv_arg3} len=0;
@ -52,62 +52,62 @@ IF(curl_cv_recv)
${recv_retv} res = recv(s, buf, len, flags)" ${recv_retv} res = recv(s, buf, len, flags)"
curl_cv_func_recv_test curl_cv_func_recv_test
"${recv_retv} recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4})") "${recv_retv} recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4})")
IF(curl_cv_func_recv_test) if(curl_cv_func_recv_test)
SET(curl_cv_func_recv_args set(curl_cv_func_recv_args
"${recv_arg1},${recv_arg2},${recv_arg3},${recv_arg4},${recv_retv}") "${recv_arg1},${recv_arg2},${recv_arg3},${recv_arg4},${recv_retv}")
SET(RECV_TYPE_ARG1 "${recv_arg1}") set(RECV_TYPE_ARG1 "${recv_arg1}")
SET(RECV_TYPE_ARG2 "${recv_arg2}") set(RECV_TYPE_ARG2 "${recv_arg2}")
SET(RECV_TYPE_ARG3 "${recv_arg3}") set(RECV_TYPE_ARG3 "${recv_arg3}")
SET(RECV_TYPE_ARG4 "${recv_arg4}") set(RECV_TYPE_ARG4 "${recv_arg4}")
SET(RECV_TYPE_RETV "${recv_retv}") set(RECV_TYPE_RETV "${recv_retv}")
SET(HAVE_RECV 1) set(HAVE_RECV 1)
SET(curl_cv_func_recv_done 1) set(curl_cv_func_recv_done 1)
ENDIF(curl_cv_func_recv_test) endif(curl_cv_func_recv_test)
ENDIF(NOT curl_cv_func_recv_done) endif(NOT curl_cv_func_recv_done)
ENDFOREACH(recv_arg4) endforeach(recv_arg4)
ENDFOREACH(recv_arg3) endforeach(recv_arg3)
ENDFOREACH(recv_arg2) endforeach(recv_arg2)
ENDFOREACH(recv_arg1) endforeach(recv_arg1)
ENDFOREACH(recv_retv) endforeach(recv_retv)
ELSE(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown") else(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")
STRING(REGEX REPLACE "^([^,]*),[^,]*,[^,]*,[^,]*,[^,]*$" "\\1" RECV_TYPE_ARG1 "${curl_cv_func_recv_args}") string(REGEX REPLACE "^([^,]*),[^,]*,[^,]*,[^,]*,[^,]*$" "\\1" RECV_TYPE_ARG1 "${curl_cv_func_recv_args}")
STRING(REGEX REPLACE "^[^,]*,([^,]*),[^,]*,[^,]*,[^,]*$" "\\1" RECV_TYPE_ARG2 "${curl_cv_func_recv_args}") string(REGEX REPLACE "^[^,]*,([^,]*),[^,]*,[^,]*,[^,]*$" "\\1" RECV_TYPE_ARG2 "${curl_cv_func_recv_args}")
STRING(REGEX REPLACE "^[^,]*,[^,]*,([^,]*),[^,]*,[^,]*$" "\\1" RECV_TYPE_ARG3 "${curl_cv_func_recv_args}") string(REGEX REPLACE "^[^,]*,[^,]*,([^,]*),[^,]*,[^,]*$" "\\1" RECV_TYPE_ARG3 "${curl_cv_func_recv_args}")
STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,([^,]*),[^,]*$" "\\1" RECV_TYPE_ARG4 "${curl_cv_func_recv_args}") string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,([^,]*),[^,]*$" "\\1" RECV_TYPE_ARG4 "${curl_cv_func_recv_args}")
STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,([^,]*)$" "\\1" RECV_TYPE_RETV "${curl_cv_func_recv_args}") string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,([^,]*)$" "\\1" RECV_TYPE_RETV "${curl_cv_func_recv_args}")
#MESSAGE("RECV_TYPE_ARG1 ${RECV_TYPE_ARG1}") #MESSAGE("RECV_TYPE_ARG1 ${RECV_TYPE_ARG1}")
#MESSAGE("RECV_TYPE_ARG2 ${RECV_TYPE_ARG2}") #MESSAGE("RECV_TYPE_ARG2 ${RECV_TYPE_ARG2}")
#MESSAGE("RECV_TYPE_ARG3 ${RECV_TYPE_ARG3}") #MESSAGE("RECV_TYPE_ARG3 ${RECV_TYPE_ARG3}")
#MESSAGE("RECV_TYPE_ARG4 ${RECV_TYPE_ARG4}") #MESSAGE("RECV_TYPE_ARG4 ${RECV_TYPE_ARG4}")
#MESSAGE("RECV_TYPE_RETV ${RECV_TYPE_RETV}") #MESSAGE("RECV_TYPE_RETV ${RECV_TYPE_RETV}")
ENDIF(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown") endif(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")
IF("${curl_cv_func_recv_args}" STREQUAL "unknown") if("${curl_cv_func_recv_args}" STREQUAL "unknown")
MESSAGE(FATAL_ERROR "Cannot find proper types to use for recv args") message(FATAL_ERROR "Cannot find proper types to use for recv args")
ENDIF("${curl_cv_func_recv_args}" STREQUAL "unknown") endif("${curl_cv_func_recv_args}" STREQUAL "unknown")
ELSE(curl_cv_recv) else(curl_cv_recv)
MESSAGE(FATAL_ERROR "Unable to link function recv") message(FATAL_ERROR "Unable to link function recv")
ENDIF(curl_cv_recv) endif(curl_cv_recv)
SET(curl_cv_func_recv_args "${curl_cv_func_recv_args}" CACHE INTERNAL "Arguments for recv") set(curl_cv_func_recv_args "${curl_cv_func_recv_args}" CACHE INTERNAL "Arguments for recv")
SET(HAVE_RECV 1) set(HAVE_RECV 1)
CURL_CHECK_C_SOURCE_COMPILES("send(0, 0, 0, 0)" curl_cv_send) curl_check_c_source_compiles("send(0, 0, 0, 0)" curl_cv_send)
IF(curl_cv_send) if(curl_cv_send)
# AC_CACHE_CHECK([types of arguments and return type for send], # AC_CACHE_CHECK([types of arguments and return type for send],
#[curl_cv_func_send_args], [ #[curl_cv_func_send_args], [
#SET(curl_cv_func_send_args "unknown") #SET(curl_cv_func_send_args "unknown")
#for send_retv in 'int' 'ssize_t'; do #for send_retv in 'int' 'ssize_t'; do
IF(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown") if(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown")
FOREACH(send_retv "int" "ssize_t" ) foreach(send_retv "int" "ssize_t" )
FOREACH(send_arg1 "int" "ssize_t" "SOCKET") foreach(send_arg1 "int" "ssize_t" "SOCKET")
FOREACH(send_arg2 "const void *" "void *" "char *" "const char *") foreach(send_arg2 "const void *" "void *" "char *" "const char *")
FOREACH(send_arg3 "size_t" "int" "socklen_t" "unsigned int") foreach(send_arg3 "size_t" "int" "socklen_t" "unsigned int")
FOREACH(send_arg4 "int" "unsigned int") foreach(send_arg4 "int" "unsigned int")
IF(NOT curl_cv_func_send_done) if(NOT curl_cv_func_send_done)
SET(curl_cv_func_send_test "UNKNOWN") set(curl_cv_func_send_test "UNKNOWN")
SET(extern_line "extern ${send_retv} ${signature_call_conv} send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4})\;") set(extern_line "extern ${send_retv} ${signature_call_conv} send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4})\;")
SET(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5") set(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5")
CURL_CHECK_C_SOURCE_COMPILES(" curl_check_c_source_compiles("
${send_arg1} s=0; ${send_arg1} s=0;
${send_arg2} buf=0; ${send_arg2} buf=0;
${send_arg3} len=0; ${send_arg3} len=0;
@ -115,136 +115,136 @@ IF(curl_cv_send)
${send_retv} res = send(s, buf, len, flags)" ${send_retv} res = send(s, buf, len, flags)"
curl_cv_func_send_test curl_cv_func_send_test
"${send_retv} send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4})") "${send_retv} send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4})")
IF(curl_cv_func_send_test) if(curl_cv_func_send_test)
#MESSAGE("Found arguments: ${curl_cv_func_send_test}") #MESSAGE("Found arguments: ${curl_cv_func_send_test}")
STRING(REGEX REPLACE "(const) .*" "\\1" send_qual_arg2 "${send_arg2}") string(REGEX REPLACE "(const) .*" "\\1" send_qual_arg2 "${send_arg2}")
STRING(REGEX REPLACE "const (.*)" "\\1" send_arg2 "${send_arg2}") string(REGEX REPLACE "const (.*)" "\\1" send_arg2 "${send_arg2}")
SET(curl_cv_func_send_args set(curl_cv_func_send_args
"${send_arg1},${send_arg2},${send_arg3},${send_arg4},${send_retv},${send_qual_arg2}") "${send_arg1},${send_arg2},${send_arg3},${send_arg4},${send_retv},${send_qual_arg2}")
SET(SEND_TYPE_ARG1 "${send_arg1}") set(SEND_TYPE_ARG1 "${send_arg1}")
SET(SEND_TYPE_ARG2 "${send_arg2}") set(SEND_TYPE_ARG2 "${send_arg2}")
SET(SEND_TYPE_ARG3 "${send_arg3}") set(SEND_TYPE_ARG3 "${send_arg3}")
SET(SEND_TYPE_ARG4 "${send_arg4}") set(SEND_TYPE_ARG4 "${send_arg4}")
SET(SEND_TYPE_RETV "${send_retv}") set(SEND_TYPE_RETV "${send_retv}")
SET(HAVE_SEND 1) set(HAVE_SEND 1)
SET(curl_cv_func_send_done 1) set(curl_cv_func_send_done 1)
ENDIF(curl_cv_func_send_test) endif(curl_cv_func_send_test)
ENDIF(NOT curl_cv_func_send_done) endif(NOT curl_cv_func_send_done)
ENDFOREACH(send_arg4) endforeach(send_arg4)
ENDFOREACH(send_arg3) endforeach(send_arg3)
ENDFOREACH(send_arg2) endforeach(send_arg2)
ENDFOREACH(send_arg1) endforeach(send_arg1)
ENDFOREACH(send_retv) endforeach(send_retv)
ELSE(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown") else(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown")
STRING(REGEX REPLACE "^([^,]*),[^,]*,[^,]*,[^,]*,[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG1 "${curl_cv_func_send_args}") string(REGEX REPLACE "^([^,]*),[^,]*,[^,]*,[^,]*,[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG1 "${curl_cv_func_send_args}")
STRING(REGEX REPLACE "^[^,]*,([^,]*),[^,]*,[^,]*,[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG2 "${curl_cv_func_send_args}") string(REGEX REPLACE "^[^,]*,([^,]*),[^,]*,[^,]*,[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG2 "${curl_cv_func_send_args}")
STRING(REGEX REPLACE "^[^,]*,[^,]*,([^,]*),[^,]*,[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG3 "${curl_cv_func_send_args}") string(REGEX REPLACE "^[^,]*,[^,]*,([^,]*),[^,]*,[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG3 "${curl_cv_func_send_args}")
STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,([^,]*),[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG4 "${curl_cv_func_send_args}") string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,([^,]*),[^,]*,[^,]*$" "\\1" SEND_TYPE_ARG4 "${curl_cv_func_send_args}")
STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,([^,]*),[^,]*$" "\\1" SEND_TYPE_RETV "${curl_cv_func_send_args}") string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,([^,]*),[^,]*$" "\\1" SEND_TYPE_RETV "${curl_cv_func_send_args}")
STRING(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,([^,]*)$" "\\1" SEND_QUAL_ARG2 "${curl_cv_func_send_args}") string(REGEX REPLACE "^[^,]*,[^,]*,[^,]*,[^,]*,[^,]*,([^,]*)$" "\\1" SEND_QUAL_ARG2 "${curl_cv_func_send_args}")
#MESSAGE("SEND_TYPE_ARG1 ${SEND_TYPE_ARG1}") #MESSAGE("SEND_TYPE_ARG1 ${SEND_TYPE_ARG1}")
#MESSAGE("SEND_TYPE_ARG2 ${SEND_TYPE_ARG2}") #MESSAGE("SEND_TYPE_ARG2 ${SEND_TYPE_ARG2}")
#MESSAGE("SEND_TYPE_ARG3 ${SEND_TYPE_ARG3}") #MESSAGE("SEND_TYPE_ARG3 ${SEND_TYPE_ARG3}")
#MESSAGE("SEND_TYPE_ARG4 ${SEND_TYPE_ARG4}") #MESSAGE("SEND_TYPE_ARG4 ${SEND_TYPE_ARG4}")
#MESSAGE("SEND_TYPE_RETV ${SEND_TYPE_RETV}") #MESSAGE("SEND_TYPE_RETV ${SEND_TYPE_RETV}")
#MESSAGE("SEND_QUAL_ARG2 ${SEND_QUAL_ARG2}") #MESSAGE("SEND_QUAL_ARG2 ${SEND_QUAL_ARG2}")
ENDIF(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown") endif(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown")
IF("${curl_cv_func_send_args}" STREQUAL "unknown") if("${curl_cv_func_send_args}" STREQUAL "unknown")
MESSAGE(FATAL_ERROR "Cannot find proper types to use for send args") message(FATAL_ERROR "Cannot find proper types to use for send args")
ENDIF("${curl_cv_func_send_args}" STREQUAL "unknown") endif("${curl_cv_func_send_args}" STREQUAL "unknown")
SET(SEND_QUAL_ARG2 "const") set(SEND_QUAL_ARG2 "const")
ELSE(curl_cv_send) else(curl_cv_send)
MESSAGE(FATAL_ERROR "Unable to link function send") message(FATAL_ERROR "Unable to link function send")
ENDIF(curl_cv_send) endif(curl_cv_send)
SET(curl_cv_func_send_args "${curl_cv_func_send_args}" CACHE INTERNAL "Arguments for send") set(curl_cv_func_send_args "${curl_cv_func_send_args}" CACHE INTERNAL "Arguments for send")
SET(HAVE_SEND 1) set(HAVE_SEND 1)
SET(EXTRA_DEFINES "${EXTRA_DEFINES}\n${headers_hack}\n#define __unused5") set(EXTRA_DEFINES "${EXTRA_DEFINES}\n${headers_hack}\n#define __unused5")
CURL_CHECK_C_SOURCE_COMPILES("int flag = MSG_NOSIGNAL" HAVE_MSG_NOSIGNAL) curl_check_c_source_compiles("int flag = MSG_NOSIGNAL" HAVE_MSG_NOSIGNAL)
SET(EXTRA_DEFINES "__unused1\n#undef inline\n#define __unused2") set(EXTRA_DEFINES "__unused1\n#undef inline\n#define __unused2")
SET(HEADER_INCLUDES) set(HEADER_INCLUDES)
SET(headers_hack) set(headers_hack)
MACRO(add_header_include check header) macro(add_header_include check header)
IF(${check}) if(${check})
SET(headers_hack set(headers_hack
"${headers_hack}\n#include <${header}>") "${headers_hack}\n#include <${header}>")
#SET(HEADER_INCLUDES #SET(HEADER_INCLUDES
# ${HEADER_INCLUDES} # ${HEADER_INCLUDES}
# "${header}") # "${header}")
ENDIF(${check}) endif(${check})
ENDMACRO(add_header_include header) endmacro(add_header_include header)
IF(HAVE_WINDOWS_H) if(HAVE_WINDOWS_H)
SET(EXTRA_DEFINES ${EXTRA_DEFINES} set(EXTRA_DEFINES ${EXTRA_DEFINES}
"__unused7\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif\n#define __unused3") "__unused7\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif\n#define __unused3")
add_header_include(HAVE_WINDOWS_H "windows.h") add_header_include(HAVE_WINDOWS_H "windows.h")
add_header_include(HAVE_WINSOCK2_H "winsock2.h") add_header_include(HAVE_WINSOCK2_H "winsock2.h")
add_header_include(HAVE_WINSOCK_H "winsock.h") add_header_include(HAVE_WINSOCK_H "winsock.h")
ELSE(HAVE_WINDOWS_H) else(HAVE_WINDOWS_H)
add_header_include(HAVE_SYS_TYPES_H "sys/types.h") add_header_include(HAVE_SYS_TYPES_H "sys/types.h")
add_header_include(HAVE_SYS_TIME_H "sys/time.h") add_header_include(HAVE_SYS_TIME_H "sys/time.h")
add_header_include(TIME_WITH_SYS_TIME "time.h") add_header_include(TIME_WITH_SYS_TIME "time.h")
add_header_include(HAVE_TIME_H "time.h") add_header_include(HAVE_TIME_H "time.h")
ENDIF(HAVE_WINDOWS_H) endif(HAVE_WINDOWS_H)
SET(EXTRA_DEFINES "${EXTRA_DEFINES}\n${headers_hack}\n#define __unused5") set(EXTRA_DEFINES "${EXTRA_DEFINES}\n${headers_hack}\n#define __unused5")
CURL_CHECK_C_SOURCE_COMPILES("struct timeval ts;\nts.tv_sec = 0;\nts.tv_usec = 0" HAVE_STRUCT_TIMEVAL) curl_check_c_source_compiles("struct timeval ts;\nts.tv_sec = 0;\nts.tv_usec = 0" HAVE_STRUCT_TIMEVAL)
INCLUDE(CurlCheckCSourceRuns) include(CurlCheckCSourceRuns)
SET(EXTRA_DEFINES) set(EXTRA_DEFINES)
SET(HEADER_INCLUDES) set(HEADER_INCLUDES)
IF(HAVE_SYS_POLL_H) if(HAVE_SYS_POLL_H)
SET(HEADER_INCLUDES "sys/poll.h") set(HEADER_INCLUDES "sys/poll.h")
ENDIF(HAVE_SYS_POLL_H) endif(HAVE_SYS_POLL_H)
CURL_CHECK_C_SOURCE_RUNS("return poll((void *)0, 0, 10 /*ms*/)" HAVE_POLL_FINE) curl_check_c_source_runs("return poll((void *)0, 0, 10 /*ms*/)" HAVE_POLL_FINE)
SET(HAVE_SIG_ATOMIC_T 1) set(HAVE_SIG_ATOMIC_T 1)
SET(EXTRA_DEFINES) set(EXTRA_DEFINES)
SET(HEADER_INCLUDES) set(HEADER_INCLUDES)
IF(HAVE_SIGNAL_H) if(HAVE_SIGNAL_H)
SET(HEADER_INCLUDES "signal.h") set(HEADER_INCLUDES "signal.h")
SET(CMAKE_EXTRA_INCLUDE_FILES "signal.h") set(CMAKE_EXTRA_INCLUDE_FILES "signal.h")
ENDIF(HAVE_SIGNAL_H) endif(HAVE_SIGNAL_H)
CHECK_TYPE_SIZE("sig_atomic_t" SIZEOF_SIG_ATOMIC_T) check_type_size("sig_atomic_t" SIZEOF_SIG_ATOMIC_T)
IF(HAVE_SIZEOF_SIG_ATOMIC_T) if(HAVE_SIZEOF_SIG_ATOMIC_T)
CURL_CHECK_C_SOURCE_COMPILES("static volatile sig_atomic_t dummy = 0" HAVE_SIG_ATOMIC_T_NOT_VOLATILE) curl_check_c_source_compiles("static volatile sig_atomic_t dummy = 0" HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
IF(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE) if(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
SET(HAVE_SIG_ATOMIC_T_VOLATILE 1) set(HAVE_SIG_ATOMIC_T_VOLATILE 1)
ENDIF(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE) endif(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
ENDIF(HAVE_SIZEOF_SIG_ATOMIC_T) endif(HAVE_SIZEOF_SIG_ATOMIC_T)
SET(CHECK_TYPE_SIZE_PREINCLUDE set(CHECK_TYPE_SIZE_PREINCLUDE
"#undef inline") "#undef inline")
IF(HAVE_WINDOWS_H) if(HAVE_WINDOWS_H)
SET(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE} set(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE}
#ifndef WIN32_LEAN_AND_MEAN #ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN
#endif #endif
#include <windows.h>") #include <windows.h>")
IF(HAVE_WINSOCK2_H) if(HAVE_WINSOCK2_H)
SET(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE}\n#include <winsock2.h>") set(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE}\n#include <winsock2.h>")
ENDIF(HAVE_WINSOCK2_H) endif(HAVE_WINSOCK2_H)
ELSE(HAVE_WINDOWS_H) else(HAVE_WINDOWS_H)
IF(HAVE_SYS_SOCKET_H) if(HAVE_SYS_SOCKET_H)
SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES} set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
"sys/socket.h") "sys/socket.h")
ENDIF(HAVE_SYS_SOCKET_H) endif(HAVE_SYS_SOCKET_H)
IF(HAVE_NETINET_IN_H) if(HAVE_NETINET_IN_H)
SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES} set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
"netinet/in.h") "netinet/in.h")
ENDIF(HAVE_NETINET_IN_H) endif(HAVE_NETINET_IN_H)
IF(HAVE_ARPA_INET_H) if(HAVE_ARPA_INET_H)
SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES} set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
"arpa/inet.h") "arpa/inet.h")
ENDIF(HAVE_ARPA_INET_H) endif(HAVE_ARPA_INET_H)
ENDIF(HAVE_WINDOWS_H) endif(HAVE_WINDOWS_H)
CHECK_TYPE_SIZE("struct sockaddr_storage" SIZEOF_STRUCT_SOCKADDR_STORAGE) check_type_size("struct sockaddr_storage" SIZEOF_STRUCT_SOCKADDR_STORAGE)
IF(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE) if(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)
SET(HAVE_STRUCT_SOCKADDR_STORAGE 1) set(HAVE_STRUCT_SOCKADDR_STORAGE 1)
ENDIF(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE) endif(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)

226
CMake/Platforms/WindowsCache.cmake
View File

@ -1,121 +1,121 @@
IF(NOT UNIX) if(NOT UNIX)
IF(WIN32) if(WIN32)
SET(HAVE_LIBDL 0) set(HAVE_LIBDL 0)
SET(HAVE_LIBUCB 0) set(HAVE_LIBUCB 0)
SET(HAVE_LIBSOCKET 0) set(HAVE_LIBSOCKET 0)
SET(NOT_NEED_LIBNSL 0) set(NOT_NEED_LIBNSL 0)
SET(HAVE_LIBNSL 0) set(HAVE_LIBNSL 0)
SET(HAVE_LIBZ 0) set(HAVE_LIBZ 0)
SET(HAVE_LIBCRYPTO 0) set(HAVE_LIBCRYPTO 0)
SET(HAVE_DLOPEN 0) set(HAVE_DLOPEN 0)
SET(HAVE_ALLOCA_H 0) set(HAVE_ALLOCA_H 0)
SET(HAVE_ARPA_INET_H 0) set(HAVE_ARPA_INET_H 0)
SET(HAVE_DLFCN_H 0) set(HAVE_DLFCN_H 0)
SET(HAVE_FCNTL_H 1) set(HAVE_FCNTL_H 1)
SET(HAVE_FEATURES_H 0) set(HAVE_FEATURES_H 0)
SET(HAVE_INTTYPES_H 0) set(HAVE_INTTYPES_H 0)
SET(HAVE_IO_H 1) set(HAVE_IO_H 1)
SET(HAVE_MALLOC_H 1) set(HAVE_MALLOC_H 1)
SET(HAVE_MEMORY_H 1) set(HAVE_MEMORY_H 1)
SET(HAVE_NETDB_H 0) set(HAVE_NETDB_H 0)
SET(HAVE_NETINET_IF_ETHER_H 0) set(HAVE_NETINET_IF_ETHER_H 0)
SET(HAVE_NETINET_IN_H 0) set(HAVE_NETINET_IN_H 0)
SET(HAVE_NET_IF_H 0) set(HAVE_NET_IF_H 0)
SET(HAVE_PROCESS_H 1) set(HAVE_PROCESS_H 1)
SET(HAVE_PWD_H 0) set(HAVE_PWD_H 0)
SET(HAVE_SETJMP_H 1) set(HAVE_SETJMP_H 1)
SET(HAVE_SGTTY_H 0) set(HAVE_SGTTY_H 0)
SET(HAVE_SIGNAL_H 1) set(HAVE_SIGNAL_H 1)
SET(HAVE_SOCKIO_H 0) set(HAVE_SOCKIO_H 0)
SET(HAVE_STDINT_H 0) set(HAVE_STDINT_H 0)
SET(HAVE_STDLIB_H 1) set(HAVE_STDLIB_H 1)
SET(HAVE_STRINGS_H 0) set(HAVE_STRINGS_H 0)
SET(HAVE_STRING_H 1) set(HAVE_STRING_H 1)
SET(HAVE_SYS_PARAM_H 0) set(HAVE_SYS_PARAM_H 0)
SET(HAVE_SYS_POLL_H 0) set(HAVE_SYS_POLL_H 0)
SET(HAVE_SYS_SELECT_H 0) set(HAVE_SYS_SELECT_H 0)
SET(HAVE_SYS_SOCKET_H 0) set(HAVE_SYS_SOCKET_H 0)
SET(HAVE_SYS_SOCKIO_H 0) set(HAVE_SYS_SOCKIO_H 0)
SET(HAVE_SYS_STAT_H 1) set(HAVE_SYS_STAT_H 1)
SET(HAVE_SYS_TIME_H 0) set(HAVE_SYS_TIME_H 0)
SET(HAVE_SYS_TYPES_H 1) set(HAVE_SYS_TYPES_H 1)
SET(HAVE_SYS_UTIME_H 1) set(HAVE_SYS_UTIME_H 1)
SET(HAVE_TERMIOS_H 0) set(HAVE_TERMIOS_H 0)
SET(HAVE_TERMIO_H 0) set(HAVE_TERMIO_H 0)
SET(HAVE_TIME_H 1) set(HAVE_TIME_H 1)
SET(HAVE_UNISTD_H 0) set(HAVE_UNISTD_H 0)
SET(HAVE_UTIME_H 0) set(HAVE_UTIME_H 0)
SET(HAVE_X509_H 0) set(HAVE_X509_H 0)
SET(HAVE_ZLIB_H 0) set(HAVE_ZLIB_H 0)
SET(HAVE_SIZEOF_LONG_DOUBLE 1) set(HAVE_SIZEOF_LONG_DOUBLE 1)
SET(SIZEOF_LONG_DOUBLE 8) set(SIZEOF_LONG_DOUBLE 8)
SET(HAVE_SOCKET 1) set(HAVE_SOCKET 1)
SET(HAVE_POLL 0) set(HAVE_POLL 0)
SET(HAVE_SELECT 1) set(HAVE_SELECT 1)
SET(HAVE_STRDUP 1) set(HAVE_STRDUP 1)
SET(HAVE_STRSTR 1) set(HAVE_STRSTR 1)
SET(HAVE_STRTOK_R 0) set(HAVE_STRTOK_R 0)
SET(HAVE_STRFTIME 1) set(HAVE_STRFTIME 1)
SET(HAVE_UNAME 0) set(HAVE_UNAME 0)
SET(HAVE_STRCASECMP 0) set(HAVE_STRCASECMP 0)
SET(HAVE_STRICMP 1) set(HAVE_STRICMP 1)
SET(HAVE_STRCMPI 1) set(HAVE_STRCMPI 1)
SET(HAVE_GETHOSTBYADDR 1) set(HAVE_GETHOSTBYADDR 1)
SET(HAVE_GETTIMEOFDAY 0) set(HAVE_GETTIMEOFDAY 0)
SET(HAVE_INET_ADDR 1) set(HAVE_INET_ADDR 1)
SET(HAVE_INET_NTOA 1) set(HAVE_INET_NTOA 1)
SET(HAVE_INET_NTOA_R 0) set(HAVE_INET_NTOA_R 0)
SET(HAVE_TCGETATTR 0) set(HAVE_TCGETATTR 0)
SET(HAVE_TCSETATTR 0) set(HAVE_TCSETATTR 0)
SET(HAVE_PERROR 1) set(HAVE_PERROR 1)
SET(HAVE_CLOSESOCKET 1) set(HAVE_CLOSESOCKET 1)
SET(HAVE_SETVBUF 0) set(HAVE_SETVBUF 0)
SET(HAVE_SIGSETJMP 0) set(HAVE_SIGSETJMP 0)
SET(HAVE_GETPASS_R 0) set(HAVE_GETPASS_R 0)
SET(HAVE_STRLCAT 0) set(HAVE_STRLCAT 0)
SET(HAVE_GETPWUID 0) set(HAVE_GETPWUID 0)
SET(HAVE_GETEUID 0) set(HAVE_GETEUID 0)
SET(HAVE_UTIME 1) set(HAVE_UTIME 1)
SET(HAVE_RAND_EGD 0) set(HAVE_RAND_EGD 0)
SET(HAVE_RAND_SCREEN 0) set(HAVE_RAND_SCREEN 0)
SET(HAVE_RAND_STATUS 0) set(HAVE_RAND_STATUS 0)
SET(HAVE_GMTIME_R 0) set(HAVE_GMTIME_R 0)
SET(HAVE_LOCALTIME_R 0) set(HAVE_LOCALTIME_R 0)
SET(HAVE_GETHOSTBYADDR_R 0) set(HAVE_GETHOSTBYADDR_R 0)
SET(HAVE_GETHOSTBYNAME_R 0) set(HAVE_GETHOSTBYNAME_R 0)
SET(HAVE_SIGNAL_FUNC 1) set(HAVE_SIGNAL_FUNC 1)
SET(HAVE_SIGNAL_MACRO 0) set(HAVE_SIGNAL_MACRO 0)
SET(HAVE_GETHOSTBYADDR_R_5 0) set(HAVE_GETHOSTBYADDR_R_5 0)
SET(HAVE_GETHOSTBYADDR_R_5_REENTRANT 0) set(HAVE_GETHOSTBYADDR_R_5_REENTRANT 0)
SET(HAVE_GETHOSTBYADDR_R_7 0) set(HAVE_GETHOSTBYADDR_R_7 0)
SET(HAVE_GETHOSTBYADDR_R_7_REENTRANT 0) set(HAVE_GETHOSTBYADDR_R_7_REENTRANT 0)
SET(HAVE_GETHOSTBYADDR_R_8 0) set(HAVE_GETHOSTBYADDR_R_8 0)
SET(HAVE_GETHOSTBYADDR_R_8_REENTRANT 0) set(HAVE_GETHOSTBYADDR_R_8_REENTRANT 0)
SET(HAVE_GETHOSTBYNAME_R_3 0) set(HAVE_GETHOSTBYNAME_R_3 0)
SET(HAVE_GETHOSTBYNAME_R_3_REENTRANT 0) set(HAVE_GETHOSTBYNAME_R_3_REENTRANT 0)
SET(HAVE_GETHOSTBYNAME_R_5 0) set(HAVE_GETHOSTBYNAME_R_5 0)
SET(HAVE_GETHOSTBYNAME_R_5_REENTRANT 0) set(HAVE_GETHOSTBYNAME_R_5_REENTRANT 0)
SET(HAVE_GETHOSTBYNAME_R_6 0) set(HAVE_GETHOSTBYNAME_R_6 0)
SET(HAVE_GETHOSTBYNAME_R_6_REENTRANT 0) set(HAVE_GETHOSTBYNAME_R_6_REENTRANT 0)
SET(TIME_WITH_SYS_TIME 0) set(TIME_WITH_SYS_TIME 0)
SET(HAVE_O_NONBLOCK 0) set(HAVE_O_NONBLOCK 0)
SET(HAVE_IN_ADDR_T 0) set(HAVE_IN_ADDR_T 0)
SET(HAVE_INET_NTOA_R_DECL 0) set(HAVE_INET_NTOA_R_DECL 0)
SET(HAVE_INET_NTOA_R_DECL_REENTRANT 0) set(HAVE_INET_NTOA_R_DECL_REENTRANT 0)
SET(HAVE_GETADDRINFO 0) set(HAVE_GETADDRINFO 0)
SET(STDC_HEADERS 1) set(STDC_HEADERS 1)
SET(RETSIGTYPE_TEST 1) set(RETSIGTYPE_TEST 1)
SET(HAVE_SIGACTION 0) set(HAVE_SIGACTION 0)
SET(HAVE_MACRO_SIGSETJMP 0) set(HAVE_MACRO_SIGSETJMP 0)
ELSE(WIN32) else(WIN32)
MESSAGE("This file should be included on Windows platform only") message("This file should be included on Windows platform only")
ENDIF(WIN32) endif(WIN32)
ENDIF(NOT UNIX) endif(NOT UNIX)

46
CMake/Utilities.cmake
View File

@ -1,31 +1,31 @@
# File containing various utilities # File containing various utilities
# Converts a CMake list to a string containing elements separated by spaces # Converts a CMake list to a string containing elements separated by spaces
FUNCTION(TO_LIST_SPACES _LIST_NAME OUTPUT_VAR) function(TO_LIST_SPACES _LIST_NAME OUTPUT_VAR)
SET(NEW_LIST_SPACE) set(NEW_LIST_SPACE)
FOREACH(ITEM ${${_LIST_NAME}}) foreach(ITEM ${${_LIST_NAME}})
SET(NEW_LIST_SPACE "${NEW_LIST_SPACE} ${ITEM}") set(NEW_LIST_SPACE "${NEW_LIST_SPACE} ${ITEM}")
ENDFOREACH() endforeach()
STRING(STRIP ${NEW_LIST_SPACE} NEW_LIST_SPACE) string(STRIP ${NEW_LIST_SPACE} NEW_LIST_SPACE)
SET(${OUTPUT_VAR} "${NEW_LIST_SPACE}" PARENT_SCOPE) set(${OUTPUT_VAR} "${NEW_LIST_SPACE}" PARENT_SCOPE)
ENDFUNCTION() endfunction()
# Appends a lis of item to a string which is a space-separated list, if they don't already exist. # Appends a lis of item to a string which is a space-separated list, if they don't already exist.
FUNCTION(LIST_SPACES_APPEND_ONCE LIST_NAME) function(LIST_SPACES_APPEND_ONCE LIST_NAME)
STRING(REPLACE " " ";" _LIST ${${LIST_NAME}}) string(REPLACE " " ";" _LIST ${${LIST_NAME}})
LIST(APPEND _LIST ${ARGN}) list(APPEND _LIST ${ARGN})
LIST(REMOVE_DUPLICATES _LIST) list(REMOVE_DUPLICATES _LIST)
TO_LIST_SPACES(_LIST NEW_LIST_SPACE) to_list_spaces(_LIST NEW_LIST_SPACE)
SET(${LIST_NAME} "${NEW_LIST_SPACE}" PARENT_SCOPE) set(${LIST_NAME} "${NEW_LIST_SPACE}" PARENT_SCOPE)
ENDFUNCTION() endfunction()
# Convinience function that does the same as LIST(FIND ...) but with a TRUE/FALSE return value. # Convinience function that does the same as LIST(FIND ...) but with a TRUE/FALSE return value.
# Ex: IN_STR_LIST(MY_LIST "Searched item" WAS_FOUND) # Ex: IN_STR_LIST(MY_LIST "Searched item" WAS_FOUND)
FUNCTION(IN_STR_LIST LIST_NAME ITEM_SEARCHED RETVAL) function(IN_STR_LIST LIST_NAME ITEM_SEARCHED RETVAL)
LIST(FIND ${LIST_NAME} ${ITEM_SEARCHED} FIND_POS) list(FIND ${LIST_NAME} ${ITEM_SEARCHED} FIND_POS)
IF(${FIND_POS} EQUAL -1) if(${FIND_POS} EQUAL -1)
SET(${RETVAL} FALSE PARENT_SCOPE) set(${RETVAL} FALSE PARENT_SCOPE)
ELSE() else()
SET(${RETVAL} TRUE PARENT_SCOPE) set(${RETVAL} TRUE PARENT_SCOPE)
ENDIF() endif()
ENDFUNCTION() endfunction()

1048
CMakeLists.txt
View File

File diff suppressed because it is too large Load Diff

86
lib/CMakeLists.txt
View File

@ -1,22 +1,22 @@
SET(LIB_NAME libcurl) set(LIB_NAME libcurl)
CONFIGURE_FILE(${CURL_SOURCE_DIR}/include/curl/curlbuild.h.cmake configure_file(${CURL_SOURCE_DIR}/include/curl/curlbuild.h.cmake
${CURL_BINARY_DIR}/include/curl/curlbuild.h) ${CURL_BINARY_DIR}/include/curl/curlbuild.h)
CONFIGURE_FILE(config.h.cmake configure_file(config.h.cmake
${CMAKE_CURRENT_BINARY_DIR}/config.h) ${CMAKE_CURRENT_BINARY_DIR}/config.h)
TRANSFORM_MAKEFILE_INC("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake") transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
INCLUDE(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake) include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
LIST(APPEND HHEADERS list(APPEND HHEADERS
${CMAKE_CURRENT_BINARY_DIR}/config.h ${CMAKE_CURRENT_BINARY_DIR}/config.h
${CURL_BINARY_DIR}/include/curl/curlbuild.h ${CURL_BINARY_DIR}/include/curl/curlbuild.h
) )
IF(MSVC) if(MSVC)
LIST(APPEND CSOURCES libcurl.rc) list(APPEND CSOURCES libcurl.rc)
ENDIF() endif()
# SET(CSOURCES # SET(CSOURCES
# # memdebug.c -not used # # memdebug.c -not used
@ -49,8 +49,8 @@ ENDIF()
# ) # )
# ENDIF(NOT HAVE_STRTOLL AND NOT HAVE__STRTOI64) # ENDIF(NOT HAVE_STRTOLL AND NOT HAVE__STRTOI64)
IF(HAVE_FEATURES_H) if(HAVE_FEATURES_H)
SET_SOURCE_FILES_PROPERTIES( set_source_files_properties(
cookie.c cookie.c
easy.c easy.c
formdata.c formdata.c
@ -65,57 +65,57 @@ IF(HAVE_FEATURES_H)
transfer.c transfer.c
url.c url.c
COMPILE_FLAGS -D_BSD_SOURCE) COMPILE_FLAGS -D_BSD_SOURCE)
ENDIF(HAVE_FEATURES_H) endif(HAVE_FEATURES_H)
# The rest of the build # The rest of the build
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/../include) include_directories(${CMAKE_CURRENT_BINARY_DIR}/../include)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/..) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../include) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/..) include_directories(${CMAKE_CURRENT_BINARY_DIR}/..)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}) include_directories(${CMAKE_CURRENT_SOURCE_DIR})
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}) include_directories(${CMAKE_CURRENT_BINARY_DIR})
IF(CURL_STATICLIB) if(CURL_STATICLIB)
# Static lib # Static lib
SET(CURL_USER_DEFINED_DYNAMIC_OR_STATIC STATIC) set(CURL_USER_DEFINED_DYNAMIC_OR_STATIC STATIC)
ELSE() else()
# DLL / so dynamic lib # DLL / so dynamic lib
SET(CURL_USER_DEFINED_DYNAMIC_OR_STATIC SHARED) set(CURL_USER_DEFINED_DYNAMIC_OR_STATIC SHARED)
ENDIF() endif()
ADD_LIBRARY( add_library(
${LIB_NAME} ${LIB_NAME}
${CURL_USER_DEFINED_DYNAMIC_OR_STATIC} ${CURL_USER_DEFINED_DYNAMIC_OR_STATIC}
${HHEADERS} ${CSOURCES} ${HHEADERS} ${CSOURCES}
) )
TARGET_LINK_LIBRARIES(${LIB_NAME} ${CURL_LIBS}) target_link_libraries(${LIB_NAME} ${CURL_LIBS})
IF(WIN32) if(WIN32)
ADD_DEFINITIONS( -D_USRDLL ) add_definitions( -D_USRDLL )
ENDIF() endif()
SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES COMPILE_DEFINITIONS BUILDING_LIBCURL) set_target_properties(${LIB_NAME} PROPERTIES COMPILE_DEFINITIONS BUILDING_LIBCURL)
SETUP_CURL_DEPENDENCIES(${LIB_NAME}) setup_curl_dependencies(${LIB_NAME})
# Remove the "lib" prefix since the library is already named "libcurl". # Remove the "lib" prefix since the library is already named "libcurl".
SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES PREFIX "") set_target_properties(${LIB_NAME} PROPERTIES PREFIX "")
SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES IMPORT_PREFIX "") set_target_properties(${LIB_NAME} PROPERTIES IMPORT_PREFIX "")
IF(MSVC) if(MSVC)
IF(NOT BUILD_RELEASE_DEBUG_DIRS) if(NOT BUILD_RELEASE_DEBUG_DIRS)
# Ugly workaround to remove the "/debug" or "/release" in each output # Ugly workaround to remove the "/debug" or "/release" in each output
SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES PREFIX "../") set_target_properties(${LIB_NAME} PROPERTIES PREFIX "../")
SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES IMPORT_PREFIX "../") set_target_properties(${LIB_NAME} PROPERTIES IMPORT_PREFIX "../")
ENDIF() endif()
ENDIF() endif()
IF(WIN32) if(WIN32)
IF(NOT CURL_STATICLIB) if(NOT CURL_STATICLIB)
# Add "_imp" as a suffix before the extension to avoid conflicting with the statically linked "libcurl.lib" # Add "_imp" as a suffix before the extension to avoid conflicting with the statically linked "libcurl.lib"
SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES IMPORT_SUFFIX "_imp.lib") set_target_properties(${LIB_NAME} PROPERTIES IMPORT_SUFFIX "_imp.lib")
ENDIF() endif()
ENDIF() endif()

49
src/CMakeLists.txt
View File

@ -1,30 +1,30 @@
SET(EXE_NAME curl) set(EXE_NAME curl)
# First try to locate hugehelp.c to see if it has already been created # First try to locate hugehelp.c to see if it has already been created
# TODO Find the file WITHOUT adding a cache entry!!! Or else the user can delete the file after the script was first run, and the script won't notice it has gone. # TODO Find the file WITHOUT adding a cache entry!!! Or else the user can delete the file after the script was first run, and the script won't notice it has gone.
FIND_FILE(HUGEHELP_C_FILE hugehelp.c PATHS . NO_DEFAULT_PATH) find_file(HUGEHELP_C_FILE hugehelp.c PATHS . NO_DEFAULT_PATH)
IF (NOT HUGEHELP_C_FILE) if (NOT HUGEHELP_C_FILE)
MESSAGE(STATUS "Warning: hugehelp.c file was not generated before. Generating an 'empty' file...") message(STATUS "Warning: hugehelp.c file was not generated before. Generating an 'empty' file...")
FILE(WRITE hugehelp.c "/* built-in manual is disabled, blank function */\n#include \"hugehelp.h\"\nvoid hugehelp(void) {}\n\n") file(WRITE hugehelp.c "/* built-in manual is disabled, blank function */\n#include \"hugehelp.h\"\nvoid hugehelp(void) {}\n\n")
ENDIF() endif()
TRANSFORM_MAKEFILE_INC("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake") transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
INCLUDE(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake) include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
IF(MSVC) if(MSVC)
LIST(APPEND CURL_SOURCE curl.rc) list(APPEND CURL_SOURCE curl.rc)
ENDIF() endif()
ADD_EXECUTABLE( add_executable(
${EXE_NAME} ${EXE_NAME}
${curl_SOURCES} ${curl_SOURCES}
) )
SOURCE_GROUP("cURLX source files" FILES ${CURLX_ONES}) source_group("cURLX source files" FILES ${CURLX_ONES})
SOURCE_GROUP("cURL source files" FILES ${CURL_SOURCES}) source_group("cURL source files" FILES ${CURL_SOURCES})
SOURCE_GROUP("cURL header files" FILES ${CURL_HFILES}) source_group("cURL header files" FILES ${CURL_HFILES})
INCLUDE_DIRECTORIES( include_directories(
${CURL_SOURCE_DIR}/lib # To be able to reach "setup_once.h" ${CURL_SOURCE_DIR}/lib # To be able to reach "setup_once.h"
${CURL_BINARY_DIR}/lib # To be able to reach "config.h" ${CURL_BINARY_DIR}/lib # To be able to reach "config.h"
${CURL_BINARY_DIR}/include # To be able to reach "curl/curlbuild.h" ${CURL_BINARY_DIR}/include # To be able to reach "curl/curlbuild.h"
@ -32,8 +32,8 @@ INCLUDE_DIRECTORIES(
# Setup dependencies # Setup dependencies
SETUP_CURL_DEPENDENCIES(${EXE_NAME}) setup_curl_dependencies(${EXE_NAME})
TARGET_LINK_LIBRARIES( ${EXE_NAME} libcurl ) target_link_libraries( ${EXE_NAME} libcurl )
################################################################################ ################################################################################
@ -43,13 +43,14 @@ TARGET_LINK_LIBRARIES( ${EXE_NAME} libcurl )
#SET_TARGET_PROPERTIES(${EXE_NAME} LIBRARY_OUTPUT_DIRECTORY "blah blah blah") #SET_TARGET_PROPERTIES(${EXE_NAME} LIBRARY_OUTPUT_DIRECTORY "blah blah blah")
# Add the postfix to the executable since it is not added automatically as for modules and shared libraries # Add the postfix to the executable since it is not added automatically as for modules and shared libraries
SET_TARGET_PROPERTIES(${EXE_NAME} PROPERTIES DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}") set_target_properties(${EXE_NAME} PROPERTIES
DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
IF(MSVC) if(MSVC)
IF(NOT BUILD_RELEASE_DEBUG_DIRS) if(NOT BUILD_RELEASE_DEBUG_DIRS)
# Ugly workaround to remove the "/debug" or "/release" in each output # Ugly workaround to remove the "/debug" or "/release" in each output
SET_TARGET_PROPERTIES(${EXE_NAME} PROPERTIES PREFIX "../") set_target_properties(${EXE_NAME} PROPERTIES PREFIX "../")
ENDIF() endif()
ENDIF() endif()
#INCLUDE(ModuleInstall OPTIONAL) #INCLUDE(ModuleInstall OPTIONAL)

4
tests/CMakeLists.txt
View File

@ -1,2 +1,2 @@
ADD_SUBDIRECTORY(libtest) add_subdirectory(libtest)
ADD_SUBDIRECTORY(server) add_subdirectory(server)

50
tests/libtest/CMakeLists.txt
View File

@ -1,41 +1,45 @@
SET(TARGET_LABEL_PREFIX "Test ") set(TARGET_LABEL_PREFIX "Test ")
FUNCTION(SETUP_TEST TEST_NAME) # ARGN are the files in the test function(SETUP_TEST TEST_NAME) # ARGN are the files in the test
ADD_EXECUTABLE( ${TEST_NAME} ${ARGN} ) add_executable( ${TEST_NAME} ${ARGN} )
STRING(TOUPPER ${TEST_NAME} UPPER_TEST_NAME) string(TOUPPER ${TEST_NAME} UPPER_TEST_NAME)
INCLUDE_DIRECTORIES( include_directories(
${CURL_SOURCE_DIR}/lib # To be able to reach "setup_once.h" ${CURL_SOURCE_DIR}/lib # To be able to reach "setup_once.h"
${CURL_BINARY_DIR}/lib # To be able to reach "config.h" ${CURL_BINARY_DIR}/lib # To be able to reach "config.h"
${CURL_BINARY_DIR}/include # To be able to reach "curl/curlbuild.h" ${CURL_BINARY_DIR}/include # To be able to reach "curl/curlbuild.h"
) )
SETUP_CURL_DEPENDENCIES(${TEST_NAME}) setup_curl_dependencies(${TEST_NAME})
TARGET_LINK_LIBRARIES( ${TEST_NAME} libcurl ) target_link_libraries( ${TEST_NAME} libcurl )
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES COMPILE_DEFINITIONS ${UPPER_TEST_NAME}) set_target_properties(${TEST_NAME}
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES PROJECT_LABEL "${TARGET_LABEL_PREFIX}${TEST_NAME}") PROPERTIES COMPILE_DEFINITIONS ${UPPER_TEST_NAME})
set_target_properties(${TEST_NAME}
PROPERTIES PROJECT_LABEL "${TARGET_LABEL_PREFIX}${TEST_NAME}")
# Add the postfix to the executable since it is not added automatically as for modules and shared libraries # Add the postfix to the executable since it is
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}") # not added automatically as for modules and shared libraries
set_target_properties(${TEST_NAME}
PROPERTIES DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
IF(MSVC) if(MSVC)
IF(NOT BUILD_RELEASE_DEBUG_DIRS) if(NOT BUILD_RELEASE_DEBUG_DIRS)
# Ugly workaround to remove the "/debug" or "/release" in each output # Ugly workaround to remove the "/debug" or "/release" in each output
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES PREFIX "../") set_target_properties(${TEST_NAME} PROPERTIES PREFIX "../")
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES IMPORT_PREFIX "../") set_target_properties(${TEST_NAME} PROPERTIES IMPORT_PREFIX "../")
ENDIF() endif()
ENDIF() endif()
ENDFUNCTION() endfunction()
TRANSFORM_MAKEFILE_INC("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake") transform_makefile_inc("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
INCLUDE(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake) include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
FOREACH(TEST_NAME ${noinst_PROGRAMS}) foreach(TEST_NAME ${noinst_PROGRAMS})
SETUP_TEST(${TEST_NAME} ${${TEST_NAME}_SOURCES}) setup_test(${TEST_NAME} ${${TEST_NAME}_SOURCES})
ENDFOREACH() endforeach()
# # files used only in some libcurl test programs # # files used only in some libcurl test programs

53
tests/server/CMakeLists.txt
View File

@ -1,16 +1,16 @@
SET(TARGET_LABEL_PREFIX "Test server ") set(TARGET_LABEL_PREFIX "Test server ")
FUNCTION(SETUP_EXECUTABLE TEST_NAME) # ARGN are the files in the test function(SETUP_EXECUTABLE TEST_NAME) # ARGN are the files in the test
ADD_EXECUTABLE( ${TEST_NAME} ${ARGN} ) add_executable( ${TEST_NAME} ${ARGN} )
STRING(TOUPPER ${TEST_NAME} UPPER_TEST_NAME) string(TOUPPER ${TEST_NAME} UPPER_TEST_NAME)
INCLUDE_DIRECTORIES( include_directories(
${CURL_SOURCE_DIR}/lib # To be able to reach "setup_once.h" ${CURL_SOURCE_DIR}/lib # To be able to reach "setup_once.h"
${CURL_BINARY_DIR}/lib # To be able to reach "config.h" ${CURL_BINARY_DIR}/lib # To be able to reach "config.h"
${CURL_BINARY_DIR}/include # To be able to reach "curl/curlbuild.h" ${CURL_BINARY_DIR}/include # To be able to reach "curl/curlbuild.h"
) )
SETUP_CURL_DEPENDENCIES(${TEST_NAME}) setup_curl_dependencies(${TEST_NAME})
#TARGET_LINK_LIBRARIES( ${TEST_NAME} libcurl ) #TARGET_LINK_LIBRARIES( ${TEST_NAME} libcurl )
# Test servers simply are standalone programs that do not use libcurl # Test servers simply are standalone programs that do not use libcurl
@ -19,31 +19,36 @@ FUNCTION(SETUP_EXECUTABLE TEST_NAME) # ARGN are the files in the test
# to build the servers. In order to achieve proper linkage of these # to build the servers. In order to achieve proper linkage of these
# files on Win32 targets it is necessary to build the test servers # files on Win32 targets it is necessary to build the test servers
# with CURL_STATICLIB defined, independently of how libcurl is built. # with CURL_STATICLIB defined, independently of how libcurl is built.
IF(NOT CURL_STATICLIB) if(NOT CURL_STATICLIB)
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES COMPILE_DEFINITIONS CURL_STATICLIB) # ${UPPER_TEST_NAME} set_target_properties(${TEST_NAME} PROPERTIES
ENDIF() COMPILE_DEFINITIONS CURL_STATICLIB) # ${UPPER_TEST_NAME}
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES PROJECT_LABEL "${TARGET_LABEL_PREFIX}${TEST_NAME}") endif()
set_target_properties(${TEST_NAME} PROPERTIES
PROJECT_LABEL "${TARGET_LABEL_PREFIX}${TEST_NAME}")
# Add the postfix to the executable since it is not added automatically as for modules and shared libraries # Add the postfix to the executable since it is not added
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}") # automatically as for modules and shared libraries
set_target_properties(${TEST_NAME} PROPERTIES
DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
IF(MSVC) if(MSVC)
IF(NOT BUILD_RELEASE_DEBUG_DIRS) if(NOT BUILD_RELEASE_DEBUG_DIRS)
# Ugly workaround to remove the "/debug" or "/release" in each output # Ugly workaround to remove the "/debug" or "/release" in each output
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES PREFIX "../") set_target_properties(${TEST_NAME} PROPERTIES PREFIX "../")
SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES IMPORT_PREFIX "../") set_target_properties(${TEST_NAME} PROPERTIES IMPORT_PREFIX "../")
ENDIF() endif()
ENDIF() endif()
ENDFUNCTION() endfunction()
TRANSFORM_MAKEFILE_INC("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake") transform_makefile_inc("Makefile.inc"
INCLUDE(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake) "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
include(${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake)
FOREACH(EXECUTABLE_NAME ${noinst_PROGRAMS}) foreach(EXECUTABLE_NAME ${noinst_PROGRAMS})
SETUP_EXECUTABLE(${EXECUTABLE_NAME} ${${EXECUTABLE_NAME}_SOURCES}) setup_executable(${EXECUTABLE_NAME} ${${EXECUTABLE_NAME}_SOURCES})
ENDFOREACH() endforeach()
# SET(useful # SET(useful