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

14 files changed, 1218 insertions, 1208 deletions

diff --git a/CMake/CheckTypeSize.cmake b/CMake/CheckTypeSize.cmake
index e16c64dfe..9b601946d 100644
--- a/CMake/CheckTypeSize.cmake
+++ b/CMake/CheckTypeSize.cmake
@@ -6,51 +6,51 @@
 #  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)
+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)
diff --git a/CMake/CurlCheckCSourceCompiles.cmake b/CMake/CurlCheckCSourceCompiles.cmake
index d025769aa..b63276809 100644
--- a/CMake/CurlCheckCSourceCompiles.cmake
+++ b/CMake/CurlCheckCSourceCompiles.cmake
@@ -12,43 +12,43 @@
 #  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}")
+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)
+    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
+      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
+    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
+    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)
+    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
+    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}
+    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}
@@ -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_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
+    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
+    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)
+    endif(${VAR})
+  endif("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
+endmacro(CURL_CHECK_C_SOURCE_COMPILES)
diff --git a/CMake/CurlCheckCSourceRuns.cmake b/CMake/CurlCheckCSourceRuns.cmake
index 19681bd85..6b14af80d 100644
--- a/CMake/CurlCheckCSourceRuns.cmake
+++ b/CMake/CurlCheckCSourceRuns.cmake
@@ -12,43 +12,43 @@
 #  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}")
+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)
+    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
+      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
+    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
+    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)
+    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
+    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
+    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}
@@ -57,27 +57,27 @@ MACRO(CURL_CHECK_C_SOURCE_RUNS SOURCE VAR)
       "${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(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
+    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
+    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)
+    endif("${result_var}" EQUAL 0)
+  endif("${VAR}" MATCHES "^${VAR}$" OR "${VAR}" MATCHES "UNKNOWN")
+endmacro(CURL_CHECK_C_SOURCE_RUNS)
diff --git a/CMake/FindOpenSSL.cmake b/CMake/FindOpenSSL.cmake
index 6eea6ff24..63a9d6062 100644
--- a/CMake/FindOpenSSL.cmake
+++ b/CMake/FindOpenSSL.cmake
@@ -1,19 +1,19 @@
 # Extension of the standard FindOpenSSL.cmake
 # 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:
-FIND_LIBRARY(SSL_LIBEAY NAMES libeay32)
+find_library(SSL_LIBEAY NAMES libeay32)
 
-IF(OPENSSL_FOUND)
-	IF(SSL_LIBEAY)
-		LIST(APPEND OPENSSL_LIBRARIES ${SSL_LIBEAY})
-	ELSE()
-		SET(OPENSSL_FOUND FALSE)
-	ENDIF()
-ENDIF()
+if(OPENSSL_FOUND)
+  if(SSL_LIBEAY)
+    list(APPEND OPENSSL_LIBRARIES ${SSL_LIBEAY})
+  else()
+    set(OPENSSL_FOUND FALSE)
+  endif()
+endif()
 
 
-IF(OPENSSL_FOUND)
-	SET(OPENSSL_INCLUDE_DIRS ${OPENSSL_INCLUDE_DIR})
-ENDIF()
+if(OPENSSL_FOUND)
+  set(OPENSSL_INCLUDE_DIRS ${OPENSSL_INCLUDE_DIR})
+endif()
diff --git a/CMake/FindZLIB.cmake b/CMake/FindZLIB.cmake
index cf3637bc4..87f1d4fe8 100644
--- a/CMake/FindZLIB.cmake
+++ b/CMake/FindZLIB.cmake
@@ -1,8 +1,8 @@
 # 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)
-  SET( ZLIB_LIBRARIES optimized "${ZLIB_LIBRARY}" debug ${ZLIB_LIBRARY_DEBUG})
-ENDIF()
+if(ZLIB_FOUND AND ZLIB_LIBRARY_DEBUG)
+  set( ZLIB_LIBRARIES optimized "${ZLIB_LIBRARY}" debug ${ZLIB_LIBRARY_DEBUG})
+endif()
diff --git a/CMake/OtherTests.cmake b/CMake/OtherTests.cmake
index ea1613d37..50fa67559 100644
--- a/CMake/OtherTests.cmake
+++ b/CMake/OtherTests.cmake
@@ -1,250 +1,250 @@
-INCLUDE(CurlCheckCSourceCompiles)
-SET(EXTRA_DEFINES "__unused1\n#undef inline\n#define __unused2")
-SET(HEADER_INCLUDES)
-SET(headers_hack)
+include(CurlCheckCSourceCompiles)
+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
+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)
+  endif(${check})
+endmacro(add_header_include)
 
-SET(signature_call_conv)
-IF(HAVE_WINDOWS_H)
+set(signature_call_conv)
+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}
+  set(EXTRA_DEFINES ${EXTRA_DEFINES}
     "__unused7\n#ifndef WIN32_LEAN_AND_MEAN\n#define WIN32_LEAN_AND_MEAN\n#endif\n#define __unused3")
-  SET(signature_call_conv "PASCAL")
-ELSE(HAVE_WINDOWS_H)
+  set(signature_call_conv "PASCAL")
+else(HAVE_WINDOWS_H)
   add_header_include(HAVE_SYS_TYPES_H "sys/types.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 "${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)
-IF(curl_cv_recv)
+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)
+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")
-        FOREACH(recv_arg2 "void *" "char *")
-          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("
+  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")
+        foreach(recv_arg2 "void *" "char *")
+          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("
                     ${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})")
-                IF(curl_cv_func_recv_test)
-                  SET(curl_cv_func_recv_args
+                  curl_cv_func_recv_test
+                  "${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}")
-                  SET(RECV_TYPE_ARG1 "${recv_arg1}")
-                  SET(RECV_TYPE_ARG2 "${recv_arg2}")
-                  SET(RECV_TYPE_ARG3 "${recv_arg3}")
-                  SET(RECV_TYPE_ARG4 "${recv_arg4}")
-                  SET(RECV_TYPE_RETV "${recv_retv}")
-                  SET(HAVE_RECV 1)
-                  SET(curl_cv_func_recv_done 1)
-                ENDIF(curl_cv_func_recv_test)
-              ENDIF(NOT curl_cv_func_recv_done)
-            ENDFOREACH(recv_arg4)
-          ENDFOREACH(recv_arg3)
-        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")
-    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}")
+                  set(RECV_TYPE_ARG1 "${recv_arg1}")
+                  set(RECV_TYPE_ARG2 "${recv_arg2}")
+                  set(RECV_TYPE_ARG3 "${recv_arg3}")
+                  set(RECV_TYPE_ARG4 "${recv_arg4}")
+                  set(RECV_TYPE_RETV "${recv_retv}")
+                  set(HAVE_RECV 1)
+                  set(curl_cv_func_recv_done 1)
+                endif(curl_cv_func_recv_test)
+              endif(NOT curl_cv_func_recv_done)
+            endforeach(recv_arg4)
+          endforeach(recv_arg3)
+        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")
+    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(NOT DEFINED curl_cv_func_recv_args OR "${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")
-  ENDIF("${curl_cv_func_recv_args}" STREQUAL "unknown")
-ELSE(curl_cv_recv)
-  MESSAGE(FATAL_ERROR "Unable to link function recv")
-ENDIF(curl_cv_recv)
-SET(curl_cv_func_recv_args "${curl_cv_func_recv_args}" CACHE INTERNAL "Arguments for recv")
-SET(HAVE_RECV 1)
+  if("${curl_cv_func_recv_args}" STREQUAL "unknown")
+    message(FATAL_ERROR "Cannot find proper types to use for recv args")
+  endif("${curl_cv_func_recv_args}" STREQUAL "unknown")
+else(curl_cv_recv)
+  message(FATAL_ERROR "Unable to link function recv")
+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)
-IF(curl_cv_send)
+curl_check_c_source_compiles("send(0, 0, 0, 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")
-        FOREACH(send_arg2 "const void *" "void *" "char *" "const char *")
-          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("
+  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")
+        foreach(send_arg2 "const void *" "void *" "char *" "const char *")
+          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("
                     ${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})")
-                IF(curl_cv_func_send_test)
+                  curl_cv_func_send_test
+                  "${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
+                  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
                     "${send_arg1},${send_arg2},${send_arg3},${send_arg4},${send_retv},${send_qual_arg2}")
-                  SET(SEND_TYPE_ARG1 "${send_arg1}")
-                  SET(SEND_TYPE_ARG2 "${send_arg2}")
-                  SET(SEND_TYPE_ARG3 "${send_arg3}")
-                  SET(SEND_TYPE_ARG4 "${send_arg4}")
-                  SET(SEND_TYPE_RETV "${send_retv}")
-                  SET(HAVE_SEND 1)
-                  SET(curl_cv_func_send_done 1)
-                ENDIF(curl_cv_func_send_test)
-              ENDIF(NOT curl_cv_func_send_done)
-            ENDFOREACH(send_arg4)
-          ENDFOREACH(send_arg3)
-        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")
-    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}")
+                  set(SEND_TYPE_ARG1 "${send_arg1}")
+                  set(SEND_TYPE_ARG2 "${send_arg2}")
+                  set(SEND_TYPE_ARG3 "${send_arg3}")
+                  set(SEND_TYPE_ARG4 "${send_arg4}")
+                  set(SEND_TYPE_RETV "${send_retv}")
+                  set(HAVE_SEND 1)
+                  set(curl_cv_func_send_done 1)
+                endif(curl_cv_func_send_test)
+              endif(NOT curl_cv_func_send_done)
+            endforeach(send_arg4)
+          endforeach(send_arg3)
+        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")
+    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(NOT DEFINED curl_cv_func_send_args OR "${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")
-  ENDIF("${curl_cv_func_send_args}" STREQUAL "unknown")
-  SET(SEND_QUAL_ARG2 "const")
-ELSE(curl_cv_send)
-  MESSAGE(FATAL_ERROR "Unable to link function send")
-ENDIF(curl_cv_send)
-SET(curl_cv_func_send_args "${curl_cv_func_send_args}" CACHE INTERNAL "Arguments for send")
-SET(HAVE_SEND 1)
+  if("${curl_cv_func_send_args}" STREQUAL "unknown")
+    message(FATAL_ERROR "Cannot find proper types to use for send args")
+  endif("${curl_cv_func_send_args}" STREQUAL "unknown")
+  set(SEND_QUAL_ARG2 "const")
+else(curl_cv_send)
+  message(FATAL_ERROR "Unable to link function send")
+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 "${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)
+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
+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)
+  endif(${check})
+endmacro(add_header_include header)
 
-IF(HAVE_WINDOWS_H)
-  SET(EXTRA_DEFINES ${EXTRA_DEFINES}
+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)
+else(HAVE_WINDOWS_H)
   add_header_include(HAVE_SYS_TYPES_H "sys/types.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)
+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)
-IF(HAVE_SYS_POLL_H)
-  SET(HEADER_INCLUDES "sys/poll.h")
-ENDIF(HAVE_SYS_POLL_H)
-CURL_CHECK_C_SOURCE_RUNS("return poll((void *)0, 0, 10 /*ms*/)" HAVE_POLL_FINE)
+include(CurlCheckCSourceRuns)
+set(EXTRA_DEFINES)
+set(HEADER_INCLUDES)
+if(HAVE_SYS_POLL_H)
+  set(HEADER_INCLUDES "sys/poll.h")
+endif(HAVE_SYS_POLL_H)
+curl_check_c_source_runs("return poll((void *)0, 0, 10 /*ms*/)" HAVE_POLL_FINE)
 
