Remove forks - use the versions from the real cmake now.

svn path=/trunk/KDE/kdelibs/; revision=507779

4 files changed, 0 insertions, 226 deletions

diff --git a/modules/CheckCXXSourceCompiles.cmake b/modules/CheckCXXSourceCompiles.cmake
deleted file mode 100644
index a4785756..00000000
--- a/modules/CheckCXXSourceCompiles.cmake
+++ /dev/null
@@ -1,53 +0,0 @@
-# - Check if the source code provided in the SOURCE argument compiles.

-# CHECK_CXX_SOURCE_COMPILES(SOURCE VAR)

-# - macro which checks if the source code compiles\

-#  SOURCE - source code to try to compile

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

-# Checks the following optional VARIABLES (not arguments)

-#  CMAKE_REQUIRED_LIBRARIES - Link to extra libraries

-#  CMAKE_REQUIRED_FLAGS     - Extra flags to C compiler

-#

-

-MACRO(CHECK_CXX_SOURCE_COMPILES SOURCE VAR)

-  IF("${VAR}" MATCHES "^${VAR}$")

-    SET(MACRO_CHECK_FUNCTION_DEFINITIONS 

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

-    SET(CHECK_CXX_SOURCE_COMPILES_ADD_LIBRARIES)

-    SET(CHECK_CXX_SOURCE_COMPILES_ADD_INCLUDES)

-    IF(CMAKE_REQUIRED_LIBRARIES)

-      SET(CHECK_CXX_SOURCE_COMPILES_ADD_LIBRARIES

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

-    ENDIF(CMAKE_REQUIRED_LIBRARIES)

-    IF(CMAKE_REQUIRED_INCLUDES)

-      SET(CHECK_CXX_SOURCE_COMPILES_ADD_INCLUDES

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

-    ENDIF(CMAKE_REQUIRED_INCLUDES)

-    FILE(WRITE "${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/src.cxx"

-      "${SOURCE}")

-

-    MESSAGE(STATUS "Performing Test ${VAR}")

-    TRY_COMPILE(${VAR}

-      ${CMAKE_BINARY_DIR}

-      ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/src.cxx

-      CMAKE_FLAGS 

-      "${CHECK_CXX_SOURCE_COMPILES_ADD_LIBRARIES}"

-      "${CHECK_CXX_SOURCE_COMPILES_ADD_INCLUDES}"

-      OUTPUT_VARIABLE OUTPUT)

-    IF(${VAR})

-      SET(${VAR} 1 CACHE INTERNAL "Test ${FUNCTION}")

-      MESSAGE(STATUS "Performing Test ${VAR} - Success")

-      WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log 

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

-        "${OUTPUT}\n"

-        "Source file was:\n${SOURCE}\n" APPEND)

-    ELSE(${VAR})

-      MESSAGE(STATUS "Performing Test ${VAR} - Failed")

-      SET(${VAR} "" CACHE INTERNAL "Test ${FUNCTION}")

-      WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log 

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

-        "${OUTPUT}\n"

-        "Source file was:\n${SOURCE}\n" APPEND)

-    ENDIF(${VAR})

-  ENDIF("${VAR}" MATCHES "^${VAR}$")

-ENDMACRO(CHECK_CXX_SOURCE_COMPILES)

-

diff --git a/modules/CheckIncludeFiles.cmake b/modules/CheckIncludeFiles.cmake
deleted file mode 100644
index 03676fb5..00000000
--- a/modules/CheckIncludeFiles.cmake
+++ /dev/null
@@ -1,56 +0,0 @@
-# - Check if the files can be included
-#
-# CHECK_INCLUDE_FILES(INCLUDE VARIABLE)
-#
-#  INCLUDE  - list of files to include
-#  VARIABLE - variable to return result
-#   
-# If CMAKE_REQUIRED_FLAGS is set then those flags will be passed into the
-# compile of the program
-# additionally to the original cmake module this one uses CMAKE_REQUIRED_INCLUDES
-# where you can specify a directory which will be added to the include path
-
-MACRO(CHECK_INCLUDE_FILES INCLUDE VARIABLE)
-  IF("${VARIABLE}" MATCHES "^${VARIABLE}$")
-   
-    SET(CHECK_INCLUDE_FILES_INCLUDE_DIRS)
-    IF(CMAKE_REQUIRED_INCLUDES)
-       SET(CHECK_INCLUDE_FILES_INCLUDE_DIRS "-DINCLUDE_DIRECTORIES=${CMAKE_REQUIRED_INCLUDES}")
-    ENDIF(CMAKE_REQUIRED_INCLUDES)
-    
-    SET(CHECK_INCLUDE_FILES_CONTENT "/* */\n")
-    SET(MACRO_CHECK_INCLUDE_FILES_FLAGS ${CMAKE_REQUIRED_FLAGS})
-    FOREACH(FILE ${INCLUDE})
-      SET(CHECK_INCLUDE_FILES_CONTENT
-        "${CHECK_INCLUDE_FILES_CONTENT}#include <${FILE}>\n")
-    ENDFOREACH(FILE)
-    SET(CHECK_INCLUDE_FILES_CONTENT
-      "${CHECK_INCLUDE_FILES_CONTENT}\n\nint main(){return 0;}\n")
-    FILE(WRITE ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckIncludeFiles.c 
-      "${CHECK_INCLUDE_FILES_CONTENT}")
-
-    MESSAGE(STATUS "Looking for include files ${VARIABLE}")
-    TRY_COMPILE(${VARIABLE}
-      ${CMAKE_BINARY_DIR}
-      ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckIncludeFiles.c
-      CMAKE_FLAGS
-      -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_INCLUDE_FILES_FLAGS}
-      "${CHECK_INCLUDE_FILES_INCLUDE_DIRS}"
-      OUTPUT_VARIABLE OUTPUT)
-    IF(${VARIABLE})
-      MESSAGE(STATUS "Looking for include files ${VARIABLE} - found")
-      SET(${VARIABLE} 1 CACHE INTERNAL "Have include ${VARIABLE}")
-      FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeFiles/CMakeOutput.log 
-        "Determining if files ${INCLUDE} "
-        "exist passed with the following output:\n"
-        "${OUTPUT}\n\n")
-    ELSE(${VARIABLE})
-      MESSAGE(STATUS "Looking for include files ${VARIABLE} - not found.")
-      SET(${VARIABLE} "" CACHE INTERNAL "Have includes ${VARIABLE}")
-      FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log 
-        "Determining if files ${INCLUDE} "
-        "exist failed with the following output:\n"
-        "${OUTPUT}\nSource:\n${CHECK_INCLUDE_FILES_CONTENT}\n")
-    ENDIF(${VARIABLE})
-  ENDIF("${VARIABLE}" MATCHES "^${VARIABLE}$")
-ENDMACRO(CHECK_INCLUDE_FILES)
diff --git a/modules/CheckSymbolExists.cmake b/modules/CheckSymbolExists.cmake
deleted file mode 100755
index ce3e4afa..00000000
--- a/modules/CheckSymbolExists.cmake
+++ /dev/null
@@ -1,65 +0,0 @@
-# - Check if the symbol exists in include files
-# CHECK_SYMBOL_EXISTS(SYMBOL FILES VARIABLE)
-#
-#  SYMBOL   - symbol
-#  FILES    - include files to check
-#  VARIABLE - variable to return result
-#  
-# If CMAKE_REQUIRED_FLAGS is set then those flags will be passed into the
-# compile of the program likewise if CMAKE_REQUIRED_LIBRARIES is set then
-# those libraries will be linked against the test program. If CMAKE_REQUIRED_INCLUDES
-# is set then these directories will be added to the include search path.
-
-
-MACRO(CHECK_SYMBOL_EXISTS SYMBOL FILES VARIABLE)
-  IF("${VARIABLE}" MATCHES "^${VARIABLE}$")
-    SET(CHECK_SYMBOL_EXISTS_CONTENT "/* */\n")
-    SET(MACRO_CHECK_SYMBOL_EXISTS_FLAGS ${CMAKE_REQUIRED_FLAGS})
-    SET(CHECK_SYMBOL_EXISTS_LIBS)
-    SET(CHECK_SYMBOL_EXISTS_ADD_INCLUDES)
-    IF(CMAKE_REQUIRED_LIBRARIES)
-      SET(CHECK_SYMBOL_EXISTS_LIBS 
-        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
-    ENDIF(CMAKE_REQUIRED_LIBRARIES)
-    IF(CMAKE_REQUIRED_INCLUDES)
-      SET(CHECK_SYMBOL_EXISTS_ADD_INCLUDES
-        "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
-    ENDIF(CMAKE_REQUIRED_INCLUDES)
-    FOREACH(FILE ${FILES})
-      SET(CHECK_SYMBOL_EXISTS_CONTENT
-        "${CHECK_SYMBOL_EXISTS_CONTENT}#include <${FILE}>\n")
-    ENDFOREACH(FILE)
-    SET(CHECK_SYMBOL_EXISTS_CONTENT
-      "${CHECK_SYMBOL_EXISTS_CONTENT}\nvoid cmakeRequireSymbol(int dummy,...){(void)dummy;}\nint main()\n{\n#ifndef ${SYMBOL}\n  cmakeRequireSymbol(0,&${SYMBOL});\n#endif\n  return 0;\n}\n")
-
-    FILE(WRITE ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckSymbolExists.c 
-      "${CHECK_SYMBOL_EXISTS_CONTENT}")
-
-    MESSAGE(STATUS "Looking for ${SYMBOL}")
-    TRY_COMPILE(${VARIABLE}
-      ${CMAKE_BINARY_DIR}
-      ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckSymbolExists.c
-      CMAKE_FLAGS 
-      -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_SYMBOL_EXISTS_FLAGS}
-      "${CHECK_SYMBOL_EXISTS_ADD_INCLUDES}"
-      "${CHECK_SYMBOL_EXISTS_LIBS}"
-      OUTPUT_VARIABLE OUTPUT)
-    IF(${VARIABLE})
-      MESSAGE(STATUS "Looking for ${SYMBOL} - found")
-      SET(${VARIABLE} 1 CACHE INTERNAL "Have symbol ${SYMBOL}")
-      FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeOutput.log 
-        "Determining if the ${SYMBOL} "
-        "exist passed with the following output:\n"
-        "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckSymbolExists.c:\n"
-        "${CHECK_SYMBOL_EXISTS_CONTENT}\n")
-    ELSE(${VARIABLE})
-      MESSAGE(STATUS "Looking for ${SYMBOL} - not found.")
-      SET(${VARIABLE} "" CACHE INTERNAL "Have symbol ${SYMBOL}")
-      FILE(APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log 
-        "Determining if the ${SYMBOL} "
-        "exist failed with the following output:\n"
-        "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckSymbolExists.c:\n"
-        "${CHECK_SYMBOL_EXISTS_CONTENT}\n")
-    ENDIF(${VARIABLE})
-  ENDIF("${VARIABLE}" MATCHES "^${VARIABLE}$")
-ENDMACRO(CHECK_SYMBOL_EXISTS)
diff --git a/modules/CheckTypeSize.cmake b/modules/CheckTypeSize.cmake
deleted file mode 100644
index c4163cc1..00000000
--- a/modules/CheckTypeSize.cmake
+++ /dev/null
@@ -1,52 +0,0 @@
-# - 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("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_PREINCLUDE)
-    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_ROOT}/Modules/CheckTypeSize.c.in"
-      "${CMAKE_BINARY_DIR}/CMakeFiles/CMakeTmp/CheckTypeSize.c" IMMEDIATE @ONLY)
-    FILE(READ "${CMAKE_BINARY_DIR}/CMakeFiles/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}/CMakeFiles/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}/CMakeFiles/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}/CMakeFiles/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}$")
-  SET(CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS )
-ENDMACRO(CHECK_TYPE_SIZE)