Commit 8cb01014 authored by Peter Wu's avatar Peter Wu Committed by Daniel Stenberg
Browse files

cmake: clean OtherTests, fixing -Werror 



There were several -Wunused warnings and one duplicate macro definition.
The EXTRA_DEFINES variable of the CurlCheckCSources macro was being
abused ("__unused1\n#undef inline\n#define __unused2", seriously?) to
insert extra C code. Avoid this broken abstraction and use cmake's
check_c_source_compiles directly (works fine with CMake 2.8, maybe
even cmake 2.6).

After cleaning up all related variables (EXTRA_DEFINES,
HEADER_INCLUDES, auxiliary headers_hack), also remove a duplicate
add_headers_include macro and remove duplicate header additions before
the struct timeval check.

Oh, and now the code is converted to use CheckCSourceRuns and
CheckCSourceCompiles, the two curl-specific helpers can be removed.
Unfortunately, the cmake output is now slightly more verbose. Before:

    Performing Test int send(int, const void *, size_t, int) (curl_cv_func_send_test)
    Performing Test int send(int, const void *, size_t, int) (curl_cv_func_send_test) - Failed

Since check_c_source_compiles prints the varname, now you see:

    Performing Test curl_cv_func_send_test
    Performing Test curl_cv_func_send_test - Failed
    Tested: int send(int, const void *, size_t, int)

Compared cmake output with each other using vimdiff, no functional
differences were found. Tested with GCC 4.9.1 and Clang 3.5.0.

Signed-off-by: default avatarPeter Wu <peter@lekensteyn.nl>
parent aebfd4cf

CMake/CurlCheckCSourceCompiles.cmake

deleted100644 → 0
+0 −71
Original line number Diff line number Diff line 
# - Check if the source code provided in the SOURCE argument compiles.

# CURL_CHECK_C_SOURCE_COMPILES(SOURCE VAR)

# - macro which checks if the source code compiles

#  SOURCE   - source code to try to compile

#  VAR      - variable to store whether the source code compiled

#

# The following variables may be set before calling this macro to

# modify the way the check is run:

#

#  CMAKE_REQUIRED_FLAGS = string of compile command line flags

#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)

#  CMAKE_REQUIRED_INCLUDES = list of include directories

#  CMAKE_REQUIRED_LIBRARIES = list of libraries to link



macro(CURL_CHECK_C_SOURCE_COMPILES SOURCE VAR)

  if("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")

    set(message "${VAR}")

    # If the number of arguments is greater than 2 (SOURCE VAR)

    if(${ARGC} GREATER 2)

      # then add the third argument as a message

      set(message "${ARGV2} (${VAR})")

    endif()

    set(MACRO_CHECK_FUNCTION_DEFINITIONS

      "-D${VAR} ${CMAKE_REQUIRED_FLAGS}")

    if(CMAKE_REQUIRED_LIBRARIES)

      set(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES

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

    endif()

    if(CMAKE_REQUIRED_INCLUDES)

      set(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES

        "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")

    endif()

    set(src "")

    foreach(def ${EXTRA_DEFINES})

      set(src "${src}#define ${def} 1\n")

    endforeach(def)

    foreach(inc ${HEADER_INCLUDES})

      set(src "${src}#include <${inc}>\n")

    endforeach(inc)



    set(src "${src}\nint main() { ${SOURCE} ; return 0; }")

    set(CMAKE_CONFIGURABLE_FILE_CONTENT "${src}")

    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CMake/CMakeConfigurableFile.in

      "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c"

      IMMEDIATE)

    message(STATUS "Performing Test ${message}")

    try_compile(${VAR}

      ${CMAKE_BINARY_DIR}

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

      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}

      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}

      "${CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES}"

      "${CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES}"

      OUTPUT_VARIABLE OUTPUT)

    if(${VAR})

      set(${VAR} 1 CACHE INTERNAL "Test ${message}")

      message(STATUS "Performing Test ${message} - Success")

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

        "Performing C SOURCE FILE Test ${message} succeded with the following output:\n"

        "${OUTPUT}\n"

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

    else()

      message(STATUS "Performing Test ${message} - Failed")

      set(${VAR} "" CACHE INTERNAL "Test ${message}")

      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log

        "Performing C SOURCE FILE Test ${message} failed with the following output:\n"

        "${OUTPUT}\n"

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

    endif()

  endif()