-SET(HAVE_SIG_ATOMIC_T 1)
-SET(EXTRA_DEFINES)
-SET(HEADER_INCLUDES)
-IF(HAVE_SIGNAL_H)
-  SET(HEADER_INCLUDES "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)
-  IF(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
-    SET(HAVE_SIG_ATOMIC_T_VOLATILE 1)
-  ENDIF(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
-ENDIF(HAVE_SIZEOF_SIG_ATOMIC_T)
+set(HAVE_SIG_ATOMIC_T 1)
+set(EXTRA_DEFINES)
+set(HEADER_INCLUDES)
+if(HAVE_SIGNAL_H)
+  set(HEADER_INCLUDES "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)
+  if(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
+    set(HAVE_SIG_ATOMIC_T_VOLATILE 1)
+  endif(NOT HAVE_SIG_ATOMIC_T_NOT_VOLATILE)
+endif(HAVE_SIZEOF_SIG_ATOMIC_T)
 
-SET(CHECK_TYPE_SIZE_PREINCLUDE
+set(CHECK_TYPE_SIZE_PREINCLUDE
   "#undef inline")
 
-IF(HAVE_WINDOWS_H)
-  SET(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE}
+if(HAVE_WINDOWS_H)
+  set(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE}
   #ifndef WIN32_LEAN_AND_MEAN
   #define WIN32_LEAN_AND_MEAN
   #endif
   #include <windows.h>")
-  IF(HAVE_WINSOCK2_H)
-    SET(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE}\n#include <winsock2.h>")
-  ENDIF(HAVE_WINSOCK2_H)
-ELSE(HAVE_WINDOWS_H)
-  IF(HAVE_SYS_SOCKET_H)
-    SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
+  if(HAVE_WINSOCK2_H)
+    set(CHECK_TYPE_SIZE_PREINCLUDE "${CHECK_TYPE_SIZE_PREINCLUDE}\n#include <winsock2.h>")
+  endif(HAVE_WINSOCK2_H)
+else(HAVE_WINDOWS_H)
+  if(HAVE_SYS_SOCKET_H)
+    set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
       "sys/socket.h")
-  ENDIF(HAVE_SYS_SOCKET_H)
-  IF(HAVE_NETINET_IN_H)
-    SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
+  endif(HAVE_SYS_SOCKET_H)
+  if(HAVE_NETINET_IN_H)
+    set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
       "netinet/in.h")
-  ENDIF(HAVE_NETINET_IN_H)
-  IF(HAVE_ARPA_INET_H)
-    SET(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
+  endif(HAVE_NETINET_IN_H)
+  if(HAVE_ARPA_INET_H)
+    set(CMAKE_EXTRA_INCLUDE_FILES ${CMAKE_EXTRA_INCLUDE_FILES}
       "arpa/inet.h")
-  ENDIF(HAVE_ARPA_INET_H)
-ENDIF(HAVE_WINDOWS_H)
+  endif(HAVE_ARPA_INET_H)
+endif(HAVE_WINDOWS_H)
 
-CHECK_TYPE_SIZE("struct sockaddr_storage" SIZEOF_STRUCT_SOCKADDR_STORAGE)
-IF(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)
-  SET(HAVE_STRUCT_SOCKADDR_STORAGE 1)
-ENDIF(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)
+check_type_size("struct sockaddr_storage" SIZEOF_STRUCT_SOCKADDR_STORAGE)
+if(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)
+  set(HAVE_STRUCT_SOCKADDR_STORAGE 1)
+endif(HAVE_SIZEOF_STRUCT_SOCKADDR_STORAGE)
 
diff --git a/CMake/Platforms/WindowsCache.cmake b/CMake/Platforms/WindowsCache.cmake
index b4515ce04..49161f86d 100644
--- a/CMake/Platforms/WindowsCache.cmake
+++ b/CMake/Platforms/WindowsCache.cmake
@@ -1,121 +1,121 @@
-IF(NOT UNIX)
-  IF(WIN32)
-    SET(HAVE_LIBDL 0)
-    SET(HAVE_LIBUCB 0)
-    SET(HAVE_LIBSOCKET 0)
-    SET(NOT_NEED_LIBNSL 0)
-    SET(HAVE_LIBNSL 0)
-    SET(HAVE_LIBZ 0)
-    SET(HAVE_LIBCRYPTO 0)
+if(NOT UNIX)
+  if(WIN32)
+    set(HAVE_LIBDL 0)
+    set(HAVE_LIBUCB 0)
+    set(HAVE_LIBSOCKET 0)
+    set(NOT_NEED_LIBNSL 0)
+    set(HAVE_LIBNSL 0)
+    set(HAVE_LIBZ 0)
+    set(HAVE_LIBCRYPTO 0)
 
-    SET(HAVE_DLOPEN 0)
+    set(HAVE_DLOPEN 0)
 
-    SET(HAVE_ALLOCA_H 0)
-    SET(HAVE_ARPA_INET_H 0)
-    SET(HAVE_DLFCN_H 0)
-    SET(HAVE_FCNTL_H 1)
-    SET(HAVE_FEATURES_H 0)
-    SET(HAVE_INTTYPES_H 0)
-    SET(HAVE_IO_H 1)
-    SET(HAVE_MALLOC_H 1)
-    SET(HAVE_MEMORY_H 1)
-    SET(HAVE_NETDB_H 0)
-    SET(HAVE_NETINET_IF_ETHER_H 0)
-    SET(HAVE_NETINET_IN_H 0)
-    SET(HAVE_NET_IF_H 0)
-    SET(HAVE_PROCESS_H 1)
-    SET(HAVE_PWD_H 0)
-    SET(HAVE_SETJMP_H 1)
-    SET(HAVE_SGTTY_H 0)
-    SET(HAVE_SIGNAL_H 1)
-    SET(HAVE_SOCKIO_H 0)
-    SET(HAVE_STDINT_H 0)
-    SET(HAVE_STDLIB_H 1)
-    SET(HAVE_STRINGS_H 0)
-    SET(HAVE_STRING_H 1)
-    SET(HAVE_SYS_PARAM_H 0)
-    SET(HAVE_SYS_POLL_H 0)
-    SET(HAVE_SYS_SELECT_H 0)
-    SET(HAVE_SYS_SOCKET_H 0)
-    SET(HAVE_SYS_SOCKIO_H 0)
-    SET(HAVE_SYS_STAT_H 1)
-    SET(HAVE_SYS_TIME_H 0)
-    SET(HAVE_SYS_TYPES_H 1)
-    SET(HAVE_SYS_UTIME_H 1)
-    SET(HAVE_TERMIOS_H 0)
-    SET(HAVE_TERMIO_H 0)
-    SET(HAVE_TIME_H 1)
-    SET(HAVE_UNISTD_H 0)
-    SET(HAVE_UTIME_H 0)
-    SET(HAVE_X509_H 0)
-    SET(HAVE_ZLIB_H 0)
+    set(HAVE_ALLOCA_H 0)
+    set(HAVE_ARPA_INET_H 0)
+    set(HAVE_DLFCN_H 0)
+    set(HAVE_FCNTL_H 1)
+    set(HAVE_FEATURES_H 0)
+    set(HAVE_INTTYPES_H 0)
+    set(HAVE_IO_H 1)
+    set(HAVE_MALLOC_H 1)
+    set(HAVE_MEMORY_H 1)
+    set(HAVE_NETDB_H 0)
+    set(HAVE_NETINET_IF_ETHER_H 0)
+    set(HAVE_NETINET_IN_H 0)
+    set(HAVE_NET_IF_H 0)
+    set(HAVE_PROCESS_H 1)
+    set(HAVE_PWD_H 0)
+    set(HAVE_SETJMP_H 1)
+    set(HAVE_SGTTY_H 0)
+    set(HAVE_SIGNAL_H 1)
+    set(HAVE_SOCKIO_H 0)
+    set(HAVE_STDINT_H 0)
+    set(HAVE_STDLIB_H 1)
+    set(HAVE_STRINGS_H 0)
+    set(HAVE_STRING_H 1)
+    set(HAVE_SYS_PARAM_H 0)
+    set(HAVE_SYS_POLL_H 0)
+    set(HAVE_SYS_SELECT_H 0)
+    set(HAVE_SYS_SOCKET_H 0)
+    set(HAVE_SYS_SOCKIO_H 0)
+    set(HAVE_SYS_STAT_H 1)
+    set(HAVE_SYS_TIME_H 0)
+    set(HAVE_SYS_TYPES_H 1)
+    set(HAVE_SYS_UTIME_H 1)
+    set(HAVE_TERMIOS_H 0)
+    set(HAVE_TERMIO_H 0)
+    set(HAVE_TIME_H 1)
+    set(HAVE_UNISTD_H 0)
+    set(HAVE_UTIME_H 0)
+    set(HAVE_X509_H 0)
+    set(HAVE_ZLIB_H 0)
 
-    SET(HAVE_SIZEOF_LONG_DOUBLE 1)
-    SET(SIZEOF_LONG_DOUBLE 8)
+    set(HAVE_SIZEOF_LONG_DOUBLE 1)
+    set(SIZEOF_LONG_DOUBLE 8)
 
-    SET(HAVE_SOCKET 1)
-    SET(HAVE_POLL 0)
-    SET(HAVE_SELECT 1)
-    SET(HAVE_STRDUP 1)
-    SET(HAVE_STRSTR 1)
-    SET(HAVE_STRTOK_R 0)
-    SET(HAVE_STRFTIME 1)
-    SET(HAVE_UNAME 0)
-    SET(HAVE_STRCASECMP 0)
-    SET(HAVE_STRICMP 1)
-    SET(HAVE_STRCMPI 1)
-    SET(HAVE_GETHOSTBYADDR 1)
-    SET(HAVE_GETTIMEOFDAY 0)
-    SET(HAVE_INET_ADDR 1)
-    SET(HAVE_INET_NTOA 1)
-    SET(HAVE_INET_NTOA_R 0)
-    SET(HAVE_TCGETATTR 0)
-    SET(HAVE_TCSETATTR 0)
-    SET(HAVE_PERROR 1)
-    SET(HAVE_CLOSESOCKET 1)
-    SET(HAVE_SETVBUF 0)
-    SET(HAVE_SIGSETJMP 0)
-    SET(HAVE_GETPASS_R 0)
-    SET(HAVE_STRLCAT 0)
-    SET(HAVE_GETPWUID 0)
-    SET(HAVE_GETEUID 0)
-    SET(HAVE_UTIME 1)
-    SET(HAVE_RAND_EGD 0)
-    SET(HAVE_RAND_SCREEN 0)
-    SET(HAVE_RAND_STATUS 0)
-    SET(HAVE_GMTIME_R 0)
-    SET(HAVE_LOCALTIME_R 0)
-    SET(HAVE_GETHOSTBYADDR_R 0)
-    SET(HAVE_GETHOSTBYNAME_R 0)
-    SET(HAVE_SIGNAL_FUNC 1)
-    SET(HAVE_SIGNAL_MACRO 0)
+    set(HAVE_SOCKET 1)
+    set(HAVE_POLL 0)
+    set(HAVE_SELECT 1)
+    set(HAVE_STRDUP 1)
+    set(HAVE_STRSTR 1)
+    set(HAVE_STRTOK_R 0)
+    set(HAVE_STRFTIME 1)
+    set(HAVE_UNAME 0)
+    set(HAVE_STRCASECMP 0)
+    set(HAVE_STRICMP 1)
+    set(HAVE_STRCMPI 1)
+    set(HAVE_GETHOSTBYADDR 1)
+    set(HAVE_GETTIMEOFDAY 0)
+    set(HAVE_INET_ADDR 1)
+    set(HAVE_INET_NTOA 1)
+    set(HAVE_INET_NTOA_R 0)
+    set(HAVE_TCGETATTR 0)
+    set(HAVE_TCSETATTR 0)
+    set(HAVE_PERROR 1)
+    set(HAVE_CLOSESOCKET 1)
+    set(HAVE_SETVBUF 0)
+    set(HAVE_SIGSETJMP 0)
+    set(HAVE_GETPASS_R 0)
+    set(HAVE_STRLCAT 0)
+    set(HAVE_GETPWUID 0)
+    set(HAVE_GETEUID 0)
+    set(HAVE_UTIME 1)
+    set(HAVE_RAND_EGD 0)
+    set(HAVE_RAND_SCREEN 0)
+    set(HAVE_RAND_STATUS 0)
+    set(HAVE_GMTIME_R 0)
+    set(HAVE_LOCALTIME_R 0)
+    set(HAVE_GETHOSTBYADDR_R 0)
+    set(HAVE_GETHOSTBYNAME_R 0)
+    set(HAVE_SIGNAL_FUNC 1)
+    set(HAVE_SIGNAL_MACRO 0)
 
-    SET(HAVE_GETHOSTBYADDR_R_5 0)
-    SET(HAVE_GETHOSTBYADDR_R_5_REENTRANT 0)
-    SET(HAVE_GETHOSTBYADDR_R_7 0)
-    SET(HAVE_GETHOSTBYADDR_R_7_REENTRANT 0)
-    SET(HAVE_GETHOSTBYADDR_R_8 0)
-    SET(HAVE_GETHOSTBYADDR_R_8_REENTRANT 0)
-    SET(HAVE_GETHOSTBYNAME_R_3 0)
-    SET(HAVE_GETHOSTBYNAME_R_3_REENTRANT 0)
-    SET(HAVE_GETHOSTBYNAME_R_5 0)
-    SET(HAVE_GETHOSTBYNAME_R_5_REENTRANT 0)
-    SET(HAVE_GETHOSTBYNAME_R_6 0)
-    SET(HAVE_GETHOSTBYNAME_R_6_REENTRANT 0)
+    set(HAVE_GETHOSTBYADDR_R_5 0)
+    set(HAVE_GETHOSTBYADDR_R_5_REENTRANT 0)
+    set(HAVE_GETHOSTBYADDR_R_7 0)
+    set(HAVE_GETHOSTBYADDR_R_7_REENTRANT 0)
+    set(HAVE_GETHOSTBYADDR_R_8 0)
+    set(HAVE_GETHOSTBYADDR_R_8_REENTRANT 0)
+    set(HAVE_GETHOSTBYNAME_R_3 0)
+    set(HAVE_GETHOSTBYNAME_R_3_REENTRANT 0)
+    set(HAVE_GETHOSTBYNAME_R_5 0)
+    set(HAVE_GETHOSTBYNAME_R_5_REENTRANT 0)
+    set(HAVE_GETHOSTBYNAME_R_6 0)
+    set(HAVE_GETHOSTBYNAME_R_6_REENTRANT 0)
 
-    SET(TIME_WITH_SYS_TIME 0)
-    SET(HAVE_O_NONBLOCK 0)
-    SET(HAVE_IN_ADDR_T 0)
-    SET(HAVE_INET_NTOA_R_DECL 0)
-    SET(HAVE_INET_NTOA_R_DECL_REENTRANT 0)
-    SET(HAVE_GETADDRINFO 0)
-    SET(STDC_HEADERS 1)
-    SET(RETSIGTYPE_TEST 1)
+    set(TIME_WITH_SYS_TIME 0)
+    set(HAVE_O_NONBLOCK 0)
+    set(HAVE_IN_ADDR_T 0)
+    set(HAVE_INET_NTOA_R_DECL 0)
+    set(HAVE_INET_NTOA_R_DECL_REENTRANT 0)
+    set(HAVE_GETADDRINFO 0)
+    set(STDC_HEADERS 1)
+    set(RETSIGTYPE_TEST 1)
 
-    SET(HAVE_SIGACTION 0)
-    SET(HAVE_MACRO_SIGSETJMP 0)
-  ELSE(WIN32)
-    MESSAGE("This file should be included on Windows platform only")
-  ENDIF(WIN32)
-ENDIF(NOT UNIX)
+    set(HAVE_SIGACTION 0)
+    set(HAVE_MACRO_SIGSETJMP 0)
+  else(WIN32)
+    message("This file should be included on Windows platform only")
+  endif(WIN32)
+endif(NOT UNIX)
 
diff --git a/CMake/Utilities.cmake b/CMake/Utilities.cmake
index 4edf8b6d9..37cdfe3bf 100644
--- a/CMake/Utilities.cmake
+++ b/CMake/Utilities.cmake
@@ -1,31 +1,31 @@
 # File containing various utilities
 
 # Converts a CMake list to a string containing elements separated by spaces
-FUNCTION(TO_LIST_SPACES _LIST_NAME OUTPUT_VAR)
-  SET(NEW_LIST_SPACE)
-  FOREACH(ITEM ${${_LIST_NAME}})
-    SET(NEW_LIST_SPACE "${NEW_LIST_SPACE} ${ITEM}")
-  ENDFOREACH()
-  STRING(STRIP ${NEW_LIST_SPACE} NEW_LIST_SPACE)
-  SET(${OUTPUT_VAR} "${NEW_LIST_SPACE}" PARENT_SCOPE)
-ENDFUNCTION()
+function(TO_LIST_SPACES _LIST_NAME OUTPUT_VAR)
+  set(NEW_LIST_SPACE)
+  foreach(ITEM ${${_LIST_NAME}})
+    set(NEW_LIST_SPACE "${NEW_LIST_SPACE} ${ITEM}")
+  endforeach()
+  string(STRIP ${NEW_LIST_SPACE} NEW_LIST_SPACE)
+  set(${OUTPUT_VAR} "${NEW_LIST_SPACE}" PARENT_SCOPE)
+endfunction()
 
 # 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)
-  STRING(REPLACE " " ";" _LIST ${${LIST_NAME}})
-  LIST(APPEND _LIST ${ARGN})
-  LIST(REMOVE_DUPLICATES _LIST)
-  TO_LIST_SPACES(_LIST NEW_LIST_SPACE)
-  SET(${LIST_NAME} "${NEW_LIST_SPACE}" PARENT_SCOPE)
-ENDFUNCTION()
+function(LIST_SPACES_APPEND_ONCE LIST_NAME)
+  string(REPLACE " " ";" _LIST ${${LIST_NAME}})
+  list(APPEND _LIST ${ARGN})
+  list(REMOVE_DUPLICATES _LIST)
+  to_list_spaces(_LIST NEW_LIST_SPACE)
+  set(${LIST_NAME} "${NEW_LIST_SPACE}" PARENT_SCOPE)
+endfunction()
 
 # 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)
-FUNCTION(IN_STR_LIST LIST_NAME ITEM_SEARCHED RETVAL)
-	LIST(FIND ${LIST_NAME} ${ITEM_SEARCHED} FIND_POS)
-	IF(${FIND_POS} EQUAL -1)
-		SET(${RETVAL} FALSE PARENT_SCOPE)
-	ELSE()
-		SET(${RETVAL} TRUE PARENT_SCOPE)
-	ENDIF()
-ENDFUNCTION()
+function(IN_STR_LIST LIST_NAME ITEM_SEARCHED RETVAL)
+  list(FIND ${LIST_NAME} ${ITEM_SEARCHED} FIND_POS)
+  if(${FIND_POS} EQUAL -1)
+    set(${RETVAL} FALSE PARENT_SCOPE)
+  else()
+    set(${RETVAL} TRUE PARENT_SCOPE)
+  endif()
+endfunction()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f21c1c64b..330dccf83 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,366 +17,366 @@
 # To check:
 # (From Daniel Stenberg) The cmake build selected to run gcc with -fPIC on my box while the plain configure script did not.
 # (From Daniel Stenberg) The gcc command line use neither -g nor any -O options. As a developer, I also treasure our configure scripts's --enable-debug option that sets a long range of "picky" compiler options.
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6.2 FATAL_ERROR)
-SET(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}")
-INCLUDE(Utilities)
+cmake_minimum_required(VERSION 2.6.2 FATAL_ERROR)
+set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}")
+include(Utilities)
 
 project( CURL C )
-SET(CURL_MAJOR_VERSION 7)
-SET(CURL_MINOR_VERSION 19)
-SET(CURL_PATCH_VERSION 4)
+set(CURL_MAJOR_VERSION 7)
+set(CURL_MINOR_VERSION 19)
+set(CURL_PATCH_VERSION 4)
 
-INCLUDE_REGULAR_EXPRESSION("^.*$")    # Sukender: Is it necessary?
+include_regular_expression("^.*$")    # Sukender: Is it necessary?
 
 # Setup package meta-data
 # SET(PACKAGE "curl")
-SET(CURL_VERSION ${CURL_MAJOR_VERSION}.${CURL_MINOR_VERSION}.${CURL_PATCH_VERSION})
+set(CURL_VERSION ${CURL_MAJOR_VERSION}.${CURL_MINOR_VERSION}.${CURL_PATCH_VERSION})
 # SET(PACKAGE_TARNAME "curl")
 # SET(PACKAGE_NAME "curl")
 # SET(PACKAGE_VERSION "-")
 # SET(PACKAGE_STRING "curl-")
 # SET(PACKAGE_BUGREPORT "a suitable curl mailing list => http://curl.haxx.se/mail/")
-SET(OPERATING_SYSTEM "${CMAKE_SYSTEM_NAME}")
-SET(OS "\"${CMAKE_SYSTEM_NAME}\"")
+set(OPERATING_SYSTEM "${CMAKE_SYSTEM_NAME}")
+set(OS "\"${CMAKE_SYSTEM_NAME}\"")
 
 # Make the base headers visible to everything
 # IF(NOT ${PROJECT_BINARY_DIR} EQUAL ${PROJECT_SOURCE_DIR})
-   # INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR}/include)
+# INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR}/include)
 # ENDIF()
-INCLUDE_DIRECTORIES( ${CURL_SOURCE_DIR}/include )
+include_directories( ${CURL_SOURCE_DIR}/include )
 
-IF(WIN32)
-  SET(NATIVE_WINDOWS ON)
-ENDIF()
+if(WIN32)
+  set(NATIVE_WINDOWS ON)
+endif()
 
-OPTION(BUILD_CURL_EXE "Set to ON to build cURL executable." ON)
-OPTION(BUILD_CURL_TESTS "Set to ON to build cURL tests." ON)
-OPTION(CURL_STATICLIB "Set to ON to build libcurl with static linking." OFF)
+option(BUILD_CURL_EXE "Set to ON to build cURL executable." ON)
+option(BUILD_CURL_TESTS "Set to ON to build cURL tests." ON)
+option(CURL_STATICLIB "Set to ON to build libcurl with static linking." OFF)
 
-OPTION(BUILD_DASHBOARD_REPORTS "Set to ON to activate reporting of cURL builds here http://www.cdash.org/CDashPublic/index.php?project=CURL" OFF)
-IF(BUILD_DASHBOARD_REPORTS)
+option(BUILD_DASHBOARD_REPORTS "Set to ON to activate reporting of cURL builds here http://www.cdash.org/CDashPublic/index.php?project=CURL" OFF)
+if(BUILD_DASHBOARD_REPORTS)
   #INCLUDE(Dart)
-  INCLUDE(CTest)
-ENDIF(BUILD_DASHBOARD_REPORTS)
+  include(CTest)
+endif(BUILD_DASHBOARD_REPORTS)
 
-IF(MSVC)
-  OPTION(BUILD_RELEASE_DEBUG_DIRS "Set OFF to build each configuration to a separate directory" OFF)
-  MARK_AS_ADVANCED(BUILD_RELEASE_DEBUG_DIRS)
-ENDIF()
+if(MSVC)
+  option(BUILD_RELEASE_DEBUG_DIRS "Set OFF to build each configuration to a separate directory" OFF)
+  mark_as_advanced(BUILD_RELEASE_DEBUG_DIRS)
+endif()
 
-OPTION(CURL_HIDDEN_SYMBOLS "Set to ON to hide libcurl internal symbols (=hide all symbols that aren't officially external)." ON)
-MARK_AS_ADVANCED(CURL_HIDDEN_SYMBOLS)
+option(CURL_HIDDEN_SYMBOLS "Set to ON to hide libcurl internal symbols (=hide all symbols that aren't officially external)." ON)
+mark_as_advanced(CURL_HIDDEN_SYMBOLS)
 
 # IF(WIN32)
-  # OPTION(CURL_WINDOWS_SSPI "Use windows libraries to allow NTLM authentication without openssl" ON)
-  # MARK_AS_ADVANCED(CURL_WINDOWS_SSPI)
+# OPTION(CURL_WINDOWS_SSPI "Use windows libraries to allow NTLM authentication without openssl" ON)
+# MARK_AS_ADVANCED(CURL_WINDOWS_SSPI)
 # ENDIF()
 
-OPTION(HTTP_ONLY "disables all protocols except HTTP (This overrides all CURL_DISABLE_* options)" OFF)
-MARK_AS_ADVANCED(HTTP_ONLY)
-OPTION(CURL_DISABLE_FTP "disables FTP" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_FTP)
-OPTION(CURL_DISABLE_LDAP "disables LDAP" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_LDAP)
-OPTION(CURL_DISABLE_TELNET "disables Telnet" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_TELNET)
-OPTION(CURL_DISABLE_DICT "disables DICT" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_DICT)
-OPTION(CURL_DISABLE_FILE "disables FILE" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_FILE)
-OPTION(CURL_DISABLE_TFTP "disables TFTP" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_TFTP)
-OPTION(CURL_DISABLE_HTTP "disables HTTP" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_HTTP)
-
-OPTION(CURL_DISABLE_LDAPS "to disable LDAPS" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_LDAPS)
-IF(WIN32)
-  OPTION(CURL_LDAP_WIN "Use W$ LDAP implementation" ON)
-  MARK_AS_ADVANCED(CURL_LDAP_WIN)
-  SET(CURL_LDAP_HYBRID OFF)
-ELSE()
-  OPTION(CURL_LDAP_HYBRID "W$ LDAP with non-W$ compiler" OFF)
-  MARK_AS_ADVANCED(CURL_LDAP_HYBRID)
-  SET(CURL_LDAP_WIN OFF)
-ENDIF()
-
-IF(HTTP_ONLY)
-  SET(CURL_DISABLE_FTP ON)
-  SET(CURL_DISABLE_LDAP ON)
-  SET(CURL_DISABLE_TELNET ON)
-  SET(CURL_DISABLE_DICT ON)
-  SET(CURL_DISABLE_FILE ON)
-  SET(CURL_DISABLE_TFTP ON)
-ENDIF()
-
-OPTION(CURL_DISABLE_COOKIES "to disable cookies support" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_COOKIES)
-
-OPTION(CURL_DISABLE_CRYPTO_AUTH "to disable cryptographic authentication" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_CRYPTO_AUTH)
-OPTION(CURL_DISABLE_VERBOSE_STRINGS "to disable verbose strings" OFF)
-MARK_AS_ADVANCED(CURL_DISABLE_VERBOSE_STRINGS)
-OPTION(DISABLED_THREADSAFE "Set to explicitly specify we don't want to use thread-safe functions" OFF)
-MARK_AS_ADVANCED(DISABLED_THREADSAFE)
-OPTION(ENABLE_IPV6 "Define if you want to enable IPv6 support" OFF)
-MARK_AS_ADVANCED(ENABLE_IPV6)
-
-IF(WIN32)
-  LIST_SPACES_APPEND_ONCE(CMAKE_C_STANDARD_LIBRARIES wsock32.lib ws2_32.lib)  # bufferoverflowu.lib
-  IF(CURL_DISABLE_LDAP)
+option(HTTP_ONLY "disables all protocols except HTTP (This overrides all CURL_DISABLE_* options)" OFF)
+mark_as_advanced(HTTP_ONLY)
+option(CURL_DISABLE_FTP "disables FTP" OFF)
+mark_as_advanced(CURL_DISABLE_FTP)
+option(CURL_DISABLE_LDAP "disables LDAP" OFF)
+mark_as_advanced(CURL_DISABLE_LDAP)
+option(CURL_DISABLE_TELNET "disables Telnet" OFF)
+mark_as_advanced(CURL_DISABLE_TELNET)
+option(CURL_DISABLE_DICT "disables DICT" OFF)
+mark_as_advanced(CURL_DISABLE_DICT)
+option(CURL_DISABLE_FILE "disables FILE" OFF)
+mark_as_advanced(CURL_DISABLE_FILE)
+option(CURL_DISABLE_TFTP "disables TFTP" OFF)
+mark_as_advanced(CURL_DISABLE_TFTP)
+option(CURL_DISABLE_HTTP "disables HTTP" OFF)
+mark_as_advanced(CURL_DISABLE_HTTP)
+
+option(CURL_DISABLE_LDAPS "to disable LDAPS" OFF)
+mark_as_advanced(CURL_DISABLE_LDAPS)
+if(WIN32)
+  option(CURL_LDAP_WIN "Use W$ LDAP implementation" ON)
+  mark_as_advanced(CURL_LDAP_WIN)
+  set(CURL_LDAP_HYBRID OFF)
+else()
+  option(CURL_LDAP_HYBRID "W$ LDAP with non-W$ compiler" OFF)
+  mark_as_advanced(CURL_LDAP_HYBRID)
+  set(CURL_LDAP_WIN OFF)
+endif()
+
+if(HTTP_ONLY)
+  set(CURL_DISABLE_FTP ON)
+  set(CURL_DISABLE_LDAP ON)
+  set(CURL_DISABLE_TELNET ON)
+  set(CURL_DISABLE_DICT ON)
+  set(CURL_DISABLE_FILE ON)
+  set(CURL_DISABLE_TFTP ON)
+endif()
+
+option(CURL_DISABLE_COOKIES "to disable cookies support" OFF)
+mark_as_advanced(CURL_DISABLE_COOKIES)
+
+option(CURL_DISABLE_CRYPTO_AUTH "to disable cryptographic authentication" OFF)
+mark_as_advanced(CURL_DISABLE_CRYPTO_AUTH)
+option(CURL_DISABLE_VERBOSE_STRINGS "to disable verbose strings" OFF)
+mark_as_advanced(CURL_DISABLE_VERBOSE_STRINGS)
+option(DISABLED_THREADSAFE "Set to explicitly specify we don't want to use thread-safe functions" OFF)
+mark_as_advanced(DISABLED_THREADSAFE)
+option(ENABLE_IPV6 "Define if you want to enable IPv6 support" OFF)
+mark_as_advanced(ENABLE_IPV6)
+
+if(WIN32)
+  list_spaces_append_once(CMAKE_C_STANDARD_LIBRARIES wsock32.lib ws2_32.lib)  # bufferoverflowu.lib
+  if(CURL_DISABLE_LDAP)
     # Remove wldap32.lib from space-separated list
-    STRING(REPLACE " " ";" _LIST ${CMAKE_C_STANDARD_LIBRARIES})
-    LIST(REMOVE_ITEM _LIST "wldap32.lib")
-    TO_LIST_SPACES(_LIST CMAKE_C_STANDARD_LIBRARIES)
-  ELSE()
+    string(REPLACE " " ";" _LIST ${CMAKE_C_STANDARD_LIBRARIES})
+    list(REMOVE_ITEM _LIST "wldap32.lib")
+    to_list_spaces(_LIST CMAKE_C_STANDARD_LIBRARIES)
+  else()
     # Append wldap32.lib
-    LIST_SPACES_APPEND_ONCE(CMAKE_C_STANDARD_LIBRARIES wldap32.lib)
-  ENDIF()
-  SET(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES}"   CACHE STRING "" FORCE)
-ENDIF()
+    list_spaces_append_once(CMAKE_C_STANDARD_LIBRARIES wldap32.lib)
+  endif()
+  set(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES}"   CACHE STRING "" FORCE)
+endif()
 
 
 # We need ansi c-flags, especially on HP
-SET(CMAKE_C_FLAGS "${CMAKE_ANSI_CFLAGS} ${CMAKE_C_FLAGS}")
-SET(CMAKE_REQUIRED_FLAGS ${CMAKE_ANSI_CFLAGS})
+set(CMAKE_C_FLAGS "${CMAKE_ANSI_CFLAGS} ${CMAKE_C_FLAGS}")
+set(CMAKE_REQUIRED_FLAGS ${CMAKE_ANSI_CFLAGS})
 
 # Disable warnings on Borland to avoid changing 3rd party code.
-IF(BORLAND)
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w-")
-ENDIF(BORLAND)
+if(BORLAND)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w-")
+endif(BORLAND)
 
 # If we are on AIX, do the _ALL_SOURCE magic
-IF(${CMAKE_SYSTEM_NAME} MATCHES AIX)
-  SET(_ALL_SOURCE 1)
-ENDIF(${CMAKE_SYSTEM_NAME} MATCHES AIX)
+if(${CMAKE_SYSTEM_NAME} MATCHES AIX)
+  set(_ALL_SOURCE 1)
+endif(${CMAKE_SYSTEM_NAME} MATCHES AIX)
 
 # Include all the necessary files for macros
-INCLUDE (CheckFunctionExists)
-INCLUDE (CheckIncludeFile)
-INCLUDE (CheckIncludeFiles)
-INCLUDE (CheckLibraryExists)
-INCLUDE (CheckSymbolExists)
+include (CheckFunctionExists)
+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)
+if(CMAKE_CROSSCOMPILING)  
+  include ("${CMAKE_MODULE_PATH}/CheckTypeSize.cmake")
+else(CMAKE_CROSSCOMPILING)
+  include (CheckTypeSize)
+endif(CMAKE_CROSSCOMPILING)
 
 # On windows preload settings
-IF(WIN32)
-  INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/CMake/Platforms/WindowsCache.cmake)
-ENDIF(WIN32)
+if(WIN32)
+  include(${CMAKE_CURRENT_SOURCE_DIR}/CMake/Platforms/WindowsCache.cmake)
+endif(WIN32)
 
 # This macro checks if the symbol exists in the library and if it
 # does, it appends library to the list.
-SET(CURL_LIBS "")
-MACRO(CHECK_LIBRARY_EXISTS_CONCAT LIBRARY SYMBOL VARIABLE)
-  CHECK_LIBRARY_EXISTS("${LIBRARY};${CURL_LIBS}" ${SYMBOL} "" 
+set(CURL_LIBS "")
+macro(CHECK_LIBRARY_EXISTS_CONCAT LIBRARY SYMBOL VARIABLE)
+  check_library_exists("${LIBRARY};${CURL_LIBS}" ${SYMBOL} "" 
     ${VARIABLE})
-  IF(${VARIABLE})
-    SET(CURL_LIBS ${CURL_LIBS} ${LIBRARY})
-  ENDIF(${VARIABLE})
-ENDMACRO(CHECK_LIBRARY_EXISTS_CONCAT)
+  if(${VARIABLE})
+    set(CURL_LIBS ${CURL_LIBS} ${LIBRARY})
+  endif(${VARIABLE})
+endmacro(CHECK_LIBRARY_EXISTS_CONCAT)
 
 # Check for all needed libraries
-CHECK_LIBRARY_EXISTS_CONCAT("dl"     dlopen       HAVE_LIBDL)
+check_library_exists_concat("dl"     dlopen       HAVE_LIBDL)
 #CHECK_LIBRARY_EXISTS_CONCAT("ucb"    gethostname  HAVE_LIBUCB)
-CHECK_LIBRARY_EXISTS_CONCAT("socket" connect      HAVE_LIBSOCKET)
-CHECK_LIBRARY_EXISTS("c" gethostbyname "" NOT_NEED_LIBNSL)
+check_library_exists_concat("socket" connect      HAVE_LIBSOCKET)
+check_library_exists("c" gethostbyname "" NOT_NEED_LIBNSL)
 
 # Yellowtab Zeta needs different libraries than BeOS 5.
-IF(BEOS)
-  SET(NOT_NEED_LIBNSL 1)
-  CHECK_LIBRARY_EXISTS_CONCAT("bind" gethostbyname HAVE_LIBBIND)
-  CHECK_LIBRARY_EXISTS_CONCAT("bnetapi" closesocket HAVE_LIBBNETAPI)
-ENDIF(BEOS)
-
-IF(NOT NOT_NEED_LIBNSL)
-  CHECK_LIBRARY_EXISTS_CONCAT("nsl"    gethostbyname  HAVE_LIBNSL)
-ENDIF(NOT NOT_NEED_LIBNSL)
-
-CHECK_LIBRARY_EXISTS_CONCAT("ws2_32" getch        HAVE_LIBWS2_32)
-CHECK_LIBRARY_EXISTS_CONCAT("winmm"  getch        HAVE_LIBWINMM)
+if(BEOS)
+  set(NOT_NEED_LIBNSL 1)
+  check_library_exists_concat("bind" gethostbyname HAVE_LIBBIND)
+  check_library_exists_concat("bnetapi" closesocket HAVE_LIBBNETAPI)
+endif(BEOS)
+
+if(NOT NOT_NEED_LIBNSL)
+  check_library_exists_concat("nsl"    gethostbyname  HAVE_LIBNSL)
+endif(NOT NOT_NEED_LIBNSL)
+
+check_library_exists_concat("ws2_32" getch        HAVE_LIBWS2_32)
+check_library_exists_concat("winmm"  getch        HAVE_LIBWINMM)
 # IF(NOT CURL_SPECIAL_LIBZ)
 #  CHECK_LIBRARY_EXISTS_CONCAT("z"      inflateEnd   HAVE_LIBZ)
 # ENDIF(NOT CURL_SPECIAL_LIBZ)
 
-OPTION(CMAKE_USE_OPENSSL "Use OpenSSL code. Experimental" ON)
-MARK_AS_ADVANCED(CMAKE_USE_OPENSSL)
-IF(CMAKE_USE_OPENSSL)
-  IF(WIN32)
-  FIND_PACKAGE(OpenSSL)
-  IF(OPENSSL_FOUND)
-    SET(USE_SSLEAY TRUE)
-    SET(USE_OPENSSL TRUE)
-    LIST(APPEND CURL_LIBS ${OPENSSL_LIBRARIES} )
-  ENDIF()
+option(CMAKE_USE_OPENSSL "Use OpenSSL code. Experimental" ON)
+mark_as_advanced(CMAKE_USE_OPENSSL)
+if(CMAKE_USE_OPENSSL)
+  if(WIN32)
+    find_package(OpenSSL)
+    if(OPENSSL_FOUND)
+      set(USE_SSLEAY TRUE)
+      set(USE_OPENSSL TRUE)
+      list(APPEND CURL_LIBS ${OPENSSL_LIBRARIES} )
+    endif()
     #FIND_LIBRARY(LIBEAY NAMES libeay32)
     #LIST(APPEND CURL_LIBS ${LIBEAY} )
-  ELSE(WIN32)
-    CHECK_LIBRARY_EXISTS_CONCAT("crypto" CRYPTO_lock  HAVE_LIBCRYPTO)
-    CHECK_LIBRARY_EXISTS_CONCAT("ssl"    SSL_connect  HAVE_LIBSSL)
-  ENDIF(WIN32)
-ENDIF(CMAKE_USE_OPENSSL)
+  else(WIN32)
+    check_library_exists_concat("crypto" CRYPTO_lock  HAVE_LIBCRYPTO)
+    check_library_exists_concat("ssl"    SSL_connect  HAVE_LIBSSL)
+  endif(WIN32)
+endif(CMAKE_USE_OPENSSL)
 
 # Check for idn
-CHECK_LIBRARY_EXISTS_CONCAT("idn" idna_to_ascii_lz HAVE_LIBIDN)
+check_library_exists_concat("idn" idna_to_ascii_lz HAVE_LIBIDN)
 
 # Check for LDAP
-CHECK_LIBRARY_EXISTS_CONCAT("ldap" ldap_init HAVE_LIBLDAP)
+check_library_exists_concat("ldap" ldap_init HAVE_LIBLDAP)
 # if(NOT HAVE_LIBLDAP)
-    # SET(CURL_DISABLE_LDAP ON)
+# SET(CURL_DISABLE_LDAP ON)
 # endif(NOT HAVE_LIBLDAP)
 
 # Check for symbol dlopen (same as HAVE_LIBDL)
-CHECK_LIBRARY_EXISTS("${CURL_LIBS}" dlopen "" HAVE_DLOPEN)
+check_library_exists("${CURL_LIBS}" dlopen "" HAVE_DLOPEN)
 
 # For other tests to use the same libraries
-SET(CMAKE_REQUIRED_LIBRARIES ${CURL_LIBS})
-
-OPTION(CURL_ZLIB "Set to ON to enable building cURL with zlib support." ON)
-SET(HAVE_LIBZ OFF)
-SET(HAVE_ZLIB_H OFF)
-SET(HAVE_ZLIB OFF)
-IF(CURL_ZLIB)  # AND CURL_CONFIG_HAS_BEEN_RUN_BEFORE
-  FIND_PACKAGE(ZLIB)
-  IF(ZLIB_FOUND)
-    SET(HAVE_ZLIB_H ON)
-    SET(HAVE_ZLIB ON)
-    SET(HAVE_LIBZ ON)
-  ENDIF()
-ENDIF()
+set(CMAKE_REQUIRED_LIBRARIES ${CURL_LIBS})
+
+option(CURL_ZLIB "Set to ON to enable building cURL with zlib support." ON)
+set(HAVE_LIBZ OFF)
+set(HAVE_ZLIB_H OFF)
+set(HAVE_ZLIB OFF)
+if(CURL_ZLIB)  # AND CURL_CONFIG_HAS_BEEN_RUN_BEFORE
+  find_package(ZLIB)
+  if(ZLIB_FOUND)
+    set(HAVE_ZLIB_H ON)
+    set(HAVE_ZLIB ON)
+    set(HAVE_LIBZ ON)
+  endif()
+endif()
 
 # If we have features.h, then do the _BSD_SOURCE magic
-CHECK_INCLUDE_FILE("features.h"       HAVE_FEATURES_H)
+check_include_file("features.h"       HAVE_FEATURES_H)
 
 # Check if header file exists and add it to the list.
-MACRO(CHECK_INCLUDE_FILE_CONCAT FILE VARIABLE)
-  CHECK_INCLUDE_FILES("${CURL_INCLUDES};${FILE}" ${VARIABLE})
-  IF(${VARIABLE})
-    SET(CURL_INCLUDES ${CURL_INCLUDES} ${FILE})
-    SET(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -D${VARIABLE}")
-  ENDIF(${VARIABLE})
-ENDMACRO(CHECK_INCLUDE_FILE_CONCAT)
+macro(CHECK_INCLUDE_FILE_CONCAT FILE VARIABLE)
+  check_include_files("${CURL_INCLUDES};${FILE}" ${VARIABLE})
+  if(${VARIABLE})
+    set(CURL_INCLUDES ${CURL_INCLUDES} ${FILE})
+    set(CURL_TEST_DEFINES "${CURL_TEST_DEFINES} -D${VARIABLE}")
+  endif(${VARIABLE})
+endmacro(CHECK_INCLUDE_FILE_CONCAT)
 
 
 # Check for header files
-IF(NOT UNIX)
-  CHECK_INCLUDE_FILE_CONCAT("ws2tcpip.h"     HAVE_WS2TCPIP_H)
-  CHECK_INCLUDE_FILE_CONCAT("winsock2.h"     HAVE_WINSOCK2_H)
-ENDIF(NOT UNIX)
-CHECK_INCLUDE_FILE_CONCAT("stdio.h"          HAVE_STDIO_H)
-IF(NOT UNIX)
-  CHECK_INCLUDE_FILE_CONCAT("windows.h"      HAVE_WINDOWS_H)
-  CHECK_INCLUDE_FILE_CONCAT("winsock.h"      HAVE_WINSOCK_H)
-ENDIF(NOT UNIX)
-
-CHECK_INCLUDE_FILE_CONCAT("inttypes.h"       HAVE_INTTYPES_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/filio.h"      HAVE_SYS_FILIO_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/ioctl.h"      HAVE_SYS_IOCTL_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/param.h"      HAVE_SYS_PARAM_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/poll.h"       HAVE_SYS_POLL_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/resource.h"   HAVE_SYS_RESOURCE_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/select.h"     HAVE_SYS_SELECT_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/socket.h"     HAVE_SYS_SOCKET_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/sockio.h"     HAVE_SYS_SOCKIO_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/stat.h"       HAVE_SYS_STAT_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/time.h"       HAVE_SYS_TIME_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/types.h"      HAVE_SYS_TYPES_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/uio.h"        HAVE_SYS_UIO_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/un.h"         HAVE_SYS_UN_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/utime.h"      HAVE_SYS_UTIME_H)
-CHECK_INCLUDE_FILE_CONCAT("alloca.h"         HAVE_ALLOCA_H)
-CHECK_INCLUDE_FILE_CONCAT("arpa/inet.h"      HAVE_ARPA_INET_H)
-CHECK_INCLUDE_FILE_CONCAT("arpa/tftp.h"      HAVE_ARPA_TFTP_H)
-CHECK_INCLUDE_FILE_CONCAT("assert.h"         HAVE_ASSERT_H)
-CHECK_INCLUDE_FILE_CONCAT("crypto.h"         HAVE_CRYPTO_H)
-CHECK_INCLUDE_FILE_CONCAT("des.h"            HAVE_DES_H)
-CHECK_INCLUDE_FILE_CONCAT("err.h"            HAVE_ERR_H)
-CHECK_INCLUDE_FILE_CONCAT("errno.h"          HAVE_ERRNO_H)
-CHECK_INCLUDE_FILE_CONCAT("fcntl.h"          HAVE_FCNTL_H)
-CHECK_INCLUDE_FILE_CONCAT("gssapi/gssapi.h"  HAVE_GSSAPI_GSSAPI_H)
-CHECK_INCLUDE_FILE_CONCAT("gssapi/gssapi_generic.h" HAVE_GSSAPI_GSSAPI_GENERIC_H)
-CHECK_INCLUDE_FILE_CONCAT("gssapi/gssapi_krb5.h" HAVE_GSSAPI_GSSAPI_KRB5_H)
-CHECK_INCLUDE_FILE_CONCAT("idn-free.h"       HAVE_IDN_FREE_H)
-CHECK_INCLUDE_FILE_CONCAT("ifaddrs.h"        HAVE_IFADDRS_H)
-CHECK_INCLUDE_FILE_CONCAT("io.h"             HAVE_IO_H)
-CHECK_INCLUDE_FILE_CONCAT("krb.h"            HAVE_KRB_H)
-CHECK_INCLUDE_FILE_CONCAT("libgen.h"         HAVE_LIBGEN_H)
-CHECK_INCLUDE_FILE_CONCAT("libssh2.h"        HAVE_LIBSSH2_H)
-CHECK_INCLUDE_FILE_CONCAT("limits.h"         HAVE_LIMITS_H)
-CHECK_INCLUDE_FILE_CONCAT("locale.h"         HAVE_LOCALE_H)
-CHECK_INCLUDE_FILE_CONCAT("net/if.h"         HAVE_NET_IF_H)
-CHECK_INCLUDE_FILE_CONCAT("netdb.h"          HAVE_NETDB_H)
-CHECK_INCLUDE_FILE_CONCAT("netinet/in.h"     HAVE_NETINET_IN_H)
-CHECK_INCLUDE_FILE_CONCAT("netinet/tcp.h"    HAVE_NETINET_TCP_H)
-CHECK_INCLUDE_FILE_CONCAT("openssl/crypto.h" HAVE_OPENSSL_CRYPTO_H)
-CHECK_INCLUDE_FILE_CONCAT("openssl/engine.h" HAVE_OPENSSL_ENGINE_H)
-CHECK_INCLUDE_FILE_CONCAT("openssl/err.h"    HAVE_OPENSSL_ERR_H)
-CHECK_INCLUDE_FILE_CONCAT("openssl/pem.h"    HAVE_OPENSSL_PEM_H)
-CHECK_INCLUDE_FILE_CONCAT("openssl/pkcs12.h" HAVE_OPENSSL_PKCS12_H)
-CHECK_INCLUDE_FILE_CONCAT("openssl/rsa.h"    HAVE_OPENSSL_RSA_H)
-CHECK_INCLUDE_FILE_CONCAT("openssl/ssl.h"    HAVE_OPENSSL_SSL_H)
-CHECK_INCLUDE_FILE_CONCAT("openssl/x509.h"   HAVE_OPENSSL_X509_H)
-CHECK_INCLUDE_FILE_CONCAT("pem.h"            HAVE_PEM_H)
-CHECK_INCLUDE_FILE_CONCAT("poll.h"           HAVE_POLL_H)
-CHECK_INCLUDE_FILE_CONCAT("pwd.h"            HAVE_PWD_H)
-CHECK_INCLUDE_FILE_CONCAT("rsa.h"            HAVE_RSA_H)
-CHECK_INCLUDE_FILE_CONCAT("setjmp.h"         HAVE_SETJMP_H)
-CHECK_INCLUDE_FILE_CONCAT("sgtty.h"          HAVE_SGTTY_H)
-CHECK_INCLUDE_FILE_CONCAT("signal.h"         HAVE_SIGNAL_H)
-CHECK_INCLUDE_FILE_CONCAT("ssl.h"            HAVE_SSL_H)
-CHECK_INCLUDE_FILE_CONCAT("stdbool.h"        HAVE_STDBOOL_H)
-CHECK_INCLUDE_FILE_CONCAT("stdint.h"         HAVE_STDINT_H)
-CHECK_INCLUDE_FILE_CONCAT("stdio.h"          HAVE_STDIO_H)
-CHECK_INCLUDE_FILE_CONCAT("stdlib.h"         HAVE_STDLIB_H)
-CHECK_INCLUDE_FILE_CONCAT("string.h"         HAVE_STRING_H)
-CHECK_INCLUDE_FILE_CONCAT("strings.h"        HAVE_STRINGS_H)
-CHECK_INCLUDE_FILE_CONCAT("stropts.h"        HAVE_STROPTS_H)
-CHECK_INCLUDE_FILE_CONCAT("termio.h"         HAVE_TERMIO_H)
-CHECK_INCLUDE_FILE_CONCAT("termios.h"        HAVE_TERMIOS_H)
-CHECK_INCLUDE_FILE_CONCAT("time.h"           HAVE_TIME_H)
-CHECK_INCLUDE_FILE_CONCAT("tld.h"            HAVE_TLD_H)
-CHECK_INCLUDE_FILE_CONCAT("unistd.h"         HAVE_UNISTD_H)
-CHECK_INCLUDE_FILE_CONCAT("utime.h"          HAVE_UTIME_H)
-CHECK_INCLUDE_FILE_CONCAT("x509.h"           HAVE_X509_H)
-
-CHECK_INCLUDE_FILE_CONCAT("process.h"        HAVE_PROCESS_H)
-CHECK_INCLUDE_FILE_CONCAT("stddef.h"         HAVE_STDDEF_H)
-CHECK_INCLUDE_FILE_CONCAT("dlfcn.h"          HAVE_DLFCN_H)
-CHECK_INCLUDE_FILE_CONCAT("malloc.h"         HAVE_MALLOC_H)
-CHECK_INCLUDE_FILE_CONCAT("memory.h"         HAVE_MEMORY_H)
-CHECK_INCLUDE_FILE_CONCAT("ldap.h"           HAVE_LDAP_H)
-CHECK_INCLUDE_FILE_CONCAT("netinet/if_ether.h" HAVE_NETINET_IF_ETHER_H)
-CHECK_INCLUDE_FILE_CONCAT("stdint.h"        HAVE_STDINT_H)
-CHECK_INCLUDE_FILE_CONCAT("sockio.h"        HAVE_SOCKIO_H)
-CHECK_INCLUDE_FILE_CONCAT("sys/utsname.h"   HAVE_SYS_UTSNAME_H)
-CHECK_INCLUDE_FILE_CONCAT("idna.h"          HAVE_IDNA_H)
-
-IF(CMAKE_USE_OPENSSL)
-  CHECK_INCLUDE_FILE_CONCAT("openssl/rand.h"   HAVE_OPENSSL_RAND_H)
-ENDIF(CMAKE_USE_OPENSSL)
-
-
-CHECK_TYPE_SIZE(size_t  SIZEOF_SIZE_T)
-CHECK_TYPE_SIZE(ssize_t  SIZEOF_SSIZE_T)
-CHECK_TYPE_SIZE("long long"  SIZEOF_LONG_LONG)
-CHECK_TYPE_SIZE("long"  SIZEOF_LONG)
-CHECK_TYPE_SIZE("int"  SIZEOF_INT)
-CHECK_TYPE_SIZE("__int64"  SIZEOF___INT64)
-CHECK_TYPE_SIZE("long double"  SIZEOF_LONG_DOUBLE)
-CHECK_TYPE_SIZE("time_t"  SIZEOF_TIME_T)
-IF(NOT HAVE_SIZEOF_SSIZE_T)
-  IF(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
-    SET(ssize_t long)
-  ENDIF(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
-  IF(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
-    SET(ssize_t __int64)
-  ENDIF(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
-ENDIF(NOT HAVE_SIZEOF_SSIZE_T)
+if(NOT UNIX)
+  check_include_file_concat("ws2tcpip.h"     HAVE_WS2TCPIP_H)
+  check_include_file_concat("winsock2.h"     HAVE_WINSOCK2_H)
+endif(NOT UNIX)
+check_include_file_concat("stdio.h"          HAVE_STDIO_H)
+if(NOT UNIX)
+  check_include_file_concat("windows.h"      HAVE_WINDOWS_H)
+  check_include_file_concat("winsock.h"      HAVE_WINSOCK_H)
+endif(NOT UNIX)
+
+check_include_file_concat("inttypes.h"       HAVE_INTTYPES_H)
+check_include_file_concat("sys/filio.h"      HAVE_SYS_FILIO_H)
+check_include_file_concat("sys/ioctl.h"      HAVE_SYS_IOCTL_H)
+check_include_file_concat("sys/param.h"      HAVE_SYS_PARAM_H)
+check_include_file_concat("sys/poll.h"       HAVE_SYS_POLL_H)
+check_include_file_concat("sys/resource.h"   HAVE_SYS_RESOURCE_H)
+check_include_file_concat("sys/select.h"     HAVE_SYS_SELECT_H)
+check_include_file_concat("sys/socket.h"     HAVE_SYS_SOCKET_H)
+check_include_file_concat("sys/sockio.h"     HAVE_SYS_SOCKIO_H)
+check_include_file_concat("sys/stat.h"       HAVE_SYS_STAT_H)
+check_include_file_concat("sys/time.h"       HAVE_SYS_TIME_H)
+check_include_file_concat("sys/types.h"      HAVE_SYS_TYPES_H)
+check_include_file_concat("sys/uio.h"        HAVE_SYS_UIO_H)
+check_include_file_concat("sys/un.h"         HAVE_SYS_UN_H)
+check_include_file_concat("sys/utime.h"      HAVE_SYS_UTIME_H)
+check_include_file_concat("alloca.h"         HAVE_ALLOCA_H)
+check_include_file_concat("arpa/inet.h"      HAVE_ARPA_INET_H)
+check_include_file_concat("arpa/tftp.h"      HAVE_ARPA_TFTP_H)
+check_include_file_concat("assert.h"         HAVE_ASSERT_H)
+check_include_file_concat("crypto.h"         HAVE_CRYPTO_H)
+check_include_file_concat("des.h"            HAVE_DES_H)
+check_include_file_concat("err.h"            HAVE_ERR_H)
+check_include_file_concat("errno.h"          HAVE_ERRNO_H)
+check_include_file_concat("fcntl.h"          HAVE_FCNTL_H)
+check_include_file_concat("gssapi/gssapi.h"  HAVE_GSSAPI_GSSAPI_H)
+check_include_file_concat("gssapi/gssapi_generic.h" HAVE_GSSAPI_GSSAPI_GENERIC_H)
+check_include_file_concat("gssapi/gssapi_krb5.h" HAVE_GSSAPI_GSSAPI_KRB5_H)
+check_include_file_concat("idn-free.h"       HAVE_IDN_FREE_H)
+check_include_file_concat("ifaddrs.h"        HAVE_IFADDRS_H)
+check_include_file_concat("io.h"             HAVE_IO_H)
+check_include_file_concat("krb.h"            HAVE_KRB_H)
+check_include_file_concat("libgen.h"         HAVE_LIBGEN_H)
+check_include_file_concat("libssh2.h"        HAVE_LIBSSH2_H)
+check_include_file_concat("limits.h"         HAVE_LIMITS_H)
+check_include_file_concat("locale.h"         HAVE_LOCALE_H)
+check_include_file_concat("net/if.h"         HAVE_NET_IF_H)
+check_include_file_concat("netdb.h"          HAVE_NETDB_H)
+check_include_file_concat("netinet/in.h"     HAVE_NETINET_IN_H)
+check_include_file_concat("netinet/tcp.h"    HAVE_NETINET_TCP_H)
+check_include_file_concat("openssl/crypto.h" HAVE_OPENSSL_CRYPTO_H)
+check_include_file_concat("openssl/engine.h" HAVE_OPENSSL_ENGINE_H)
+check_include_file_concat("openssl/err.h"    HAVE_OPENSSL_ERR_H)
+check_include_file_concat("openssl/pem.h"    HAVE_OPENSSL_PEM_H)
+check_include_file_concat("openssl/pkcs12.h" HAVE_OPENSSL_PKCS12_H)
+check_include_file_concat("openssl/rsa.h"    HAVE_OPENSSL_RSA_H)
+check_include_file_concat("openssl/ssl.h"    HAVE_OPENSSL_SSL_H)
+check_include_file_concat("openssl/x509.h"   HAVE_OPENSSL_X509_H)
+check_include_file_concat("pem.h"            HAVE_PEM_H)
+check_include_file_concat("poll.h"           HAVE_POLL_H)
+check_include_file_concat("pwd.h"            HAVE_PWD_H)
+check_include_file_concat("rsa.h"            HAVE_RSA_H)
+check_include_file_concat("setjmp.h"         HAVE_SETJMP_H)
+check_include_file_concat("sgtty.h"          HAVE_SGTTY_H)
+check_include_file_concat("signal.h"         HAVE_SIGNAL_H)
+check_include_file_concat("ssl.h"            HAVE_SSL_H)
+check_include_file_concat("stdbool.h"        HAVE_STDBOOL_H)
+check_include_file_concat("stdint.h"         HAVE_STDINT_H)
+check_include_file_concat("stdio.h"          HAVE_STDIO_H)
+check_include_file_concat("stdlib.h"         HAVE_STDLIB_H)
+check_include_file_concat("string.h"         HAVE_STRING_H)
+check_include_file_concat("strings.h"        HAVE_STRINGS_H)
+check_include_file_concat("stropts.h"        HAVE_STROPTS_H)
+check_include_file_concat("termio.h"         HAVE_TERMIO_H)
+check_include_file_concat("termios.h"        HAVE_TERMIOS_H)
+check_include_file_concat("time.h"           HAVE_TIME_H)
+check_include_file_concat("tld.h"            HAVE_TLD_H)
+check_include_file_concat("unistd.h"         HAVE_UNISTD_H)
+check_include_file_concat("utime.h"          HAVE_UTIME_H)
+check_include_file_concat("x509.h"           HAVE_X509_H)
+
+check_include_file_concat("process.h"        HAVE_PROCESS_H)
+check_include_file_concat("stddef.h"         HAVE_STDDEF_H)
+check_include_file_concat("dlfcn.h"          HAVE_DLFCN_H)
+check_include_file_concat("malloc.h"         HAVE_MALLOC_H)
+check_include_file_concat("memory.h"         HAVE_MEMORY_H)
+check_include_file_concat("ldap.h"           HAVE_LDAP_H)
+check_include_file_concat("netinet/if_ether.h" HAVE_NETINET_IF_ETHER_H)
+check_include_file_concat("stdint.h"        HAVE_STDINT_H)
+check_include_file_concat("sockio.h"        HAVE_SOCKIO_H)
+check_include_file_concat("sys/utsname.h"   HAVE_SYS_UTSNAME_H)
+check_include_file_concat("idna.h"          HAVE_IDNA_H)
+
+if(CMAKE_USE_OPENSSL)
+  check_include_file_concat("openssl/rand.h"   HAVE_OPENSSL_RAND_H)
+endif(CMAKE_USE_OPENSSL)
+
+
+check_type_size(size_t  SIZEOF_SIZE_T)
+check_type_size(ssize_t  SIZEOF_SSIZE_T)
+check_type_size("long long"  SIZEOF_LONG_LONG)
+check_type_size("long"  SIZEOF_LONG)
+check_type_size("int"  SIZEOF_INT)
+check_type_size("__int64"  SIZEOF___INT64)
+check_type_size("long double"  SIZEOF_LONG_DOUBLE)
+check_type_size("time_t"  SIZEOF_TIME_T)
+if(NOT HAVE_SIZEOF_SSIZE_T)
+  if(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
+    set(ssize_t long)
+  endif(SIZEOF_LONG EQUAL SIZEOF_SIZE_T)
+  if(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
+    set(ssize_t __int64)
+  endif(NOT ssize_t AND SIZEOF___INT64 EQUAL SIZEOF_SIZE_T)
+endif(NOT HAVE_SIZEOF_SSIZE_T)
 
 # Different sizeofs, etc.
 
@@ -422,187 +422,187 @@ if(NOT CURL_TYPEOF_CURL_OFF_T)
   set(CURL_SUFFIX_CURL_OFF_TU LU)
 endif(NOT CURL_TYPEOF_CURL_OFF_T)
 
-IF(HAVE_SIZEOF_LONG_LONG)
-  SET(HAVE_LONGLONG 1)
-  SET(HAVE_LL 1)
-ENDIF(HAVE_SIZEOF_LONG_LONG)
+if(HAVE_SIZEOF_LONG_LONG)
+  set(HAVE_LONGLONG 1)
+  set(HAVE_LL 1)
+endif(HAVE_SIZEOF_LONG_LONG)
 
-FIND_FILE(RANDOM_FILE urandom /dev)
-MARK_AS_ADVANCED(RANDOM_FILE)
+find_file(RANDOM_FILE urandom /dev)
+mark_as_advanced(RANDOM_FILE)
 
 # Check for some functions that are used
-CHECK_SYMBOL_EXISTS(basename      "${CURL_INCLUDES}" HAVE_BASENAME)
-CHECK_SYMBOL_EXISTS(socket        "${CURL_INCLUDES}" HAVE_SOCKET)
-CHECK_SYMBOL_EXISTS(poll          "${CURL_INCLUDES}" HAVE_POLL)
-CHECK_SYMBOL_EXISTS(select        "${CURL_INCLUDES}" HAVE_SELECT)
-CHECK_SYMBOL_EXISTS(strdup        "${CURL_INCLUDES}" HAVE_STRDUP)
-CHECK_SYMBOL_EXISTS(strstr        "${CURL_INCLUDES}" HAVE_STRSTR)
-CHECK_SYMBOL_EXISTS(strtok_r      "${CURL_INCLUDES}" HAVE_STRTOK_R)
-CHECK_SYMBOL_EXISTS(strftime      "${CURL_INCLUDES}" HAVE_STRFTIME)
-CHECK_SYMBOL_EXISTS(uname         "${CURL_INCLUDES}" HAVE_UNAME)
-CHECK_SYMBOL_EXISTS(strcasecmp    "${CURL_INCLUDES}" HAVE_STRCASECMP)
-CHECK_SYMBOL_EXISTS(stricmp       "${CURL_INCLUDES}" HAVE_STRICMP)
-CHECK_SYMBOL_EXISTS(strcmpi       "${CURL_INCLUDES}" HAVE_STRCMPI)
-CHECK_SYMBOL_EXISTS(strncmpi      "${CURL_INCLUDES}" HAVE_STRNCMPI)
-CHECK_SYMBOL_EXISTS(alarm         "${CURL_INCLUDES}" HAVE_ALARM)
-IF(NOT HAVE_STRNCMPI)
-  SET(HAVE_STRCMPI)
-ENDIF(NOT HAVE_STRNCMPI)
-CHECK_SYMBOL_EXISTS(gethostbyaddr "${CURL_INCLUDES}" HAVE_GETHOSTBYADDR)
-CHECK_SYMBOL_EXISTS(gethostbyaddr_r "${CURL_INCLUDES}" HAVE_GETHOSTBYADDR_R)
-CHECK_SYMBOL_EXISTS(gettimeofday  "${CURL_INCLUDES}" HAVE_GETTIMEOFDAY)
-CHECK_SYMBOL_EXISTS(inet_addr     "${CURL_INCLUDES}" HAVE_INET_ADDR)
-CHECK_SYMBOL_EXISTS(inet_ntoa     "${CURL_INCLUDES}" HAVE_INET_NTOA)
-CHECK_SYMBOL_EXISTS(inet_ntoa_r   "${CURL_INCLUDES}" HAVE_INET_NTOA_R)
-CHECK_SYMBOL_EXISTS(tcsetattr     "${CURL_INCLUDES}" HAVE_TCSETATTR)
-CHECK_SYMBOL_EXISTS(tcgetattr     "${CURL_INCLUDES}" HAVE_TCGETATTR)
-CHECK_SYMBOL_EXISTS(perror        "${CURL_INCLUDES}" HAVE_PERROR)
-CHECK_SYMBOL_EXISTS(closesocket   "${CURL_INCLUDES}" HAVE_CLOSESOCKET)
-CHECK_SYMBOL_EXISTS(setvbuf       "${CURL_INCLUDES}" HAVE_SETVBUF)
-CHECK_SYMBOL_EXISTS(sigsetjmp     "${CURL_INCLUDES}" HAVE_SIGSETJMP)
-CHECK_SYMBOL_EXISTS(getpass_r     "${CURL_INCLUDES}" HAVE_GETPASS_R)
-CHECK_SYMBOL_EXISTS(strlcat       "${CURL_INCLUDES}" HAVE_STRLCAT)
-CHECK_SYMBOL_EXISTS(getpwuid      "${CURL_INCLUDES}" HAVE_GETPWUID)
-CHECK_SYMBOL_EXISTS(geteuid       "${CURL_INCLUDES}" HAVE_GETEUID)
-CHECK_SYMBOL_EXISTS(utime         "${CURL_INCLUDES}" HAVE_UTIME)
-IF(CMAKE_USE_OPENSSL)
-  CHECK_SYMBOL_EXISTS(RAND_status   "${CURL_INCLUDES}" HAVE_RAND_STATUS)
-  CHECK_SYMBOL_EXISTS(RAND_screen   "${CURL_INCLUDES}" HAVE_RAND_SCREEN)
-  CHECK_SYMBOL_EXISTS(RAND_egd      "${CURL_INCLUDES}" HAVE_RAND_EGD)
-  CHECK_SYMBOL_EXISTS(CRYPTO_cleanup_all_ex_data "${CURL_INCLUDES}" 
+check_symbol_exists(basename      "${CURL_INCLUDES}" HAVE_BASENAME)
+check_symbol_exists(socket        "${CURL_INCLUDES}" HAVE_SOCKET)
+check_symbol_exists(poll          "${CURL_INCLUDES}" HAVE_POLL)
+check_symbol_exists(select        "${CURL_INCLUDES}" HAVE_SELECT)
+check_symbol_exists(strdup        "${CURL_INCLUDES}" HAVE_STRDUP)
+check_symbol_exists(strstr        "${CURL_INCLUDES}" HAVE_STRSTR)
+check_symbol_exists(strtok_r      "${CURL_INCLUDES}" HAVE_STRTOK_R)
+check_symbol_exists(strftime      "${CURL_INCLUDES}" HAVE_STRFTIME)
+check_symbol_exists(uname         "${CURL_INCLUDES}" HAVE_UNAME)
+check_symbol_exists(strcasecmp    "${CURL_INCLUDES}" HAVE_STRCASECMP)
+check_symbol_exists(stricmp       "${CURL_INCLUDES}" HAVE_STRICMP)
+check_symbol_exists(strcmpi       "${CURL_INCLUDES}" HAVE_STRCMPI)
+check_symbol_exists(strncmpi      "${CURL_INCLUDES}" HAVE_STRNCMPI)
+check_symbol_exists(alarm         "${CURL_INCLUDES}" HAVE_ALARM)
+if(NOT HAVE_STRNCMPI)
+  set(HAVE_STRCMPI)
+endif(NOT HAVE_STRNCMPI)
+check_symbol_exists(gethostbyaddr "${CURL_INCLUDES}" HAVE_GETHOSTBYADDR)
+check_symbol_exists(gethostbyaddr_r "${CURL_INCLUDES}" HAVE_GETHOSTBYADDR_R)
+check_symbol_exists(gettimeofday  "${CURL_INCLUDES}" HAVE_GETTIMEOFDAY)
+check_symbol_exists(inet_addr     "${CURL_INCLUDES}" HAVE_INET_ADDR)
+check_symbol_exists(inet_ntoa     "${CURL_INCLUDES}" HAVE_INET_NTOA)
+check_symbol_exists(inet_ntoa_r   "${CURL_INCLUDES}" HAVE_INET_NTOA_R)
+check_symbol_exists(tcsetattr     "${CURL_INCLUDES}" HAVE_TCSETATTR)
+check_symbol_exists(tcgetattr     "${CURL_INCLUDES}" HAVE_TCGETATTR)
+check_symbol_exists(perror        "${CURL_INCLUDES}" HAVE_PERROR)
+check_symbol_exists(closesocket   "${CURL_INCLUDES}" HAVE_CLOSESOCKET)
+check_symbol_exists(setvbuf       "${CURL_INCLUDES}" HAVE_SETVBUF)
+check_symbol_exists(sigsetjmp     "${CURL_INCLUDES}" HAVE_SIGSETJMP)
+check_symbol_exists(getpass_r     "${CURL_INCLUDES}" HAVE_GETPASS_R)
+check_symbol_exists(strlcat       "${CURL_INCLUDES}" HAVE_STRLCAT)
+check_symbol_exists(getpwuid      "${CURL_INCLUDES}" HAVE_GETPWUID)
+check_symbol_exists(geteuid       "${CURL_INCLUDES}" HAVE_GETEUID)
+check_symbol_exists(utime         "${CURL_INCLUDES}" HAVE_UTIME)
+if(CMAKE_USE_OPENSSL)
+  check_symbol_exists(RAND_status   "${CURL_INCLUDES}" HAVE_RAND_STATUS)
+  check_symbol_exists(RAND_screen   "${CURL_INCLUDES}" HAVE_RAND_SCREEN)
+  check_symbol_exists(RAND_egd      "${CURL_INCLUDES}" HAVE_RAND_EGD)
+  check_symbol_exists(CRYPTO_cleanup_all_ex_data "${CURL_INCLUDES}" 
     HAVE_CRYPTO_CLEANUP_ALL_EX_DATA)
-  IF(HAVE_LIBCRYPTO AND HAVE_LIBSSL)
-  SET(USE_OPENSSL 1)
-  SET(USE_SSLEAY 1)
-  ENDIF(HAVE_LIBCRYPTO AND HAVE_LIBSSL)
-ENDIF(CMAKE_USE_OPENSSL)
-CHECK_SYMBOL_EXISTS(gmtime_r      "${CURL_INCLUDES}" HAVE_GMTIME_R)
-CHECK_SYMBOL_EXISTS(localtime_r   "${CURL_INCLUDES}" HAVE_LOCALTIME_R)
-
-CHECK_SYMBOL_EXISTS(gethostbyname   "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME)
-CHECK_SYMBOL_EXISTS(gethostbyname_r "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME_R)
-
-CHECK_SYMBOL_EXISTS(signal        "${CURL_INCLUDES}" HAVE_SIGNAL_FUNC)
-CHECK_SYMBOL_EXISTS(SIGALRM       "${CURL_INCLUDES}" HAVE_SIGNAL_MACRO)
-IF(HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO)
-  SET(HAVE_SIGNAL 1)
-ENDIF(HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO)
-CHECK_SYMBOL_EXISTS(uname          "${CURL_INCLUDES}" HAVE_UNAME)
-CHECK_SYMBOL_EXISTS(strtoll        "${CURL_INCLUDES}" HAVE_STRTOLL)
-CHECK_SYMBOL_EXISTS(_strtoi64      "${CURL_INCLUDES}" HAVE__STRTOI64)
-CHECK_SYMBOL_EXISTS(strerror_r     "${CURL_INCLUDES}" HAVE_STRERROR_R)
-CHECK_SYMBOL_EXISTS(siginterrupt   "${CURL_INCLUDES}" HAVE_SIGINTERRUPT)
-CHECK_SYMBOL_EXISTS(perror         "${CURL_INCLUDES}" HAVE_PERROR)
-CHECK_SYMBOL_EXISTS(fork           "${CURL_INCLUDES}" HAVE_FORK)
-CHECK_SYMBOL_EXISTS(freeaddrinfo   "${CURL_INCLUDES}" HAVE_FREEADDRINFO)
-CHECK_SYMBOL_EXISTS(freeifaddrs    "${CURL_INCLUDES}" HAVE_FREEIFADDRS)
-CHECK_SYMBOL_EXISTS(pipe           "${CURL_INCLUDES}" HAVE_PIPE)
-CHECK_SYMBOL_EXISTS(ftruncate      "${CURL_INCLUDES}" HAVE_FTRUNCATE)
-CHECK_SYMBOL_EXISTS(getprotobyname "${CURL_INCLUDES}" HAVE_GETPROTOBYNAME)
-CHECK_SYMBOL_EXISTS(getrlimit      "${CURL_INCLUDES}" HAVE_GETRLIMIT)
-CHECK_SYMBOL_EXISTS(idn_free       "${CURL_INCLUDES}" HAVE_IDN_FREE)
-CHECK_SYMBOL_EXISTS(idna_strerror  "${CURL_INCLUDES}" HAVE_IDNA_STRERROR)
-CHECK_SYMBOL_EXISTS(tld_strerror   "${CURL_INCLUDES}" HAVE_TLD_STRERROR)
-CHECK_SYMBOL_EXISTS(setlocale      "${CURL_INCLUDES}" HAVE_SETLOCALE)
-CHECK_SYMBOL_EXISTS(setrlimit      "${CURL_INCLUDES}" HAVE_SETRLIMIT)
-CHECK_SYMBOL_EXISTS(fcntl          "${CURL_INCLUDES}" HAVE_FCNTL)
-CHECK_SYMBOL_EXISTS(ioctl          "${CURL_INCLUDES}" HAVE_IOCTL)
-CHECK_SYMBOL_EXISTS(setsockopt     "${CURL_INCLUDES}" HAVE_SETSOCKOPT)
+  if(HAVE_LIBCRYPTO AND HAVE_LIBSSL)
+    set(USE_OPENSSL 1)
+    set(USE_SSLEAY 1)
+  endif(HAVE_LIBCRYPTO AND HAVE_LIBSSL)
+endif(CMAKE_USE_OPENSSL)
+check_symbol_exists(gmtime_r      "${CURL_INCLUDES}" HAVE_GMTIME_R)
+check_symbol_exists(localtime_r   "${CURL_INCLUDES}" HAVE_LOCALTIME_R)
+
+check_symbol_exists(gethostbyname   "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME)
+check_symbol_exists(gethostbyname_r "${CURL_INCLUDES}" HAVE_GETHOSTBYNAME_R)
+
+check_symbol_exists(signal        "${CURL_INCLUDES}" HAVE_SIGNAL_FUNC)
+check_symbol_exists(SIGALRM       "${CURL_INCLUDES}" HAVE_SIGNAL_MACRO)
+if(HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO)
+  set(HAVE_SIGNAL 1)
+endif(HAVE_SIGNAL_FUNC AND HAVE_SIGNAL_MACRO)
+check_symbol_exists(uname          "${CURL_INCLUDES}" HAVE_UNAME)
+check_symbol_exists(strtoll        "${CURL_INCLUDES}" HAVE_STRTOLL)
+check_symbol_exists(_strtoi64      "${CURL_INCLUDES}" HAVE__STRTOI64)
+check_symbol_exists(strerror_r     "${CURL_INCLUDES}" HAVE_STRERROR_R)
+check_symbol_exists(siginterrupt   "${CURL_INCLUDES}" HAVE_SIGINTERRUPT)
+check_symbol_exists(perror         "${CURL_INCLUDES}" HAVE_PERROR)
+check_symbol_exists(fork           "${CURL_INCLUDES}" HAVE_FORK)
+check_symbol_exists(freeaddrinfo   "${CURL_INCLUDES}" HAVE_FREEADDRINFO)
+check_symbol_exists(freeifaddrs    "${CURL_INCLUDES}" HAVE_FREEIFADDRS)
+check_symbol_exists(pipe           "${CURL_INCLUDES}" HAVE_PIPE)
+check_symbol_exists(ftruncate      "${CURL_INCLUDES}" HAVE_FTRUNCATE)
+check_symbol_exists(getprotobyname "${CURL_INCLUDES}" HAVE_GETPROTOBYNAME)
+check_symbol_exists(getrlimit      "${CURL_INCLUDES}" HAVE_GETRLIMIT)
+check_symbol_exists(idn_free       "${CURL_INCLUDES}" HAVE_IDN_FREE)
+check_symbol_exists(idna_strerror  "${CURL_INCLUDES}" HAVE_IDNA_STRERROR)
+check_symbol_exists(tld_strerror   "${CURL_INCLUDES}" HAVE_TLD_STRERROR)
+check_symbol_exists(setlocale      "${CURL_INCLUDES}" HAVE_SETLOCALE)
+check_symbol_exists(setrlimit      "${CURL_INCLUDES}" HAVE_SETRLIMIT)
+check_symbol_exists(fcntl          "${CURL_INCLUDES}" HAVE_FCNTL)
+check_symbol_exists(ioctl          "${CURL_INCLUDES}" HAVE_IOCTL)
+check_symbol_exists(setsockopt     "${CURL_INCLUDES}" HAVE_SETSOCKOPT)
 
 # symbol exists in win32, but function does not.
-CHECK_FUNCTION_EXISTS(inet_pton HAVE_INET_PTON)
+check_function_exists(inet_pton HAVE_INET_PTON)
 
 # sigaction and sigsetjmp are special. Use special mechanism for
 # detecting those, but only if previous attempt failed.
-IF(HAVE_SIGNAL_H)
-  CHECK_SYMBOL_EXISTS(sigaction "signal.h" HAVE_SIGACTION)
-ENDIF(HAVE_SIGNAL_H)
-
-IF(NOT HAVE_SIGSETJMP)
-  IF(HAVE_SETJMP_H)
-    CHECK_SYMBOL_EXISTS(sigsetjmp "setjmp.h" HAVE_MACRO_SIGSETJMP)
-    IF(HAVE_MACRO_SIGSETJMP)
-      SET(HAVE_SIGSETJMP 1)
-    ENDIF(HAVE_MACRO_SIGSETJMP)
-  ENDIF(HAVE_SETJMP_H)
-ENDIF(NOT HAVE_SIGSETJMP)
+if(HAVE_SIGNAL_H)
+  check_symbol_exists(sigaction "signal.h" HAVE_SIGACTION)
+endif(HAVE_SIGNAL_H)
+
+if(NOT HAVE_SIGSETJMP)
+  if(HAVE_SETJMP_H)
+    check_symbol_exists(sigsetjmp "setjmp.h" HAVE_MACRO_SIGSETJMP)
+    if(HAVE_MACRO_SIGSETJMP)
+      set(HAVE_SIGSETJMP 1)
+    endif(HAVE_MACRO_SIGSETJMP)
+  endif(HAVE_SETJMP_H)
+endif(NOT HAVE_SIGSETJMP)
 
 # If there is no stricmp(), do not allow LDAP to parse URLs
 if(NOT HAVE_STRICMP)
-    SET(HAVE_LDAP_URL_PARSE 1)
+  set(HAVE_LDAP_URL_PARSE 1)
 endif(NOT HAVE_STRICMP)
 
 # For other curl specific tests, use this macro.
-MACRO(CURL_INTERNAL_TEST CURL_TEST)
-  IF("${CURL_TEST}" MATCHES "^${CURL_TEST}$")
-    SET(MACRO_CHECK_FUNCTION_DEFINITIONS 
+macro(CURL_INTERNAL_TEST CURL_TEST)
+  if("${CURL_TEST}" MATCHES "^${CURL_TEST}$")
+    set(MACRO_CHECK_FUNCTION_DEFINITIONS 
       "-D${CURL_TEST} ${CURL_TEST_DEFINES} ${CMAKE_REQUIRED_FLAGS}")
-    IF(CMAKE_REQUIRED_LIBRARIES)
-      SET(CURL_TEST_ADD_LIBRARIES
+    if(CMAKE_REQUIRED_LIBRARIES)
+      set(CURL_TEST_ADD_LIBRARIES
         "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
-    ENDIF(CMAKE_REQUIRED_LIBRARIES)
+    endif(CMAKE_REQUIRED_LIBRARIES)
 
-    MESSAGE(STATUS "Performing Curl Test ${CURL_TEST}")
-    TRY_COMPILE(${CURL_TEST}
+    message(STATUS "Performing Curl Test ${CURL_TEST}")
+    try_compile(${CURL_TEST}
       ${CMAKE_BINARY_DIR}
       ${CMAKE_CURRENT_SOURCE_DIR}/CMake/CurlTests.c
       CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
       "${CURL_TEST_ADD_LIBRARIES}"
       OUTPUT_VARIABLE OUTPUT)
-    IF(${CURL_TEST})
-      SET(${CURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
-      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Success")
-      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
+    if(${CURL_TEST})
+      set(${CURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
+      message(STATUS "Performing Curl Test ${CURL_TEST} - Success")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 
         "Performing Curl Test ${CURL_TEST} passed with the following output:\n"
         "${OUTPUT}\n")
-    ELSE(${CURL_TEST})
-      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
-      SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
-      FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 
+    else(${CURL_TEST})
+      message(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
+      set(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 
         "Performing Curl Test ${CURL_TEST} failed with the following output:\n"
         "${OUTPUT}\n")
-    ENDIF(${CURL_TEST})
-  ENDIF("${CURL_TEST}" MATCHES "^${CURL_TEST}$")
-ENDMACRO(CURL_INTERNAL_TEST) 
+    endif(${CURL_TEST})
+  endif("${CURL_TEST}" MATCHES "^${CURL_TEST}$")
+endmacro(CURL_INTERNAL_TEST) 
 
-MACRO(CURL_INTERNAL_TEST_RUN CURL_TEST)
-  IF("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$")
-    SET(MACRO_CHECK_FUNCTION_DEFINITIONS 
+macro(CURL_INTERNAL_TEST_RUN CURL_TEST)
+  if("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$")
+    set(MACRO_CHECK_FUNCTION_DEFINITIONS 
       "-D${CURL_TEST} ${CMAKE_REQUIRED_FLAGS}")
-    IF(CMAKE_REQUIRED_LIBRARIES)
-      SET(CURL_TEST_ADD_LIBRARIES
+    if(CMAKE_REQUIRED_LIBRARIES)
+      set(CURL_TEST_ADD_LIBRARIES
         "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
-    ENDIF(CMAKE_REQUIRED_LIBRARIES)
+    endif(CMAKE_REQUIRED_LIBRARIES)
 
-    MESSAGE(STATUS "Performing Curl Test ${CURL_TEST}")
-    TRY_RUN(${CURL_TEST} ${CURL_TEST}_COMPILE
+    message(STATUS "Performing Curl Test ${CURL_TEST}")
+    try_run(${CURL_TEST} ${CURL_TEST}_COMPILE
       ${CMAKE_BINARY_DIR}
       ${CMAKE_CURRENT_SOURCE_DIR}/CMake/CurlTests.c
       CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
       "${CURL_TEST_ADD_LIBRARIES}"
       OUTPUT_VARIABLE OUTPUT)
-    IF(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
-      SET(${CURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
-      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Success")
-    ELSE(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
-      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
-      SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
-      FILE(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
+    if(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
+      set(${CURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
+      message(STATUS "Performing Curl Test ${CURL_TEST} - Success")
+    else(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
+      message(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
+      set(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
+      file(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
         "Performing Curl Test ${CURL_TEST} failed with the following output:\n"
         "${OUTPUT}")
-      IF(${CURL_TEST}_COMPILE)
-        FILE(APPEND 
+      if(${CURL_TEST}_COMPILE)
+        file(APPEND 
           "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log" 
           "There was a problem running this test\n")
-      ENDIF(${CURL_TEST}_COMPILE)
-      FILE(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log" 
+      endif(${CURL_TEST}_COMPILE)
+      file(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log" 
         "\n\n")
-    ENDIF(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
-  ENDIF("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$")
-ENDMACRO(CURL_INTERNAL_TEST_RUN) 
+    endif(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
+  endif("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$")
+endmacro(CURL_INTERNAL_TEST_RUN) 
 
 # Do curl specific tests
-FOREACH(CURL_TEST 
+foreach(CURL_TEST 
     HAVE_FCNTL_O_NONBLOCK
     HAVE_IOCTLSOCKET
     HAVE_IOCTLSOCKET_CAMEL
@@ -636,20 +636,20 @@ FOREACH(CURL_TEST
     HAVE_GETADDRINFO
     HAVE_FILE_OFFSET_BITS
     )
-  CURL_INTERNAL_TEST(${CURL_TEST})
-ENDFOREACH(CURL_TEST)
-IF(HAVE_FILE_OFFSET_BITS)
-  SET(_FILE_OFFSET_BITS 64)
-ENDIF(HAVE_FILE_OFFSET_BITS)
-FOREACH(CURL_TEST 
+  curl_internal_test(${CURL_TEST})
+endforeach(CURL_TEST)
+if(HAVE_FILE_OFFSET_BITS)
+  set(_FILE_OFFSET_BITS 64)
+endif(HAVE_FILE_OFFSET_BITS)
+foreach(CURL_TEST 
     HAVE_GLIBC_STRERROR_R
     HAVE_POSIX_STRERROR_R
     )
-  CURL_INTERNAL_TEST_RUN(${CURL_TEST})
-ENDFOREACH(CURL_TEST)
+  curl_internal_test_run(${CURL_TEST})
+endforeach(CURL_TEST)
 
 # Check for reentrant
-FOREACH(CURL_TEST
+foreach(CURL_TEST
     HAVE_GETHOSTBYADDR_R_5
     HAVE_GETHOSTBYADDR_R_7
     HAVE_GETHOSTBYADDR_R_8
@@ -657,149 +657,149 @@ FOREACH(CURL_TEST
     HAVE_GETHOSTBYNAME_R_5
     HAVE_GETHOSTBYNAME_R_6
     HAVE_INET_NTOA_R_DECL_REENTRANT)
-  IF(NOT ${CURL_TEST})
-    IF(${CURL_TEST}_REENTRANT)
-      SET(NEED_REENTRANT 1)
-    ENDIF(${CURL_TEST}_REENTRANT)
-  ENDIF(NOT ${CURL_TEST})
-ENDFOREACH(CURL_TEST)
-
-IF(NEED_REENTRANT)
-  FOREACH(CURL_TEST
+  if(NOT ${CURL_TEST})
+    if(${CURL_TEST}_REENTRANT)
+      set(NEED_REENTRANT 1)
+    endif(${CURL_TEST}_REENTRANT)
+  endif(NOT ${CURL_TEST})
+endforeach(CURL_TEST)
+
+if(NEED_REENTRANT)
+  foreach(CURL_TEST
       HAVE_GETHOSTBYADDR_R_5
       HAVE_GETHOSTBYADDR_R_7
       HAVE_GETHOSTBYADDR_R_8
       HAVE_GETHOSTBYNAME_R_3
       HAVE_GETHOSTBYNAME_R_5
       HAVE_GETHOSTBYNAME_R_6)
-    SET(${CURL_TEST} 0)
-    IF(${CURL_TEST}_REENTRANT)
-      SET(${CURL_TEST} 1)
-    ENDIF(${CURL_TEST}_REENTRANT)
-  ENDFOREACH(CURL_TEST)
-ENDIF(NEED_REENTRANT)
-
-IF(HAVE_INET_NTOA_R_DECL_REENTRANT)
-  SET(HAVE_INET_NTOA_R_DECL 1)
-  SET(NEED_REENTRANT 1)
-ENDIF(HAVE_INET_NTOA_R_DECL_REENTRANT)
+    set(${CURL_TEST} 0)
+    if(${CURL_TEST}_REENTRANT)
+      set(${CURL_TEST} 1)
+    endif(${CURL_TEST}_REENTRANT)
+  endforeach(CURL_TEST)
+endif(NEED_REENTRANT)
+
+if(HAVE_INET_NTOA_R_DECL_REENTRANT)
+  set(HAVE_INET_NTOA_R_DECL 1)
+  set(NEED_REENTRANT 1)
+endif(HAVE_INET_NTOA_R_DECL_REENTRANT)
 
 # Some other minor tests
 
-IF(NOT HAVE_IN_ADDR_T)
-  SET(in_addr_t "unsigned long")
-ENDIF(NOT HAVE_IN_ADDR_T)
+if(NOT HAVE_IN_ADDR_T)
+  set(in_addr_t "unsigned long")
+endif(NOT HAVE_IN_ADDR_T)
 
 # Fix libz / zlib.h
 
-IF(NOT CURL_SPECIAL_LIBZ)
-  IF(NOT HAVE_LIBZ)
-    SET(HAVE_ZLIB_H 0)
-  ENDIF(NOT HAVE_LIBZ)
+if(NOT CURL_SPECIAL_LIBZ)
+  if(NOT HAVE_LIBZ)
+    set(HAVE_ZLIB_H 0)
+  endif(NOT HAVE_LIBZ)
 
-  IF(NOT HAVE_ZLIB_H)
-    SET(HAVE_LIBZ 0)
-  ENDIF(NOT HAVE_ZLIB_H)
-ENDIF(NOT CURL_SPECIAL_LIBZ)
+  if(NOT HAVE_ZLIB_H)
+    set(HAVE_LIBZ 0)
+  endif(NOT HAVE_ZLIB_H)
+endif(NOT CURL_SPECIAL_LIBZ)
 
-IF(_FILE_OFFSET_BITS)
-  SET(_FILE_OFFSET_BITS 64)
-ENDIF(_FILE_OFFSET_BITS)
-SET(CMAKE_REQUIRED_FLAGS "-D_FILE_OFFSET_BITS=64")
-SET(CMAKE_EXTRA_INCLUDE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/curl/curl.h")
-CHECK_TYPE_SIZE("curl_off_t" SIZEOF_CURL_OFF_T)
-SET(CMAKE_EXTRA_INCLUDE_FILES)
-SET(CMAKE_REQUIRED_FLAGS)
+if(_FILE_OFFSET_BITS)
+  set(_FILE_OFFSET_BITS 64)
+endif(_FILE_OFFSET_BITS)
+set(CMAKE_REQUIRED_FLAGS "-D_FILE_OFFSET_BITS=64")
+set(CMAKE_EXTRA_INCLUDE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/curl/curl.h")
+check_type_size("curl_off_t" SIZEOF_CURL_OFF_T)
+set(CMAKE_EXTRA_INCLUDE_FILES)
+set(CMAKE_REQUIRED_FLAGS)
 
 
 # Check for nonblocking
-SET(HAVE_DISABLED_NONBLOCKING 1)
-IF(HAVE_FIONBIO OR 
+set(HAVE_DISABLED_NONBLOCKING 1)
+if(HAVE_FIONBIO OR 
     HAVE_IOCTLSOCKET OR
     HAVE_IOCTLSOCKET_CASE OR
     HAVE_O_NONBLOCK)
-  SET(HAVE_DISABLED_NONBLOCKING)
-ENDIF(HAVE_FIONBIO OR 
+  set(HAVE_DISABLED_NONBLOCKING)
+endif(HAVE_FIONBIO OR 
   HAVE_IOCTLSOCKET OR
   HAVE_IOCTLSOCKET_CASE OR
   HAVE_O_NONBLOCK)
 
-IF(RETSIGTYPE_TEST)
-  SET(RETSIGTYPE void)
-ELSE(RETSIGTYPE_TEST)
-  SET(RETSIGTYPE int)
-ENDIF(RETSIGTYPE_TEST)
+if(RETSIGTYPE_TEST)
+  set(RETSIGTYPE void)
+else(RETSIGTYPE_TEST)
+  set(RETSIGTYPE int)
+endif(RETSIGTYPE_TEST)
 
-IF(CMAKE_COMPILER_IS_GNUCC AND APPLE)
-  INCLUDE(CheckCCompilerFlag)
-  CHECK_C_COMPILER_FLAG(-Wno-long-double HAVE_C_FLAG_Wno_long_double)
-  IF(HAVE_C_FLAG_Wno_long_double)
+if(CMAKE_COMPILER_IS_GNUCC AND APPLE)
+  include(CheckCCompilerFlag)
+  check_c_compiler_flag(-Wno-long-double HAVE_C_FLAG_Wno_long_double)
+  if(HAVE_C_FLAG_Wno_long_double)
     # The Mac version of GCC warns about use of long double.  Disable it.
-    GET_SOURCE_FILE_PROPERTY(MPRINTF_COMPILE_FLAGS mprintf.c COMPILE_FLAGS)
-    IF(MPRINTF_COMPILE_FLAGS)
-      SET(MPRINTF_COMPILE_FLAGS "${MPRINTF_COMPILE_FLAGS} -Wno-long-double")
-    ELSE(MPRINTF_COMPILE_FLAGS)
-      SET(MPRINTF_COMPILE_FLAGS "-Wno-long-double")
-    ENDIF(MPRINTF_COMPILE_FLAGS)
-    SET_SOURCE_FILES_PROPERTIES(mprintf.c PROPERTIES
+    get_source_file_property(MPRINTF_COMPILE_FLAGS mprintf.c COMPILE_FLAGS)
+    if(MPRINTF_COMPILE_FLAGS)
+      set(MPRINTF_COMPILE_FLAGS "${MPRINTF_COMPILE_FLAGS} -Wno-long-double")
+    else(MPRINTF_COMPILE_FLAGS)
+      set(MPRINTF_COMPILE_FLAGS "-Wno-long-double")
+    endif(MPRINTF_COMPILE_FLAGS)
+    set_source_files_properties(mprintf.c PROPERTIES
       COMPILE_FLAGS ${MPRINTF_COMPILE_FLAGS})
-  ENDIF(HAVE_C_FLAG_Wno_long_double)
-ENDIF(CMAKE_COMPILER_IS_GNUCC AND APPLE)
+  endif(HAVE_C_FLAG_Wno_long_double)
+endif(CMAKE_COMPILER_IS_GNUCC AND APPLE)
 
-IF(HAVE_SOCKLEN_T)
-  SET(CURL_TYPEOF_CURL_SOCKLEN_T "socklen_t")
-  CHECK_TYPE_SIZE("socklen_t" CURL_SIZEOF_CURL_SOCKLEN_T)
-ELSE()
-  SET(CURL_TYPEOF_CURL_SOCKLEN_T int)
-  SET(CURL_SIZEOF_CURL_SOCKLEN_T ${SIZEOF_INT})
-ENDIF()
+if(HAVE_SOCKLEN_T)
+  set(CURL_TYPEOF_CURL_SOCKLEN_T "socklen_t")
+  check_type_size("socklen_t" CURL_SIZEOF_CURL_SOCKLEN_T)
+else()
+  set(CURL_TYPEOF_CURL_SOCKLEN_T int)
+  set(CURL_SIZEOF_CURL_SOCKLEN_T ${SIZEOF_INT})
+endif()
 
-INCLUDE(CMake/OtherTests.cmake)
+include(CMake/OtherTests.cmake)
 
-ADD_DEFINITIONS(-DHAVE_CONFIG_H)
+add_definitions(-DHAVE_CONFIG_H)
 
 # For windows, do not allow the compiler to use default target (Vista).
-IF(WIN32)
-  ADD_DEFINITIONS(-D_WIN32_WINNT=0x0501)
-ENDIF(WIN32)
+if(WIN32)
+  add_definitions(-D_WIN32_WINNT=0x0501)
+endif(WIN32)
 
-IF(MSVC)
-  ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
-ENDIF(MSVC)
+if(MSVC)
+  add_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
+endif(MSVC)
 
 # Sets up the dependencies (zlib, OpenSSL, etc.) of a cURL subproject according to options.
 # TODO This is far to be complete!
-FUNCTION(SETUP_CURL_DEPENDENCIES TARGET_NAME)
-  IF(CURL_ZLIB AND ZLIB_FOUND)
-    INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
-  ENDIF()
-  IF(CURL_ZLIB AND ZLIB_FOUND)
-    TARGET_LINK_LIBRARIES(${TARGET_NAME} ${ZLIB_LIBRARIES})
+function(SETUP_CURL_DEPENDENCIES TARGET_NAME)
+  if(CURL_ZLIB AND ZLIB_FOUND)
+    include_directories(${ZLIB_INCLUDE_DIR})
+  endif()
+  if(CURL_ZLIB AND ZLIB_FOUND)
+    target_link_libraries(${TARGET_NAME} ${ZLIB_LIBRARIES})
     #ADD_DEFINITIONS( -DHAVE_ZLIB_H -DHAVE_ZLIB -DHAVE_LIBZ )
-  ENDIF()
+  endif()
 
-  IF(CMAKE_USE_OPENSSL AND OPENSSL_FOUND)
-    INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
-  ENDIF()
-  IF(CURL_SSL AND CURL_CONFIG_HAS_BEEN_RUN_BEFORE)
-    TARGET_LINK_LIBRARIES(${TARGET_NAME} ${OPENSSL_LIBRARIES})
+  if(CMAKE_USE_OPENSSL AND OPENSSL_FOUND)
+    include_directories(${OPENSSL_INCLUDE_DIR})
+  endif()
+  if(CURL_SSL AND CURL_CONFIG_HAS_BEEN_RUN_BEFORE)
+    target_link_libraries(${TARGET_NAME} ${OPENSSL_LIBRARIES})
     #ADD_DEFINITIONS( -DUSE_SSLEAY )
-  ENDIF()
-ENDFUNCTION()
+  endif()
+endfunction()
 
 # Ugly (but functional) way to include "Makefile.inc" by transforming it (= regenerate it).
-FUNCTION(TRANSFORM_MAKEFILE_INC INPUT_FILE OUTPUT_FILE)
-  FILE(READ ${INPUT_FILE} MAKEFILE_INC_TEXT)
-  STRING(REPLACE "$(top_srcdir)"   "\${CURL_SOURCE_DIR}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
-  STRING(REPLACE "$(top_builddir)" "\${CURL_BINARY_DIR}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+function(TRANSFORM_MAKEFILE_INC INPUT_FILE OUTPUT_FILE)
+  file(READ ${INPUT_FILE} MAKEFILE_INC_TEXT)
+  string(REPLACE "$(top_srcdir)"   "\${CURL_SOURCE_DIR}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  string(REPLACE "$(top_builddir)" "\${CURL_BINARY_DIR}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
 
-  STRING(REGEX REPLACE "\\\\\n" "§!§" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
-  STRING(REGEX REPLACE "([a-zA-Z_][a-zA-Z0-9_]*)[\t ]*=[\t ]*([^\n]*\n)" "SET(\\1 \\2)\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
-  STRING(REPLACE "§!§" "\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  string(REGEX REPLACE "\\\\\n" "§!§" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  string(REGEX REPLACE "([a-zA-Z_][a-zA-Z0-9_]*)[\t ]*=[\t ]*([^\n]*\n)" "SET(\\1 \\2)\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
+  string(REPLACE "§!§" "\n" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
 
-  STRING(REGEX REPLACE "\\$\\(([a-zA-Z_][a-zA-Z0-9_]*)\\)" "\${\\1}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace $() with ${}
-  STRING(REGEX REPLACE "@([a-zA-Z_][a-zA-Z0-9_]*)@" "\${\\1}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace @@ with ${}, even if that may not be read by CMake scripts.
-  FILE(WRITE ${OUTPUT_FILE} ${MAKEFILE_INC_TEXT})
+  string(REGEX REPLACE "\\$\\(([a-zA-Z_][a-zA-Z0-9_]*)\\)" "\${\\1}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace $() with ${}
+  string(REGEX REPLACE "@([a-zA-Z_][a-zA-Z0-9_]*)@" "\${\\1}" MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})    # Replace @@ with ${}, even if that may not be read by CMake scripts.
+  file(WRITE ${OUTPUT_FILE} ${MAKEFILE_INC_TEXT})
 
   ### BUGGY METHOD 1
   # FILE(STRINGS Makefile.inc MAKEFILE_INC_TEXT)
@@ -833,17 +833,17 @@ FUNCTION(TRANSFORM_MAKEFILE_INC INPUT_FILE OUTPUT_FILE)
   # # STRING(REGEX REPLACE "CSOURCES *=" "SET(libCurl_SRCS " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
   # # STRING(REGEX REPLACE "HHEADERS *=" "SET(libCurl_HEADERS " MAKEFILE_INC_TEXT ${MAKEFILE_INC_TEXT})
   # FILE(WRITE Makefile.inc.cmake ${MAKEFILE_INC_TEXT})
-ENDFUNCTION()
+endfunction()
 
-ADD_SUBDIRECTORY(lib)
-IF(BUILD_CURL_EXE)
-  ADD_SUBDIRECTORY(src)
-ENDIF()
-IF(BUILD_CURL_TESTS)
-  ADD_SUBDIRECTORY(tests)
-ENDIF()
+add_subdirectory(lib)
+if(BUILD_CURL_EXE)
+  add_subdirectory(src)
+endif()
+if(BUILD_CURL_TESTS)
+  add_subdirectory(tests)
+endif()
 
 # This needs to be run very last so other parts of the scripts can take advantage of this.
-IF(NOT CURL_CONFIG_HAS_BEEN_RUN_BEFORE)
-    SET(CURL_CONFIG_HAS_BEEN_RUN_BEFORE 1 CACHE INTERNAL "Flag to track whether this is the first time running CMake or if CMake has been configured before")
-ENDIF()
+if(NOT CURL_CONFIG_HAS_BEEN_RUN_BEFORE)
+  set(CURL_CONFIG_HAS_BEEN_RUN_BEFORE 1 CACHE INTERNAL "Flag to track whether this is the first time running CMake or if CMake has been configured before")
+endif()
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index 12b422e5a..699b4f1c1 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -1,56 +1,56 @@
-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)
-CONFIGURE_FILE(config.h.cmake
+configure_file(config.h.cmake
   ${CMAKE_CURRENT_BINARY_DIR}/config.h)
 
 
-TRANSFORM_MAKEFILE_INC("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-INCLUDE(${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)
 
-LIST(APPEND HHEADERS
-	${CMAKE_CURRENT_BINARY_DIR}/config.h
-	${CURL_BINARY_DIR}/include/curl/curlbuild.h
-)
+list(APPEND HHEADERS
+  ${CMAKE_CURRENT_BINARY_DIR}/config.h
+  ${CURL_BINARY_DIR}/include/curl/curlbuild.h
+  )
 
-IF(MSVC)
-	LIST(APPEND CSOURCES libcurl.rc)
-ENDIF()
+if(MSVC)
+  list(APPEND CSOURCES libcurl.rc)
+endif()
 
 # SET(CSOURCES
-  # #  memdebug.c -not used
-  # # nwlib.c - Not used
-  # # strtok.c - specify later
-  # # strtoofft.c - specify later
+# #  memdebug.c -not used
+# # nwlib.c - Not used
+# # strtok.c - specify later
+# # strtoofft.c - specify later
 # )
 
 # # if we have Kerberos 4, right now this is never on
 # #OPTION(CURL_KRB4 "Use Kerberos 4" OFF)
 # IF(CURL_KRB4)
-  # SET(CSOURCES ${CSOURCES}
-    # krb4.c
-    # security.c
-    # )
+# SET(CSOURCES ${CSOURCES}
+# krb4.c
+# security.c
+# )
 # ENDIF(CURL_KRB4)
 
 # #OPTION(CURL_MALLOC_DEBUG "Debug mallocs in Curl" OFF)
 # MARK_AS_ADVANCED(CURL_MALLOC_DEBUG)
 # IF(CURL_MALLOC_DEBUG)
-  # SET(CSOURCES ${CSOURCES}
-    # memdebug.c
-    # )
+# SET(CSOURCES ${CSOURCES}
+# memdebug.c
+# )
 # ENDIF(CURL_MALLOC_DEBUG)
 
 # # only build compat strtoofft if we need to
 # IF(NOT HAVE_STRTOLL AND NOT HAVE__STRTOI64)
-  # SET(CSOURCES ${CSOURCES}
-    # strtoofft.c
-    # )
+# SET(CSOURCES ${CSOURCES}
+# strtoofft.c
+# )
 # ENDIF(NOT HAVE_STRTOLL AND NOT HAVE__STRTOI64)
 
-IF(HAVE_FEATURES_H)
-  SET_SOURCE_FILES_PROPERTIES(
+if(HAVE_FEATURES_H)
+  set_source_files_properties(
     cookie.c
     easy.c
     formdata.c
@@ -65,57 +65,57 @@ IF(HAVE_FEATURES_H)
     transfer.c
     url.c
     COMPILE_FLAGS -D_BSD_SOURCE)
-ENDIF(HAVE_FEATURES_H)
+endif(HAVE_FEATURES_H)
 
 
 # The rest of the build
 
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/../include)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/..)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/../include)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/..)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/../include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../include)
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/..)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
-IF(CURL_STATICLIB)
-	# Static lib
-	SET(CURL_USER_DEFINED_DYNAMIC_OR_STATIC STATIC)
-ELSE()
-	# DLL / so dynamic lib
-	SET(CURL_USER_DEFINED_DYNAMIC_OR_STATIC SHARED)
-ENDIF()
+if(CURL_STATICLIB)
+  # Static lib
+  set(CURL_USER_DEFINED_DYNAMIC_OR_STATIC STATIC)
+else()
+  # DLL / so dynamic lib
+  set(CURL_USER_DEFINED_DYNAMIC_OR_STATIC SHARED)
+endif()
 
-ADD_LIBRARY(
-	${LIB_NAME}
-	${CURL_USER_DEFINED_DYNAMIC_OR_STATIC}
-	${HHEADERS} ${CSOURCES}
-)
+add_library(
+  ${LIB_NAME}
+  ${CURL_USER_DEFINED_DYNAMIC_OR_STATIC}
+  ${HHEADERS} ${CSOURCES}
+  )
 
-TARGET_LINK_LIBRARIES(${LIB_NAME} ${CURL_LIBS})
+target_link_libraries(${LIB_NAME} ${CURL_LIBS})
 
-IF(WIN32)
-	ADD_DEFINITIONS( -D_USRDLL )
-ENDIF()
+if(WIN32)
+  add_definitions( -D_USRDLL )
+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".
-SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES PREFIX "")
-SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES IMPORT_PREFIX "")
-
-IF(MSVC)
-	IF(NOT BUILD_RELEASE_DEBUG_DIRS)
-		# Ugly workaround to remove the "/debug" or "/release" in each output
-		SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES PREFIX "../")
-		SET_TARGET_PROPERTIES(${LIB_NAME} PROPERTIES IMPORT_PREFIX "../")
-	ENDIF()
-ENDIF()
-
-IF(WIN32)
-	IF(NOT CURL_STATICLIB)
-		# 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")
-	ENDIF()
-ENDIF()
+set_target_properties(${LIB_NAME} PROPERTIES PREFIX "")
+set_target_properties(${LIB_NAME} PROPERTIES IMPORT_PREFIX "")
+
+if(MSVC)
+  if(NOT BUILD_RELEASE_DEBUG_DIRS)
+    # Ugly workaround to remove the "/debug" or "/release" in each output
+    set_target_properties(${LIB_NAME} PROPERTIES PREFIX "../")
+    set_target_properties(${LIB_NAME} PROPERTIES IMPORT_PREFIX "../")
+  endif()
+endif()
+
+if(WIN32)
+  if(NOT CURL_STATICLIB)
+    # 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")
+  endif()
+endif()
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e636eb1c3..c6871787c 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,39 +1,39 @@
-SET(EXE_NAME curl)
+set(EXE_NAME curl)
 
 # 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.
-FIND_FILE(HUGEHELP_C_FILE hugehelp.c PATHS . NO_DEFAULT_PATH)
-IF (NOT HUGEHELP_C_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")
-ENDIF()
+find_file(HUGEHELP_C_FILE hugehelp.c PATHS . NO_DEFAULT_PATH)
+if (NOT HUGEHELP_C_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")
+endif()
 
-TRANSFORM_MAKEFILE_INC("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-INCLUDE(${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)
 
-IF(MSVC)
-	LIST(APPEND CURL_SOURCE curl.rc)
-ENDIF()
+if(MSVC)
+  list(APPEND CURL_SOURCE curl.rc)
+endif()
 
-ADD_EXECUTABLE(
-	${EXE_NAME}
-    ${curl_SOURCES}
-)
+add_executable(
+  ${EXE_NAME}
+  ${curl_SOURCES}
+  )
 
-SOURCE_GROUP("cURLX source files" FILES ${CURLX_ONES})
-SOURCE_GROUP("cURL source files" FILES ${CURL_SOURCES})
-SOURCE_GROUP("cURL header files" FILES ${CURL_HFILES})
+source_group("cURLX source files" FILES ${CURLX_ONES})
+source_group("cURL source files" FILES ${CURL_SOURCES})
+source_group("cURL header files" FILES ${CURL_HFILES})
 
-INCLUDE_DIRECTORIES(
-    ${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}/include	# To be able to reach "curl/curlbuild.h"
-)
+include_directories(
+  ${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}/include    # To be able to reach "curl/curlbuild.h"
+  )
 
 
 # Setup dependencies
-SETUP_CURL_DEPENDENCIES(${EXE_NAME})
-TARGET_LINK_LIBRARIES( ${EXE_NAME} libcurl )
+setup_curl_dependencies(${EXE_NAME})
+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")
 
 # 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}")
-
-IF(MSVC)
-	IF(NOT BUILD_RELEASE_DEBUG_DIRS)
-		# Ugly workaround to remove the "/debug" or "/release" in each output
-		SET_TARGET_PROPERTIES(${EXE_NAME} PROPERTIES PREFIX "../")
-	ENDIF()
-ENDIF()
+set_target_properties(${EXE_NAME} PROPERTIES 
+  DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
+
+if(MSVC)
+  if(NOT BUILD_RELEASE_DEBUG_DIRS)
+    # Ugly workaround to remove the "/debug" or "/release" in each output
+    set_target_properties(${EXE_NAME} PROPERTIES PREFIX "../")
+  endif()
+endif()
 
 #INCLUDE(ModuleInstall OPTIONAL)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 147ef1fdd..04ab06ed6 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -1,2 +1,2 @@
-ADD_SUBDIRECTORY(libtest)
-ADD_SUBDIRECTORY(server)
+add_subdirectory(libtest)
+add_subdirectory(server)
diff --git a/tests/libtest/CMakeLists.txt b/tests/libtest/CMakeLists.txt
index 4d55cfe05..08edbd0c9 100644
--- a/tests/libtest/CMakeLists.txt
+++ b/tests/libtest/CMakeLists.txt
@@ -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
-	ADD_EXECUTABLE( ${TEST_NAME} ${ARGN} )
-	STRING(TOUPPER ${TEST_NAME} UPPER_TEST_NAME)
+function(SETUP_TEST TEST_NAME)          # ARGN are the files in the test
+  add_executable( ${TEST_NAME} ${ARGN} )
+  string(TOUPPER ${TEST_NAME} UPPER_TEST_NAME)
 
-	INCLUDE_DIRECTORIES(
-		${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}/include	# To be able to reach "curl/curlbuild.h"
-	)
+  include_directories(
+    ${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}/include      # To be able to reach "curl/curlbuild.h"
+    )
 
-	SETUP_CURL_DEPENDENCIES(${TEST_NAME})
-	TARGET_LINK_LIBRARIES( ${TEST_NAME} libcurl )
+  setup_curl_dependencies(${TEST_NAME})
+  target_link_libraries( ${TEST_NAME} libcurl )
 
-	SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES COMPILE_DEFINITIONS ${UPPER_TEST_NAME})
-	SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES PROJECT_LABEL "${TARGET_LABEL_PREFIX}${TEST_NAME}")
+  set_target_properties(${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
-	SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
+  # Add the postfix to the executable since it is 
+  # not added automatically as for modules and shared libraries
+  set_target_properties(${TEST_NAME} 
+    PROPERTIES DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
 
-	IF(MSVC)
-		IF(NOT BUILD_RELEASE_DEBUG_DIRS)
-			# Ugly workaround to remove the "/debug" or "/release" in each output
-			SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES PREFIX "../")
-			SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES IMPORT_PREFIX "../")
-		ENDIF()
-	ENDIF()
+  if(MSVC)
+    if(NOT BUILD_RELEASE_DEBUG_DIRS)
+      # Ugly workaround to remove the "/debug" or "/release" in each output
+      set_target_properties(${TEST_NAME} PROPERTIES PREFIX "../")
+      set_target_properties(${TEST_NAME} PROPERTIES IMPORT_PREFIX "../")
+    endif()
+  endif()
 
-ENDFUNCTION()
+endfunction()
 
 
-TRANSFORM_MAKEFILE_INC("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-INCLUDE(${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)
 
-FOREACH(TEST_NAME ${noinst_PROGRAMS})
-	SETUP_TEST(${TEST_NAME} ${${TEST_NAME}_SOURCES})
-ENDFOREACH()
+foreach(TEST_NAME ${noinst_PROGRAMS})
+  setup_test(${TEST_NAME} ${${TEST_NAME}_SOURCES})
+endforeach()
 
 
 # # files used only in some libcurl test programs
@@ -46,47 +50,47 @@ ENDFOREACH()
 
 # # These are all libcurl test programs
 # SET(noinst_PROGRAMS
-	# lib500 lib501 lib502 lib503 lib504 lib505 lib506
-	# lib507 lib508 lib510 lib511 lib512 lib513 lib514 lib515 lib516
-	# lib517 lib518 lib519 lib520 lib521 lib523 lib524 lib525 lib526
-	# #lib527
-	# #lib529
-	# lib530
-	# #lib532
-	# lib533 lib536 lib537 lib540 lib541 lib542 lib543
-	# lib544
-	# #lib545
-	# lib547
-	# #lib548
-	# lib549 lib552 lib553 lib554 lib555 lib556
-	# lib539 lib557 lib558
-	# #lib559
-	# lib560
+# lib500 lib501 lib502 lib503 lib504 lib505 lib506
+# lib507 lib508 lib510 lib511 lib512 lib513 lib514 lib515 lib516
+# lib517 lib518 lib519 lib520 lib521 lib523 lib524 lib525 lib526
+# #lib527
+# #lib529
+# lib530
+# #lib532
+# lib533 lib536 lib537 lib540 lib541 lib542 lib543
+# lib544
+# #lib545
+# lib547
+# #lib548
+# lib549 lib552 lib553 lib554 lib555 lib556
+# lib539 lib557 lib558
+# #lib559
+# lib560
 # )
 
 # SET(noinst_PROGRAMS_USE_TESTUTIL
-	# lib502 lib503 lib504
-	# lib507
-	# lib525 lib526 lib527
-	# lib529
-	# lib530
-	# lib532
-	# lib533 lib536
-	# lib555
+# lib502 lib503 lib504
+# lib507
+# lib525 lib526 lib527
+# lib529
+# lib530
+# lib532
+# lib533 lib536
+# lib555
 # )
 
 # MACRO(ADD_TESTUTIL_IF_NECESSARY TEST_NAME)
-	# LIST(FIND noinst_PROGRAMS_USE_TESTUTIL ${TEST_NAME} USES_TESTUTIL)
-	# IF(NOT ${USES_TESTUTIL} EQUAL -1)
-		# LIST(APPEND SOURCE ${TESTUTIL})		# Need TestUtil
-	# ENDIF()
+# LIST(FIND noinst_PROGRAMS_USE_TESTUTIL ${TEST_NAME} USES_TESTUTIL)
+# IF(NOT ${USES_TESTUTIL} EQUAL -1)
+# LIST(APPEND SOURCE ${TESTUTIL})               # Need TestUtil
+# ENDIF()
 # ENDMACRO()
 
 # # General case
 # FOREACH(TEST_NAME ${noinst_PROGRAMS})
-	# SET(SOURCE "${TEST_NAME}.c" ${SUPPORTFILES})
-	# ADD_TESTUTIL_IF_NECESSARY(${TEST_NAME})
-	# SETUP_TEST(${TEST_NAME} ${SOURCE})
+# SET(SOURCE "${TEST_NAME}.c" ${SUPPORTFILES})
+# ADD_TESTUTIL_IF_NECESSARY(${TEST_NAME})
+# SETUP_TEST(${TEST_NAME} ${SOURCE})
 # ENDFOREACH()
 
 # # Special cases
diff --git a/tests/server/CMakeLists.txt b/tests/server/CMakeLists.txt
index e094301fa..c9b32e16f 100644
--- a/tests/server/CMakeLists.txt
+++ b/tests/server/CMakeLists.txt
@@ -1,58 +1,63 @@
-SET(TARGET_LABEL_PREFIX "Test server ")
+set(TARGET_LABEL_PREFIX "Test server ")
 
-FUNCTION(SETUP_EXECUTABLE TEST_NAME)		# ARGN are the files in the test
-	ADD_EXECUTABLE( ${TEST_NAME} ${ARGN} )
-	STRING(TOUPPER ${TEST_NAME} UPPER_TEST_NAME)
+function(SETUP_EXECUTABLE TEST_NAME)    # ARGN are the files in the test
+  add_executable( ${TEST_NAME} ${ARGN} )
+  string(TOUPPER ${TEST_NAME} UPPER_TEST_NAME)
 
-	INCLUDE_DIRECTORIES(
-		${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}/include	# To be able to reach "curl/curlbuild.h"
-	)
+  include_directories(
+    ${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}/include  # To be able to reach "curl/curlbuild.h"
+    )
 
-	SETUP_CURL_DEPENDENCIES(${TEST_NAME})
-	#TARGET_LINK_LIBRARIES( ${TEST_NAME} libcurl )
+  setup_curl_dependencies(${TEST_NAME})
+  #TARGET_LINK_LIBRARIES( ${TEST_NAME} libcurl )
 
-	# Test servers simply are standalone programs that do not use libcurl
-	# library.  For convinience and to ease portability of these servers,
-	# some source code files from the libcurl subdirectory are also used
-	# to build the servers.  In order to achieve proper linkage of these
-	# files on Win32 targets it is necessary to build the test servers
-	# with CURL_STATICLIB defined, independently of how libcurl is built.
-	IF(NOT CURL_STATICLIB)
-		SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES COMPILE_DEFINITIONS CURL_STATICLIB)	# ${UPPER_TEST_NAME}
-	ENDIF()
-	SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES PROJECT_LABEL "${TARGET_LABEL_PREFIX}${TEST_NAME}")
+  # Test servers simply are standalone programs that do not use libcurl
+  # library.  For convinience and to ease portability of these servers,
+  # some source code files from the libcurl subdirectory are also used
+  # to build the servers.  In order to achieve proper linkage of these
+  # files on Win32 targets it is necessary to build the test servers
+  # with CURL_STATICLIB defined, independently of how libcurl is built.
+  if(NOT CURL_STATICLIB)
+    set_target_properties(${TEST_NAME} PROPERTIES 
+      COMPILE_DEFINITIONS CURL_STATICLIB)       # ${UPPER_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
-	SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
+  # Add the postfix to the executable since it is not added 
+  # automatically as for modules and shared libraries
+  set_target_properties(${TEST_NAME} PROPERTIES
+    DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
 
-	IF(MSVC)
-		IF(NOT BUILD_RELEASE_DEBUG_DIRS)
-			# Ugly workaround to remove the "/debug" or "/release" in each output
-			SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES PREFIX "../")
-			SET_TARGET_PROPERTIES(${TEST_NAME} PROPERTIES IMPORT_PREFIX "../")
-		ENDIF()
-	ENDIF()
+  if(MSVC)
+    if(NOT BUILD_RELEASE_DEBUG_DIRS)
+      # Ugly workaround to remove the "/debug" or "/release" in each output
+      set_target_properties(${TEST_NAME} PROPERTIES PREFIX "../")
+      set_target_properties(${TEST_NAME} PROPERTIES IMPORT_PREFIX "../")
+    endif()
+  endif()
 
-ENDFUNCTION()
+endfunction()
 
 
-TRANSFORM_MAKEFILE_INC("Makefile.inc" "${CMAKE_CURRENT_BINARY_DIR}/Makefile.inc.cmake")
-INCLUDE(${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)
 
-FOREACH(EXECUTABLE_NAME ${noinst_PROGRAMS})
-	SETUP_EXECUTABLE(${EXECUTABLE_NAME} ${${EXECUTABLE_NAME}_SOURCES})
-ENDFOREACH()
+foreach(EXECUTABLE_NAME ${noinst_PROGRAMS})
+  setup_executable(${EXECUTABLE_NAME} ${${EXECUTABLE_NAME}_SOURCES})
+endforeach()
 
 
 # SET(useful
-	# getpart.c getpart.h
-	# ${CURL_SOURCE_DIR}/lib/strequal.c
-	# ${CURL_SOURCE_DIR}/lib/base64.c
-	# ${CURL_SOURCE_DIR}/lib/mprintf.c
-	# ${CURL_SOURCE_DIR}/lib/memdebug.c
-	# ${CURL_SOURCE_DIR}/lib/timeval.c
+# getpart.c getpart.h
+# ${CURL_SOURCE_DIR}/lib/strequal.c
+# ${CURL_SOURCE_DIR}/lib/base64.c
+# ${CURL_SOURCE_DIR}/lib/mprintf.c
+# ${CURL_SOURCE_DIR}/lib/memdebug.c
+# ${CURL_SOURCE_DIR}/lib/timeval.c
 # )
 
 # SETUP_EXECUTABLE(sws sws.c util.c util.h ${useful})