Commit 651c0bcd authored by Brad King's avatar Brad King Committed by Daniel Stenberg
Browse files

CMake: Use upstream CheckTypeSize module 



The CheckTypeSize module that comes with CMake 2.6.2 and above does
everything we need and also supports cross-compiling.  Avoid duplicating
an older version of it here.  This also fixes a cross-compiling error
because the old line

  include ("${CMAKE_MODULE_PATH}/CheckTypeSize.cmake")

failed because CMAKE_MODULE_PATH is a search path and not a directory.

Signed-off-by: default avatarBrad King <brad.king@kitware.com>
parent d45ed0ec

CMake/CheckTypeSize.c.in

deleted100644 → 0
+0 −44
Original line number Diff line number Diff line 
#cmakedefine CHECK_TYPE_SIZE_TYPE @CHECK_TYPE_SIZE_TYPE@

#ifdef CHECK_TYPE_SIZE_TYPE



@CHECK_TYPE_SIZE_PREINCLUDE@

#ifdef HAVE_SYS_TYPES_H

#  include <sys/types.h>

#endif /* HAVE_SYS_TYPES_H */



#ifdef HAVE_SYS_SOCKET_H

#  include <sys/socket.h>

#endif



#ifdef _WIN32

#  include <winsock2.h>

#  include <ws2tcpip.h>

#endif





#ifdef HAVE_STDINT_H

#  include <stdint.h>

#endif /* HAVE_STDINT_H */



#ifdef HAVE_STDDEF_H

#  include <stddef.h>

#endif /* HAVE_STDDEF_H */



@CHECK_TYPE_SIZE_PREMAIN@



#ifdef __CLASSIC_C__

int main(){

  int ac;

  char*av[];

#else

int main(int ac, char*av[]){

#endif

  if(ac > 1000){return *av[0];}

  return sizeof(CHECK_TYPE_SIZE_TYPE);

}



#else  /* CHECK_TYPE_SIZE_TYPE */



#  error "CHECK_TYPE_SIZE_TYPE has to specify the type"



#endif /* CHECK_TYPE_SIZE_TYPE */

CMake/CheckTypeSize.cmake

deleted100644 → 0
+0 −57
Original line number Diff line number Diff line 
# - Check sizeof a type

#  CHECK_TYPE_SIZE(TYPE VARIABLE)

# Check if the type exists and determine size of type.  if the type

# exists, the size will be stored to the variable.

#

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

#  HAVE_${VARIABLE} - does the variable exists or not



macro(CHECK_TYPE_SIZE TYPE VARIABLE)

  set(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS 1)

  if(NOT DEFINED ${VARIABLE})

    if("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$")

      set(CHECK_TYPE_SIZE_TYPE "${TYPE}")

      set(MACRO_CHECK_TYPE_SIZE_FLAGS

        "${CMAKE_REQUIRED_FLAGS}")

      foreach(def HAVE_SYS_TYPES_H 

         HAVE_STDINT_H HAVE_STDDEF_H HAVE_SYS_SOCKET_H)

        if("${def}")

          set(MACRO_CHECK_TYPE_SIZE_FLAGS

            "${MACRO_CHECK_TYPE_SIZE_FLAGS} -D${def}")

        endif("${def}")

      endforeach(def)

      set(CHECK_TYPE_SIZE_PREMAIN)

      foreach(def ${CMAKE_EXTRA_INCLUDE_FILES})

        set(CHECK_TYPE_SIZE_PREMAIN "${CHECK_TYPE_SIZE_PREMAIN}#include \"${def}\"\n")

      endforeach(def)

      configure_file(

        "${CMAKE_CURRENT_SOURCE_DIR}/CMake/CheckTypeSize.c.in"

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

        IMMEDIATE @ONLY)

      file(READ

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

        CHECK_TYPE_SIZE_FILE_CONTENT)

      message(STATUS "Check size of ${TYPE}")

      if(CMAKE_REQUIRED_LIBRARIES)

        set(CHECK_TYPE_SIZE_ADD_LIBRARIES

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

      endif(CMAKE_REQUIRED_LIBRARIES)

      try_run(${VARIABLE} HAVE_${VARIABLE}

        ${CMAKE_BINARY_DIR}

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

        CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_TYPE_SIZE_FLAGS}

        "${CHECK_TYPE_SIZE_ADD_LIBRARIES}"

        OUTPUT_VARIABLE OUTPUT)

      if(HAVE_${VARIABLE})

        message(STATUS "Check size of ${TYPE} - done")

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

          "Determining size of ${TYPE} passed with the following output:\n${OUTPUT}\n\n")

      else(HAVE_${VARIABLE})

        message(STATUS "Check size of ${TYPE} - failed")

        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")

      endif(HAVE_${VARIABLE})

    endif("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$")

  endif(NOT DEFINED ${VARIABLE})

  set(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS )

endmacro(CHECK_TYPE_SIZE)

CMakeLists.txt

+7 −7
Original line number Diff line number Diff line
@@ -183,13 +183,7 @@ 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)
@@ -781,7 +775,13 @@ endif(CMAKE_COMPILER_IS_GNUCC AND APPLE) 


if(HAVE_SOCKLEN_T)

  set(CURL_TYPEOF_CURL_SOCKLEN_T "socklen_t")

  if(WIN32)

    set(CMAKE_EXTRA_INCLUDE_FILES "winsock2.h;ws2tcpip.h")

  elseif(HAVE_SYS_SOCKET_H)

    set(CMAKE_EXTRA_INCLUDE_FILES "sys/socket.h")

  endif()

  check_type_size("socklen_t" CURL_SIZEOF_CURL_SOCKLEN_T)

  set(CMAKE_EXTRA_INCLUDE_FILES)

  if(NOT HAVE_CURL_SIZEOF_CURL_SOCKLEN_T)

    message(FATAL_ERROR 

     "Check for sizeof socklen_t failed, see CMakeFiles/CMakerror.log")