endmacro()

CMake/CurlCheckCSourceRuns.cmake

deleted100644 → 0
+0 −83
Original line number Diff line number Diff line 
# - Check if the source code provided in the SOURCE argument compiles and runs.

# CURL_CHECK_C_SOURCE_RUNS(SOURCE VAR)

# - macro which checks if the source code runs

#  SOURCE   - source code to try to compile

#  VAR - variable to store size if the type exists.

#

# The following variables may be set before calling this macro to

# modify the way the check is run:

#

#  CMAKE_REQUIRED_FLAGS = string of compile command line flags

#  CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar)

#  CMAKE_REQUIRED_INCLUDES = list of include directories

#  CMAKE_REQUIRED_LIBRARIES = list of libraries to link



macro(CURL_CHECK_C_SOURCE_RUNS SOURCE VAR)

  if("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")

    set(message "${VAR}")

    # If the number of arguments is greater than 2 (SOURCE VAR)

    if(${ARGC} GREATER 2)

      # then add the third argument as a message

      set(message "${ARGV2} (${VAR})")

    endif(${ARGC} GREATER 2)

    set(MACRO_CHECK_FUNCTION_DEFINITIONS

      "-D${VAR} ${CMAKE_REQUIRED_FLAGS}")

    if(CMAKE_REQUIRED_LIBRARIES)

      set(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES

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

    else(CMAKE_REQUIRED_LIBRARIES)

      set(CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES)

    endif(CMAKE_REQUIRED_LIBRARIES)

    if(CMAKE_REQUIRED_INCLUDES)

      set(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES

        "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")

    else(CMAKE_REQUIRED_INCLUDES)

      set(CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES)

    endif(CMAKE_REQUIRED_INCLUDES)

    set(src "")

    foreach(def ${EXTRA_DEFINES})

      set(src "${src}#define ${def} 1\n")

    endforeach(def)

    foreach(inc ${HEADER_INCLUDES})

      set(src "${src}#include <${inc}>\n")

    endforeach(inc)



    set(src "${src}\nint main() { ${SOURCE} ; return 0; }")

    set(CMAKE_CONFIGURABLE_FILE_CONTENT "${src}")

    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/CMake/CMakeConfigurableFile.in

      "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/src.c"

      IMMEDIATE)

    message(STATUS "Performing Test ${message}")

    try_run(${VAR} ${VAR}_COMPILED

      ${CMAKE_BINARY_DIR}

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

      COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}

      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}

      "${CURL_CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES}"

      "${CURL_CHECK_C_SOURCE_COMPILES_ADD_INCLUDES}"

      OUTPUT_VARIABLE OUTPUT)

    # if it did not compile make the return value fail code of 1

    if(NOT ${VAR}_COMPILED)

      set(${VAR} 1)

    endif(NOT ${VAR}_COMPILED)

    # if the return value was 0 then it worked

    set(result_var ${${VAR}})

    if("${result_var}" EQUAL 0)

      set(${VAR} 1 CACHE INTERNAL "Test ${message}")

      message(STATUS "Performing Test ${message} - Success")

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

        "Performing C SOURCE FILE Test ${message} succeded with the following output:\n"

        "${OUTPUT}\n"

        "Return value: ${${VAR}}\n"

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

    else("${result_var}" EQUAL 0)

      message(STATUS "Performing Test ${message} - Failed")

      set(${VAR} "" CACHE INTERNAL "Test ${message}")

      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log

        "Performing C SOURCE FILE Test ${message} failed with the following output:\n"

        "${OUTPUT}\n"

        "Return value: ${result_var}\n"

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

    endif("${result_var}" EQUAL 0)

  endif("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")

