Commit 4c5307b4 authored by Benoit Neil's avatar Benoit Neil
Browse files

Initial CMake scripts (libcurl only), based on the merge of tetest scripts and... 

Initial CMake scripts (libcurl only), based on the merge of tetest scripts and mine. These are far to be functionnal yet.
PS: Hello world :)
parent 626f9bd8

CMake/CMakeConfigurableFile.in

0 → 100644
+2 −0
Original line number Diff line number Diff line 
@CMAKE_CONFIGURABLE_FILE_CONTENT@

CMake/CheckTypeSize.c.in

0 → 100644
+34 −0
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_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

0 → 100644
+56 −0
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)

      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)

CMake/CurlCheckCSourceCompiles.cmake

0 → 100644
+75 −0
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(${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_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(${VAR})

      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(${VAR})

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

ENDMACRO(CURL_CHECK_C_SOURCE_COMPILES)

CMake/CurlCheckCSourceRuns.cmake

0 → 100644
+83 −0
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)