endmacro(CURL_CHECK_C_SOURCE_RUNS)

CMake/OtherTests.cmake

+85 −91
Original line number Diff line number Diff line 
include(CurlCheckCSourceCompiles)

set(EXTRA_DEFINES "__unused1\n#undef inline\n#define __unused2")

set(HEADER_INCLUDES)

set(headers_hack)

include(CheckCSourceCompiles)

# The begin of the sources (macros and includes)

set(_source_epilogue "#undef inline")



macro(add_header_include check header)

  if(${check})

    set(headers_hack

      "${headers_hack}\n#include <${header}>")

    #SET(HEADER_INCLUDES

    #  ${HEADER_INCLUDES}

    #  "${header}")

    set(_source_epilogue "${_source_epilogue}\n#include <${header}>")

  endif(${check})

endmacro(add_header_include)
@@ -18,8 +13,8 @@ if(HAVE_WINDOWS_H) 
  add_header_include(HAVE_WINDOWS_H "windows.h")

  add_header_include(HAVE_WINSOCK2_H "winsock2.h")

  add_header_include(HAVE_WINSOCK_H "winsock.h")

  set(EXTRA_DEFINES ${EXTRA_DEFINES}

    "__unused7\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif\n#define __unused3")

  set(_source_epilogue

      "${_source_epilogue}\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif")

  set(signature_call_conv "PASCAL")

  if(HAVE_LIBWS2_32)

    set(CMAKE_REQUIRED_LIBRARIES ws2_32)
@@ -29,14 +24,12 @@ else(HAVE_WINDOWS_H) 
  add_header_include(HAVE_SYS_SOCKET_H "sys/socket.h")

endif(HAVE_WINDOWS_H)



set(EXTRA_DEFINES_BACKUP "${EXTRA_DEFINES}")

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)

check_c_source_compiles("${_source_epilogue}

int main(void) {

    recv(0, 0, 0, 0);

    return 0;

}" curl_cv_recv)

if(curl_cv_recv)

  #    AC_CACHE_CHECK([types of arguments and return type for recv],

  #[curl_cv_func_recv_args], [

  #SET(curl_cv_func_recv_args "unknown")

  #for recv_retv in 'int' 'ssize_t'; do

  if(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")

    foreach(recv_retv "int" "ssize_t" )

      foreach(recv_arg1 "int" "ssize_t" "SOCKET")
@@ -44,17 +37,23 @@ if(curl_cv_recv) 
          foreach(recv_arg3 "size_t" "int" "socklen_t" "unsigned int")

            foreach(recv_arg4 "int" "unsigned int")

              if(NOT curl_cv_func_recv_done)

                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(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5")

                curl_check_c_source_compiles("

                unset(curl_cv_func_recv_test CACHE)

                check_c_source_compiles("

                  ${_source_epilogue}

                  extern ${recv_retv} ${signature_call_conv}

                  recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4});

                  int main(void) {

                    ${recv_arg1} s=0;

                    ${recv_arg2} buf=0;

                    ${recv_arg3} len=0;

                    ${recv_arg4} flags=0;

                    ${recv_retv} res = recv(s, buf, len, flags)"

                  curl_cv_func_recv_test

                  "${recv_retv} recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4})")

                    ${recv_retv} res = recv(s, buf, len, flags);

                    (void) res;

                    return 0;

                  }"

                  curl_cv_func_recv_test)

                message(STATUS

                  "Tested: ${recv_retv} recv(${recv_arg1}, ${recv_arg2}, ${recv_arg3}, ${recv_arg4})")

                if(curl_cv_func_recv_test)

                  set(curl_cv_func_recv_args

                    "${recv_arg1},${recv_arg2},${recv_arg3},${recv_arg4},${recv_retv}")
@@ -72,18 +71,13 @@ if(curl_cv_recv) 
        endforeach(recv_arg2)

      endforeach(recv_arg1)

    endforeach(recv_retv)

  else(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")

  else()

    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_ARG3 "${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}")

    #MESSAGE("RECV_TYPE_ARG1 ${RECV_TYPE_ARG1}")

    #MESSAGE("RECV_TYPE_ARG2 ${RECV_TYPE_ARG2}")

    #MESSAGE("RECV_TYPE_ARG3 ${RECV_TYPE_ARG3}")

    #MESSAGE("RECV_TYPE_ARG4 ${RECV_TYPE_ARG4}")

    #MESSAGE("RECV_TYPE_RETV ${RECV_TYPE_RETV}")

  endif(NOT DEFINED curl_cv_func_recv_args OR "${curl_cv_func_recv_args}" STREQUAL "unknown")

  endif()



  if("${curl_cv_func_recv_args}" STREQUAL "unknown")

    message(FATAL_ERROR "Cannot find proper types to use for recv args")
@@ -94,12 +88,12 @@ endif(curl_cv_recv) 
set(curl_cv_func_recv_args "${curl_cv_func_recv_args}" CACHE INTERNAL "Arguments for recv")

set(HAVE_RECV 1)



curl_check_c_source_compiles("send(0, 0, 0, 0)" curl_cv_send)

check_c_source_compiles("${_source_epilogue}

int main(void) {

    send(0, 0, 0, 0);

    return 0;

}" curl_cv_send)

if(curl_cv_send)

  #    AC_CACHE_CHECK([types of arguments and return type for send],

  #[curl_cv_func_send_args], [

  #SET(curl_cv_func_send_args "unknown")

  #for send_retv in 'int' 'ssize_t'; do

  if(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown")

    foreach(send_retv "int" "ssize_t" )

      foreach(send_arg1 "int" "ssize_t" "SOCKET")
@@ -107,19 +101,24 @@ if(curl_cv_send) 
          foreach(send_arg3 "size_t" "int" "socklen_t" "unsigned int")

            foreach(send_arg4 "int" "unsigned int")

              if(NOT curl_cv_func_send_done)

                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(EXTRA_DEFINES "${EXTRA_DEFINES_BACKUP}\n${headers_hack}\n${extern_line}\n#define __unused5")

                curl_check_c_source_compiles("

                unset(curl_cv_func_send_test CACHE)

                check_c_source_compiles("

                  ${_source_epilogue}

                  extern ${send_retv} ${signature_call_conv}

                  send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4});

                  int main(void) {

                    ${send_arg1} s=0;

                    ${send_arg2} buf=0;

                    ${send_arg3} len=0;

                    ${send_arg4} flags=0;

                    ${send_retv} res = send(s, buf, len, flags)"

                  curl_cv_func_send_test

                  "${send_retv} send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4})")

                    ${send_retv} res = send(s, buf, len, flags);

                    (void) res;

                    return 0;

                  }"

                  curl_cv_func_send_test)

                message(STATUS

                  "Tested: ${send_retv} send(${send_arg1}, ${send_arg2}, ${send_arg3}, ${send_arg4})")

                if(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_arg2 "${send_arg2}")

                  set(curl_cv_func_send_args
@@ -138,20 +137,14 @@ if(curl_cv_send) 
        endforeach(send_arg2)

      endforeach(send_arg1)

    endforeach(send_retv)

  else(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown")

  else()

    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_ARG3 "${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_QUAL_ARG2 "${curl_cv_func_send_args}")

    #MESSAGE("SEND_TYPE_ARG1 ${SEND_TYPE_ARG1}")

    #MESSAGE("SEND_TYPE_ARG2 ${SEND_TYPE_ARG2}")

    #MESSAGE("SEND_TYPE_ARG3 ${SEND_TYPE_ARG3}")

    #MESSAGE("SEND_TYPE_ARG4 ${SEND_TYPE_ARG4}")

    #MESSAGE("SEND_TYPE_RETV ${SEND_TYPE_RETV}")

    #MESSAGE("SEND_QUAL_ARG2 ${SEND_QUAL_ARG2}")

  endif(NOT DEFINED curl_cv_func_send_args OR "${curl_cv_func_send_args}" STREQUAL "unknown")

  endif()



  if("${curl_cv_func_send_args}" STREQUAL "unknown")

    message(FATAL_ERROR "Cannot find proper types to use for send args")
@@ -163,57 +156,58 @@ endif(curl_cv_send) 
set(curl_cv_func_send_args "${curl_cv_func_send_args}" CACHE INTERNAL "Arguments for send")

set(HAVE_SEND 1)



set(EXTRA_DEFINES "${EXTRA_DEFINES}\n${headers_hack}\n#define __unused5")

curl_check_c_source_compiles("int flag = MSG_NOSIGNAL" HAVE_MSG_NOSIGNAL)



set(EXTRA_DEFINES "__unused1\n#undef inline\n#define __unused2")

set(HEADER_INCLUDES)

set(headers_hack)



macro(add_header_include check header)

  if(${check})

    set(headers_hack

      "${headers_hack}\n#include <${header}>")

    #SET(HEADER_INCLUDES

    #  ${HEADER_INCLUDES}

    #  "${header}")

  endif(${check})

endmacro(add_header_include header)

check_c_source_compiles("${_source_epilogue}

  int main(void) {

    int flag = MSG_NOSIGNAL;

    (void)flag;

    return 0;

  }" HAVE_MSG_NOSIGNAL)



if(HAVE_WINDOWS_H)

  set(EXTRA_DEFINES ${EXTRA_DEFINES}

    "__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_WINSOCK2_H "winsock2.h")

  add_header_include(HAVE_WINSOCK_H "winsock.h")

else(HAVE_WINDOWS_H)

  add_header_include(HAVE_SYS_TYPES_H "sys/types.h")

if(NOT HAVE_WINDOWS_H)

  add_header_include(HAVE_SYS_TIME_H "sys/time.h")

  add_header_include(TIME_WITH_SYS_TIME "time.h")

  add_header_include(HAVE_TIME_H "time.h")

endif(HAVE_WINDOWS_H)

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)





include(CurlCheckCSourceRuns)

set(EXTRA_DEFINES)

set(HEADER_INCLUDES)

endif()

check_c_source_compiles("${_source_epilogue}

int main(void) {

  struct timeval ts;

  ts.tv_sec  = 0;

  ts.tv_usec = 0;

  (void)ts;

  return 0;

}" HAVE_STRUCT_TIMEVAL)





include(CheckCSourceRuns)

set(CMAKE_REQUIRED_FLAGS)

if(HAVE_SYS_POLL_H)

  set(HEADER_INCLUDES "sys/poll.h")

  set(CMAKE_REQUIRED_FLAGS "-DHAVE_SYS_POLL_H")

endif(HAVE_SYS_POLL_H)

curl_check_c_source_runs("return poll((void *)0, 0, 10 /*ms*/)" HAVE_POLL_FINE)

check_c_source_runs("

  #ifdef HAVE_SYS_POLL_H

  #  include <sys/poll.h>

  #endif

  int main(void) {

    return poll((void *)0, 0, 10 /*ms*/);

  }" HAVE_POLL_FINE)



set(HAVE_SIG_ATOMIC_T 1)

set(EXTRA_DEFINES)

set(HEADER_INCLUDES)

set(CMAKE_REQUIRED_FLAGS)

if(HAVE_SIGNAL_H)

  set(HEADER_INCLUDES "signal.h")

  set(CMAKE_REQUIRED_FLAGS "-DHAVE_SIGNAL_H")

  set(CMAKE_EXTRA_INCLUDE_FILES "signal.h")

endif(HAVE_SIGNAL_H)

check_type_size("sig_atomic_t" 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)

  check_c_source_compiles("

    #ifdef HAVE_SIGNAL_H

    #  include <signal.h>

    #endif

    int main(void) {

      static volatile sig_atomic_t dummy = 0;

      (void)dummy;

      return 0;

    }" HAVE_SIG_ATOMIC_T_NOT_VOLATILE)

  if(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)

    set(HAVE_SIG_ATOMIC_T_VOLATILE 1)

  endif(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)