diff --git a/cmake-d/CMakeDCompiler.cmake.in b/cmake-d/CMakeDCompiler.cmake.in
index 87d905a..68398af 100644
--- a/cmake-d/CMakeDCompiler.cmake.in
+++ b/cmake-d/CMakeDCompiler.cmake.in
@@ -1,7 +1,7 @@
 # < 2.8.10 backward compatibility
 if(NOT CMAKE_PLATFORM_INFO_DIR)
   set(CMAKE_PLATFORM_INFO_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY})
-endif(NOT CMAKE_PLATFORM_INFO_DIR)
+endif()
 
 set(CMAKE_D_COMPILER "@CMAKE_D_COMPILER@")
 set(CMAKE_D_COMPILER_ARG1 "@CMAKE_D_COMPILER_ARG1@")
@@ -19,13 +19,13 @@ set(CMAKE_COMPILER_IS_CYGWIN @CMAKE_COMPILER_IS_CYGWIN@)
 if(CMAKE_COMPILER_IS_CYGWIN)
   set(CYGWIN 1)
   set(UNIX 1)
-endif(CMAKE_COMPILER_IS_CYGWIN)
+endif()
 
 set(CMAKE_D_COMPILER_ENV_VAR "DC")
 
 if(CMAKE_COMPILER_IS_MINGW)
   set(MINGW 1)
-endif(CMAKE_COMPILER_IS_MINGW)
+endif()
 set(CMAKE_D_SOURCE_FILE_EXTENSIONS d;di)
 set(CMAKE_D_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
 # Prefer to use D's linker.
@@ -38,11 +38,11 @@ set(CMAKE_D_COMPILER_ABI "@CMAKE_D_COMPILER_ABI@")
 
 if(CMAKE_D_SIZEOF_DATA_PTR)
   set(CMAKE_SIZEOF_VOID_P "${CMAKE_D_SIZEOF_DATA_PTR}")
-endif(CMAKE_D_SIZEOF_DATA_PTR)
+endif()
 
 if(CMAKE_D_COMPILER_ABI)
   set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_D_COMPILER_ABI}")
-endif(CMAKE_D_COMPILER_ABI)
+endif()
 
 set(CMAKE_D_HAS_ISYSROOT "@CMAKE_D_HAS_ISYSROOT@")
 @CMAKE_D_OSX_DEPLOYMENT_TARGET_FLAG_CODE@
diff --git a/cmake-d/CMakeDInformation.cmake b/cmake-d/CMakeDInformation.cmake
index b5a51e7..7609f59 100644
--- a/cmake-d/CMakeDInformation.cmake
+++ b/cmake-d/CMakeDInformation.cmake
@@ -27,7 +27,7 @@ set(_INCLUDED_FILE 0)  # reset the indicator if an include occurred.
 
 if(CMAKE_D_COMPILER_ID)
   include(Compiler/${CMAKE_D_COMPILER_ID}-D OPTIONAL)
-endif(CMAKE_D_COMPILER_ID)
+endif()
 
 # set(CMAKE_D_OUTPUT_EXTENSION .o)
 set(CMAKE_C_OUTPUT_EXTENSION_REPLACE TRUE )
@@ -42,11 +42,11 @@ set(_INCLUDED_FILE 0)  # reset the indicator if an include occurred.
 if(CMAKE_SYSTEM_PROCESSOR)
   if(CMAKE_D_COMPILER_ID)
     include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_D_COMPILER_ID}-D-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
-  endif(CMAKE_D_COMPILER_ID)
+  endif()
   if(NOT _INCLUDED_FILE)
     include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
-  endif(NOT _INCLUDED_FILE)
-endif(CMAKE_SYSTEM_PROCESSOR)
+  endif()
+endif()
 
 set(_INCLUDED_FILE 0)  # reset the indicator if an include occurred.
 
@@ -54,13 +54,13 @@ set(_INCLUDED_FILE 0)  # reset the indicator if an include occurred.
 if(CMAKE_D_COMPILER_ID)
   include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_D_COMPILER_ID}-D
     OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
-endif(CMAKE_D_COMPILER_ID)
+endif()
 
 # if no high specificity file was included, then try a more general one
 if(NOT _INCLUDED_FILE)
   include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}
     OPTIONAL RESULT_VARIABLE _INCLUDED_FILE)
-endif(NOT _INCLUDED_FILE)
+endif()
 
 # We specify the compiler information in the system file for some
 # platforms, but this language may not have been enabled when the file
@@ -68,7 +68,7 @@ endif(NOT _INCLUDED_FILE)
 # Remove this when all compiler info is removed from system files.
 if(NOT _INCLUDED_FILE)
   include(Platform/${CMAKE_SYSTEM_NAME} OPTIONAL)
-endif(NOT _INCLUDED_FILE)
+endif()
 
 
 # This should be included before the _INIT variables are
@@ -79,11 +79,11 @@ endif(NOT _INCLUDED_FILE)
 
 if(CMAKE_USER_MAKE_RULES_OVERRIDE)
    include(${CMAKE_USER_MAKE_RULES_OVERRIDE})
-endif(CMAKE_USER_MAKE_RULES_OVERRIDE)
+endif()
 
 if(CMAKE_USER_MAKE_RULES_OVERRIDE_D)
    include(${CMAKE_USER_MAKE_RULES_OVERRIDE_D})
-endif(CMAKE_USER_MAKE_RULES_OVERRIDE_D)
+endif()
 
 # Lines below was taken from CMakeCXXInformation.cmake
 # Not all of this flags are available on D compilers for now, but some as OPTIONS_PIC are.
@@ -162,7 +162,7 @@ endif()
 if(NOT CMAKE_MODULE_EXISTS)
   set(CMAKE_SHARED_MODULE_D_FLAGS ${CMAKE_SHARED_LIBRARY_D_FLAGS})
   set(CMAKE_SHARED_MODULE_CREATE_D_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_D_FLAGS})
-endif(NOT CMAKE_MODULE_EXISTS)
+endif()
 
 # repeat for modules
 if(NOT CMAKE_SHARED_MODULE_CREATE_D_FLAGS)
@@ -177,7 +177,7 @@ set(CMAKE_D_FLAGS_INIT "$ENV{DFLAGS} ${CMAKE_D_FLAGS_INIT}")
 # avoid just having a space as the initial value for the cache
 if(CMAKE_D_FLAGS_INIT STREQUAL " ")
   set(CMAKE_D_FLAGS_INIT)
-endif(CMAKE_D_FLAGS_INIT STREQUAL " ")
+endif()
 set(CMAKE_D_FLAGS "${CMAKE_D_FLAGS_INIT}" CACHE STRING
      "Flags used by the D compiler during all build types.")
 
@@ -186,7 +186,7 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
   if(NOT CMAKE_NO_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE_INIT} CACHE STRING
       "Choose the type of build, options are: None(CMAKE_D_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
-  endif(NOT CMAKE_NO_BUILD_TYPE)
+  endif()
   set(CMAKE_D_FLAGS_DEBUG "${CMAKE_D_FLAGS_DEBUG_INIT}" CACHE STRING
     "Flags used by the compiler during debug builds.")
   set(CMAKE_D_FLAGS_MINSIZEREL "${CMAKE_D_FLAGS_MINSIZEREL_INIT}" CACHE STRING
@@ -195,13 +195,13 @@ if(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
     "Flags used by the compiler during release builds (/MD /Ob1 /Oi /Ot /Oy /Gs will produce slightly less optimized but smaller files).")
   set(CMAKE_D_FLAGS_RELWITHDEBINFO "${CMAKE_D_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
     "Flags used by the compiler during Release with Debug Info builds.")
-endif(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+endif()
 
 if(CMAKE_D_STANDARD_LIBRARIES_INIT)
   set(CMAKE_D_STANDARD_LIBRARIES "${CMAKE_D_STANDARD_LIBRARIES_INIT}"
     CACHE STRING "Libraries linked by default with all D applications.")
   mark_as_advanced(CMAKE_D_STANDARD_LIBRARIES)
-endif(CMAKE_D_STANDARD_LIBRARIES_INIT)
+endif()
 
 include(CMakeCommonLanguageInclude)
 
@@ -235,23 +235,23 @@ include(CMakeCommonLanguageInclude)
 # < 2.8.10 backward compatibility
 if(NOT CMAKE_PLATFORM_INFO_DIR)
   set(CMAKE_PLATFORM_INFO_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY})
-endif(NOT CMAKE_PLATFORM_INFO_DIR)
+endif()
 
 # create a D shared library
 if(NOT CMAKE_D_CREATE_SHARED_LIBRARY)
 	set(CMAKE_D_CREATE_SHARED_LIBRARY
 		"<CMAKE_D_COMPILER> <CMAKE_SHARED_LIBRARY_D_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_D_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_D_FLAG><TARGET_SONAME> ${CMAKE_D_DASH_O}<TARGET> <OBJECTS> <LINK_LIBRARIES> ${DSTDLIB_FLAGS} ${CMAKE_D_STDLIBS}")
-endif(NOT CMAKE_D_CREATE_SHARED_LIBRARY)
+endif()
 
 # create a D shared module just copy the shared library rule
 if(NOT CMAKE_D_CREATE_SHARED_MODULE)
   set(CMAKE_D_CREATE_SHARED_MODULE "${CMAKE_D_CREATE_SHARED_LIBRARY}")
-endif(NOT CMAKE_D_CREATE_SHARED_MODULE)
+endif()
 
 if(NOT CMAKE_D_CREATE_STATIC_LIBRARY AND CMAKE_STATIC_LIBRARY_CREATE_D_FLAGS)
 	set(CMAKE_D_CREATE_STATIC_LIBRARY
 		"<CMAKE_D_COMPILER> ${CMAKE_STATIC_LIBRARY_CREATE_D_FLAGS} <OBJECTS> ${CMAKE_D_DASH_O}<TARGET>")
-endif(NOT CMAKE_D_CREATE_STATIC_LIBRARY AND CMAKE_STATIC_LIBRARY_CREATE_D_FLAGS)
+endif()
 
 # Create a static archive incrementally for large object file counts.
 # If CMAKE_D_CREATE_STATIC_LIBRARY is set it will override these.
@@ -261,20 +261,20 @@ set(CMAKE_D_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
 
 # compile a D file into an object file
 if(NOT CMAKE_D_COMPILE_OBJECT)
-    set(CMAKE_D_COMPILE_OBJECT
-     "<CMAKE_D_COMPILER> <FLAGS> ${CMAKE_D_DASH_O}<OBJECT> -c <SOURCE>")
-endif(NOT CMAKE_D_COMPILE_OBJECT)
+  set(CMAKE_D_COMPILE_OBJECT
+   "<CMAKE_D_COMPILER> <FLAGS> ${CMAKE_D_DASH_O}<OBJECT> -c <SOURCE>")
+endif()
 
 if(NOT CMAKE_D_LINK_EXECUTABLE)
   set(CMAKE_D_LINK_EXECUTABLE
     "<CMAKE_D_COMPILER> <FLAGS> <CMAKE_D_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> ${CMAKE_D_DASH_O}<TARGET> <LINK_LIBRARIES> ${CMAKE_D_STDLIBS}")
-endif(NOT CMAKE_D_LINK_EXECUTABLE)
+endif()
 
 mark_as_advanced(
-CMAKE_D_FLAGS
-CMAKE_D_FLAGS_DEBUG
-CMAKE_D_FLAGS_MINSIZEREL
-CMAKE_D_FLAGS_RELEASE
-CMAKE_D_FLAGS_RELWITHDEBINFO
-)
+  CMAKE_D_FLAGS
+  CMAKE_D_FLAGS_DEBUG
+  CMAKE_D_FLAGS_MINSIZEREL
+  CMAKE_D_FLAGS_RELEASE
+  CMAKE_D_FLAGS_RELWITHDEBINFO)
+
 set(CMAKE_D_INFORMATION_LOADED 1)
diff --git a/cmake-d/CMakeDetermineDCompiler.cmake b/cmake-d/CMakeDetermineDCompiler.cmake
index eafc595..19f9957 100644
--- a/cmake-d/CMakeDetermineDCompiler.cmake
+++ b/cmake-d/CMakeDetermineDCompiler.cmake
@@ -27,36 +27,36 @@ if(NOT CMAKE_D_COMPILER)
     get_filename_component(CMAKE_D_COMPILER_INIT $ENV{DC} PROGRAM PROGRAM_ARGS CMAKE_D_FLAGS_ENV_INIT)
     if(CMAKE_D_FLAGS_ENV_INIT)
       set(CMAKE_D_COMPILER_ARG1 "${CMAKE_D_FLAGS_ENV_INIT}" CACHE STRING "First argument to D compiler")
-    endif(CMAKE_D_FLAGS_ENV_INIT)
+    endif()
     if(NOT EXISTS ${CMAKE_D_COMPILER_INIT})
       MESSAGE(FATAL_ERROR "Could not find compiler set in environment variable C:\n$ENV{DC}.")
-    endif(NOT EXISTS ${CMAKE_D_COMPILER_INIT})
-  endif($ENV{DC} MATCHES ".+")
+    endif()
+  endif()
 
   # next try prefer the compiler specified by the generator
   if(CMAKE_GENERATOR_D)
     if(NOT CMAKE_D_COMPILER_INIT)
       set(CMAKE_D_COMPILER_INIT ${CMAKE_GENERATOR_D})
-    endif(NOT CMAKE_D_COMPILER_INIT)
-  endif(CMAKE_GENERATOR_D)
+    endif()
+  endif()
 
   # finally list compilers to try
   if(CMAKE_D_COMPILER_INIT)
     set(CMAKE_D_COMPILER_LIST ${CMAKE_D_COMPILER_INIT})
-  else(CMAKE_D_COMPILER_INIT)
+  else()
     set(CMAKE_D_COMPILER_LIST ${_CMAKE_TOOLCHAIN_PREFIX}gdc ${_CMAKE_TOOLCHAIN_PREFIX}dmd)
-  endif(CMAKE_D_COMPILER_INIT)
+  endif()
 
   # Find the compiler.
   if(_CMAKE_USER_D_COMPILER_PATH)
   	find_program(CMAKE_D_COMPILER NAMES ${CMAKE_D_COMPILER_LIST} PATHS ${_CMAKE_USER_D_COMPILER_PATH} DOC "D compiler" NO_DEFAULT_PATH)
-  endif(_CMAKE_USER_D_COMPILER_PATH)
+  endif()
   find_program(CMAKE_D_COMPILER NAMES ${CMAKE_D_COMPILER_LIST} DOC "D compiler")
 
   if(CMAKE_D_COMPILER_INIT AND NOT CMAKE_D_COMPILER)
     set(CMAKE_D_COMPILER "${CMAKE_D_COMPILER_INIT}" CACHE FILEPATH "D compiler" FORCE)
-  endif(CMAKE_D_COMPILER_INIT AND NOT CMAKE_D_COMPILER)
-else(NOT CMAKE_D_COMPILER)
+  endif()
+else()
 
   # we only get here if CMAKE_D_COMPILER was specified using -D or a pre-made CMakeCache.txt
   # (e.g. via ctest) or set in CMAKE_TOOLCHAIN_FILE
@@ -67,7 +67,7 @@ else(NOT CMAKE_D_COMPILER)
   if("${_CMAKE_D_COMPILER_LIST_LENGTH}" EQUAL 2)
     list(GET CMAKE_D_COMPILER 1 CMAKE_D_COMPILER_ARG1)
     list(GET CMAKE_D_COMPILER 0 CMAKE_D_COMPILER)
-  endif("${_CMAKE_D_COMPILER_LIST_LENGTH}" EQUAL 2)
+  endif()
 
   # if a compiler was specified by the user but without path,
   # now try to find it with the full path
@@ -80,14 +80,14 @@ else(NOT CMAKE_D_COMPILER)
     mark_as_advanced(CMAKE_D_COMPILER_WITH_PATH)
     if(CMAKE_D_COMPILER_WITH_PATH)
       set(CMAKE_D_COMPILER ${CMAKE_D_COMPILER_WITH_PATH} CACHE STRING "D compiler" FORCE)
-    endif(CMAKE_D_COMPILER_WITH_PATH)
-  endif(NOT _CMAKE_USER_D_COMPILER_PATH)
-endif(NOT CMAKE_D_COMPILER)
+    endif()
+  endif()
+endif()
 mark_as_advanced(CMAKE_D_COMPILER)
 
 if(NOT _CMAKE_TOOLCHAIN_LOCATION)
   get_filename_component(_CMAKE_TOOLCHAIN_LOCATION "${CMAKE_D_COMPILER}" PATH)
-endif(NOT _CMAKE_TOOLCHAIN_LOCATION)
+endif()
 
 # Build a small source file to identify the compiler.
 if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
@@ -97,7 +97,7 @@ if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
   # TODO: Set the compiler id.  It is probably MSVC but
   # the user may be using an integrated Intel compiler.
   # set(CMAKE_D_COMPILER_ID "MSVC")
-endif(${CMAKE_GENERATOR} MATCHES "Visual Studio")
+endif()
 
 if(NOT CMAKE_D_COMPILER_ID_RUN)
   set(CMAKE_D_COMPILER_ID_RUN 1)
@@ -122,7 +122,7 @@ if(NOT CMAKE_D_COMPILER_ID_RUN)
   get_filename_component(CMAKE_D_COMPILER_ID_FILE_IN_PATH ${CMAKE_D_COMPILER_ID_FILE_IN} PATH)
   if(CMAKE_MAJOR_VERSION GREATER 2 OR CMAKE_D_COMPILER_ID_FILE_IN_PATH STREQUAL ${CMAKE_ROOT}/Modules)
     include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake)
-  else(CMAKE_D_COMPILER_ID_FILE_IN_PATH STREQUAL ${CMAKE_ROOT}/Modules)
+  else()
     file(READ ${CMAKE_ROOT}/Modules/CMakeDetermineCompilerId.cmake CMAKE_DETERMINE_COMPILER_ID_CMAKE_CONTENT)
     STRING(REPLACE "file(READ \${CMAKE_ROOT}/Modules/\${src}.in ID_CONTENT_IN)" 
       "find_file(src_in \${src}.in PATHS \${CMAKE_ROOT}/Modules \${CMAKE_MODULE_PATH} NO_DEFAULT_PATH)
@@ -132,7 +132,7 @@ if(NOT CMAKE_D_COMPILER_ID_RUN)
     file(WRITE ${CMAKE_PLATFORM_INFO_DIR}/CMakeDetermineCompilerId.cmake
       ${CMAKE_DETERMINE_COMPILER_ID_CMAKE_CONTENT_PATCHED})
     include(${CMAKE_PLATFORM_INFO_DIR}/CMakeDetermineCompilerId.cmake)
-  endif(CMAKE_MAJOR_VERSION GREATER 2 OR CMAKE_D_COMPILER_ID_FILE_IN_PATH STREQUAL ${CMAKE_ROOT}/Modules)
+  endif()
   CMAKE_DETERMINE_COMPILER_ID(D DFLAGS CMakeDCompilerId.d)
   unset(CMAKE_D_COMPILER_ID_FILE_IN CACHE)
   unset(CMAKE_PLATFORM_ID_CONTENT_FILE CACHE)
@@ -140,19 +140,19 @@ if(NOT CMAKE_D_COMPILER_ID_RUN)
   # Set old compiler and platform id variables.
   if("${CMAKE_D_COMPILER_ID}" MATCHES "GNU")
     set(CMAKE_COMPILER_IS_GDC 1)
-  endif("${CMAKE_D_COMPILER_ID}" MATCHES "GNU")
+  endif()
   if("${CMAKE_D_PLATFORM_ID}" MATCHES "MinGW")
     set(CMAKE_COMPILER_IS_MINGW 1)
   elseif("${CMAKE_D_PLATFORM_ID}" MATCHES "Cygwin")
     set(CMAKE_COMPILER_IS_CYGWIN 1)
-  endif("${CMAKE_D_PLATFORM_ID}" MATCHES "MinGW")
-endif(NOT CMAKE_D_COMPILER_ID_RUN)
+  endif()
+endif()
 
 include(CMakeFindBinUtils)
 if(MSVC_D_ARCHITECTURE_ID)
   set(SET_MSVC_D_ARCHITECTURE_ID
     "set(MSVC_D_ARCHITECTURE_ID ${MSVC_D_ARCHITECTURE_ID})")
-endif(MSVC_D_ARCHITECTURE_ID)
+endif()
 # configure variables set in this file for fast reload later on
 find_file(CMAKE_D_COMPILER_CMAKE_IN CMakeDCompiler.cmake.in PATHS ${CMAKE_ROOT}/Modules
   ${CMAKE_MODULE_PATH} NO_DEFAULT_PATH)
diff --git a/cmake-d/CMakeLists.txt b/cmake-d/CMakeLists.txt
index 7a43b78..6ccc255 100644
--- a/cmake-d/CMakeLists.txt
+++ b/cmake-d/CMakeLists.txt
@@ -9,10 +9,10 @@
 #
 # See LICENSE for details.
 #
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8.1)
-PROJECT (cmake-d NONE)
+cmake_minimum_required(VERSION 2.8.1)
+project(cmake-d NONE)
 
-SET (MOD_SRCS
+set(MOD_SRCS
 	CMakeDCompiler.cmake.in        
 	CMakeDCompilerId.d.in        
 	CMakeDInformation.cmake        
@@ -29,7 +29,7 @@ SET (MOD_SRCS
 	CMakePlatformId.di.in
 )
 
-SET (PLAT_SRCS
+set(PLAT_SRCS
 	Platform/Linux-dmd.cmake
 	Platform/Linux-gdc.cmake 
 	Platform/Linux-ldc2.cmake 
@@ -37,5 +37,5 @@ SET (PLAT_SRCS
 	Platform/Windows-gdc.cmake
 )
 
-INSTALL (FILES ${MOD_SRCS} DESTINATION ${CMAKE_ROOT}/Modules)
-INSTALL (FILES ${PLAT_SRCS} DESTINATION ${CMAKE_ROOT}/Modules/Platform)
+install(FILES ${MOD_SRCS} DESTINATION ${CMAKE_ROOT}/Modules)
+install(FILES ${PLAT_SRCS} DESTINATION ${CMAKE_ROOT}/Modules/Platform)
diff --git a/cmake-d/CMakeTestDCompiler.cmake b/cmake-d/CMakeTestDCompiler.cmake
index 2c39431..14c78c8 100644
--- a/cmake-d/CMakeTestDCompiler.cmake
+++ b/cmake-d/CMakeTestDCompiler.cmake
@@ -29,7 +29,7 @@ if(NOT CMAKE_D_COMPILER_WORKS)
     ${CMAKE_PLATFORM_INFO_DIR}/CMakeTmp/testDCompiler.d
     OUTPUT_VARIABLE OUTPUT)
   set(D_TEST_WAS_RUN 1)
-endif(NOT CMAKE_D_COMPILER_WORKS)
+endif()
 
 if(NOT CMAKE_D_COMPILER_WORKS)
   PrintTestCompilerStatus("D" " -- broken")
@@ -46,19 +46,19 @@ if(NOT CMAKE_D_COMPILER_WORKS)
     "is not able to compile a simple test program.\nIt fails "
     "with the following output:\n ${OUTPUT}\n\n"
     "CMake will not be able to correctly generate this project.")
-else(NOT CMAKE_D_COMPILER_WORKS)
+else()
   if(D_TEST_WAS_RUN)
     message(STATUS "Check for working D compiler: ${CMAKE_D_COMPILER} -- works")
     file(APPEND ${CMAKE_PLATFORM_INFO_DIR}/CMakeOutput.log
       "Determining if the D compiler works passed with "
       "the following output:\n${OUTPUT}\n\n")
-  endif(D_TEST_WAS_RUN)
+  endif()
   set(CMAKE_D_COMPILER_WORKS 1 CACHE INTERNAL "")
 
   if(CMAKE_D_COMPILER_FORCED)
     # The compiler configuration was forced by the user.
     # Assume the user has configured all compiler information.
-  else(CMAKE_D_COMPILER_FORCED)
+  else()
     # Try to identify the ABI and configure it into CMakeDCompiler.cmake
     include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerABI.cmake)
     find_file(CMAKE_D_COMPILER_ABI_SRC CMakeDCompilerABI.d PATHS ${CMAKE_ROOT}/Modules
@@ -74,5 +74,5 @@ else(NOT CMAKE_D_COMPILER_WORKS)
     include(${CMAKE_PLATFORM_INFO_DIR}/CMakeDCompiler.cmake)
     unset(CMAKE_D_COMPILER_ABI_SRC CACHE)
     unset(CMAKE_D_COMPILER_CMAKE_IN CACHE)
-  endif(CMAKE_D_COMPILER_FORCED)
-endif(NOT CMAKE_D_COMPILER_WORKS)
+  endif()
+endif()
diff --git a/cmake-d/FindGDCPath.cmake b/cmake-d/FindGDCPath.cmake
index 97918cf..e9f42aa 100644
--- a/cmake-d/FindGDCPath.cmake
+++ b/cmake-d/FindGDCPath.cmake
@@ -38,12 +38,9 @@ set(GDC_POSSIBLE_INCLUDE_PATHS
   /usr/include/d/3.4.3
   /usr/include/d/3.4.2
   /usr/include/d/3.4.1
-  /usr/include/d/3.4.0
-  )
+  /usr/include/d/3.4.0)
 
 find_path(GDC_INCLUDE_PATH object.d
   ${GDC_POSSIBLE_INCLUDE_PATHS})
 
-mark_as_advanced(
-  GDC_INCLUDE_PATH
-  )
+mark_as_advanced(GDC_INCLUDE_PATH)
diff --git a/cmake-d/Platform/Linux-dmd.cmake b/cmake-d/Platform/Linux-dmd.cmake
index d531da7..2832b19 100644
--- a/cmake-d/Platform/Linux-dmd.cmake
+++ b/cmake-d/Platform/Linux-dmd.cmake
@@ -12,56 +12,56 @@
 # See http://www.cmake.org/HTML/Copyright.html for details
 #
 
-#SET(DSTDLIB_FLAGS "-version=Phobos")
-IF(CMAKE_D_BUILD_DOCS)
-	SET(DDOC_FLAGS "-D -Dddocumentation")
-	#FOREACH(item ${CMAKE_D_DDOC_FILES})
-	#	SET(DDOC_FLAGS "${DDOC_FLAGS} ${item}")
-	#ENDFOREACH(item)
-ENDIF(CMAKE_D_BUILD_DOCS)
+#set(DSTDLIB_FLAGS "-version=Phobos")
+if(CMAKE_D_BUILD_DOCS)
+  set(DDOC_FLAGS "-D -Dddocumentation")
+  # foreach(item ${CMAKE_D_DDOC_FILES})
+  #  set(DDOC_FLAGS "${DDOC_FLAGS} ${item}")
+  # endforeach()
+endif()
 
-SET(CMAKE_D_OUTPUT_EXTENSION .o)
-SET(CMAKE_D_DASH_O "-of")
-SET(CMAKE_BASE_NAME dmd)
+set(CMAKE_D_OUTPUT_EXTENSION .o)
+set(CMAKE_D_DASH_O "-of")
+set(CMAKE_BASE_NAME dmd)
 
-SET(CMAKE_STATIC_LIBRARY_CREATE_D_FLAGS "-lib")
+set(CMAKE_STATIC_LIBRARY_CREATE_D_FLAGS "-lib")
 
-SET(CMAKE_SHARED_LIBRARY_D_FLAGS "")            # -pic
-SET(CMAKE_SHARED_LIBRARY_CREATE_D_FLAGS "-shared -defaultlib=libphobos2.so")       # -shared
-SET(CMAKE_SHARED_LIBRARY_LINK_D_FLAGS "")         # +s, flag for exe link to use shared lib
-SET(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG "")       # -rpath
-SET(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG_SEP "")   # : or empty
-SET(CMAKE_SHARED_LIBRARY_SONAME_D_FLAG "-L-soname=")
-SET(CMAKE_SHARED_LIBRARY_RPATH_LINK_D_FLAG "-L-rpath=")
-SET(CMAKE_INCLUDE_FLAG_D "-I")       # -I
-SET(CMAKE_INCLUDE_FLAG_D_SEP "")     # , or empty
-SET(CMAKE_LIBRARY_PATH_FLAG "-L-L")
-SET(CMAKE_LIBRARY_PATH_TERMINATOR "")  # for the Digital Mars D compiler the link paths have to be terminated with a "/"
-SET(CMAKE_LINK_LIBRARY_FLAG "-L-l")
+set(CMAKE_SHARED_LIBRARY_D_FLAGS "")            # -pic
+set(CMAKE_SHARED_LIBRARY_CREATE_D_FLAGS "-shared -defaultlib=libphobos2.so")       # -shared
+set(CMAKE_SHARED_LIBRARY_LINK_D_FLAGS "")         # +s, flag for exe link to use shared lib
+set(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG "")       # -rpath
+set(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG_SEP "")   # : or empty
+set(CMAKE_SHARED_LIBRARY_SONAME_D_FLAG "-L-soname=")
+set(CMAKE_SHARED_LIBRARY_RPATH_LINK_D_FLAG "-L-rpath=")
+set(CMAKE_INCLUDE_FLAG_D "-I")       # -I
+set(CMAKE_INCLUDE_FLAG_D_SEP "")     # , or empty
+set(CMAKE_LIBRARY_PATH_FLAG "-L-L")
+set(CMAKE_LIBRARY_PATH_TERMINATOR "")  # for the Digital Mars D compiler the link paths have to be terminated with a "/"
+set(CMAKE_LINK_LIBRARY_FLAG "-L-l")
 
-SET(CMAKE_D_COMPILE_OPTIONS_PIC "-fPIC")
+set(CMAKE_D_COMPILE_OPTIONS_PIC "-fPIC")
 
-SET(CMAKE_LINK_LIBRARY_SUFFIX "")
-SET(CMAKE_STATIC_LIBRARY_PREFIX "lib")
-SET(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
-SET(CMAKE_SHARED_LIBRARY_PREFIX "lib")          # lib
-SET(CMAKE_SHARED_LIBRARY_SUFFIX ".so")          # .so
-SET(CMAKE_EXECUTABLE_SUFFIX "")          # .exe
-SET(CMAKE_DL_LIBS "dl")
+set(CMAKE_LINK_LIBRARY_SUFFIX "")
+set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
+set(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
+set(CMAKE_SHARED_LIBRARY_PREFIX "lib")          # lib
+set(CMAKE_SHARED_LIBRARY_SUFFIX ".so")          # .so
+set(CMAKE_EXECUTABLE_SUFFIX "")          # .exe
+set(CMAKE_DL_LIBS "dl")
 
-SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-SET(CMAKE_FIND_LIBRARY_SUFFIXES ".so" ".a")
+set(CMAKE_FIND_LIBRARY_PREFIXES "lib")
+set(CMAKE_FIND_LIBRARY_SUFFIXES ".so" ".a")
 
-#SET(CMAKE_D_STDLIBS "-L-lphobos2 -L-lpthread -L-lm -defaultlib=libphobos2.so")
+# set(CMAKE_D_STDLIBS "-L-lphobos2 -L-lpthread -L-lm -defaultlib=libphobos2.so")
 
-#SET (CMAKE_D_FLAGS_INIT "-version=${CMAKE_BUILD_TYPE}Build ${DSTDLIB_FLAGS} ${DSTDLIB_TYPE} -I$ENV{D_PATH}/include -I$ENV{D_PATH}/import -I${CMAKE_PROJECT_SOURCE_DIR}")
-SET (CMAKE_D_FLAGS_INIT "")
+# set(CMAKE_D_FLAGS_INIT "-version=${CMAKE_BUILD_TYPE}Build ${DSTDLIB_FLAGS} ${DSTDLIB_TYPE} -I$ENV{D_PATH}/include -I$ENV{D_PATH}/import -I${CMAKE_PROJECT_SOURCE_DIR}")
+set(CMAKE_D_FLAGS_INIT "")
 
-SET (CMAKE_D_LINK_FLAGS "")
-SET (CMAKE_D_FLAGS_DEBUG_INIT "-g -debug -L--export-dynamic ${DDOC_FLAGS}")
-#  SET (CMAKE_D_FLAGS_MINSIZEREL_INIT "-Os ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELEASE_INIT "-O ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O -g -L--export-dynamic ${DDOC_FLAGS}")
-#  SET (CMAKE_D_CREATE_PREPROCESSED_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
-SET (CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -of<ASSEMBLY_SOURCE>")
-#  SET (CMAKE_INCLUDE_SYSTEM_FLAG_D "-isystem ")
+set(CMAKE_D_LINK_FLAGS "")
+set(CMAKE_D_FLAGS_DEBUG_INIT "-g -debug -L--export-dynamic ${DDOC_FLAGS}")
+# set(CMAKE_D_FLAGS_MINSIZEREL_INIT "-Os ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELEASE_INIT "-O ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O -g -L--export-dynamic ${DDOC_FLAGS}")
+# set(CMAKE_D_CREATE_PREPROCESSED_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+set(CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -of<ASSEMBLY_SOURCE>")
+# set(CMAKE_INCLUDE_SYSTEM_FLAG_D "-isystem ")
diff --git a/cmake-d/Platform/Linux-gdc.cmake b/cmake-d/Platform/Linux-gdc.cmake
index 0d363aa..0f31c26 100644
--- a/cmake-d/Platform/Linux-gdc.cmake
+++ b/cmake-d/Platform/Linux-gdc.cmake
@@ -12,30 +12,30 @@
 # See http://www.cmake.org/HTML/Copyright.html for details
 #
 
-SET(CMAKE_D_DASH_O "-o")
-SET(CMAKE_BASE_NAME gdc)
+set(CMAKE_D_DASH_O "-o")
+set(CMAKE_BASE_NAME gdc)
 
-IF(CMAKE_D_USE_TANGO)
-	SET(DSTDLIB_FLAGS "-fversion=Tango")
-ENDIF(CMAKE_D_USE_TANGO)
-IF(CMAKE_D_USE_PHOBOS)
-	SET(DSTDLIB_FLAGS "-fversion=Phobos")
-ENDIF(CMAKE_D_USE_PHOBOS)
-IF(CMAKE_D_BUILD_DOCS)
-	SET(DDOC_FLAGS "-fdoc -fdoc-dir=documentation")
-	FOREACH(item ${CMAKE_D_DDOC_FILES})
-		SET(DDOC_FLAGS "${DDOC_FLAGS} -fdoc-inc=${item}")
-	ENDFOREACH(item)
-ENDIF(CMAKE_D_BUILD_DOCS)
+if(CMAKE_D_USE_TANGO)
+  set(DSTDLIB_FLAGS "-fversion=Tango")
+endif()
+if(CMAKE_D_USE_PHOBOS)
+  set(DSTDLIB_FLAGS "-fversion=Phobos")
+endif()
+if(CMAKE_D_BUILD_DOCS)
+  set(DDOC_FLAGS "-fdoc -fdoc-dir=documentation")
+  foreach(item ${CMAKE_D_DDOC_FILES})
+    set(DDOC_FLAGS "${DDOC_FLAGS} -fdoc-inc=${item}")
+  endforeach()
+endif()
 
-#SET (CMAKE_D_FLAGS_INIT "-fversion=Posix -fversion=${CMAKE_BUILD_TYPE}Build ${DSTDLIB_FLAGS}")
-SET (CMAKE_D_FLAGS_INIT "")
-SET (CMAKE_D_FLAGS_DEBUG_INIT "-g ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_MINSIZEREL_INIT "-Os ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELEASE_INIT "-O3 -fomit-frame-pointer -fweb -frelease -finline-functions ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O2 -g ${DDOC_FLAGS}")
-#  SET (CMAKE_D_CREATE_PREPROCESSED_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
-SET (CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
-#SET (CMAKE_INCLUDE_SYSTEM_FLAG_D "-isystem ")
+# SET(CMAKE_D_FLAGS_INIT "-fversion=Posix -fversion=${CMAKE_BUILD_TYPE}Build ${DSTDLIB_FLAGS}")
+set(CMAKE_D_FLAGS_INIT "")
+set(CMAKE_D_FLAGS_DEBUG_INIT "-g ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_MINSIZEREL_INIT "-Os ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELEASE_INIT "-O3 -fomit-frame-pointer -fweb -frelease -finline-functions ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O2 -g ${DDOC_FLAGS}")
+# set(CMAKE_D_CREATE_PREPROCESSED_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+set(CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+# set(CMAKE_INCLUDE_SYSTEM_FLAG_D "-isystem ")
 
-SET(CMAKE_INCLUDE_FLAG_D "-I")       # -I
+set(CMAKE_INCLUDE_FLAG_D "-I")       # -I
diff --git a/cmake-d/Platform/Linux-ldc2.cmake b/cmake-d/Platform/Linux-ldc2.cmake
index 872670f..e0244e4 100644
--- a/cmake-d/Platform/Linux-ldc2.cmake
+++ b/cmake-d/Platform/Linux-ldc2.cmake
@@ -12,52 +12,52 @@
 # See http://www.cmake.org/HTML/Copyright.html for details
 #
 
-#SET(DSTDLIB_FLAGS "-version=Phobos")
-IF(CMAKE_D_BUILD_DOCS)
-	SET(DDOC_FLAGS "-D -Dddocumentation")
-	#FOREACH(item ${CMAKE_D_DDOC_FILES})
-	#	SET(DDOC_FLAGS "${DDOC_FLAGS} ${item}")
-	#ENDFOREACH(item)
-ENDIF(CMAKE_D_BUILD_DOCS)
+# set(DSTDLIB_FLAGS "-version=Phobos")
+if(CMAKE_D_BUILD_DOCS)
+  set(DDOC_FLAGS "-D -Dddocumentation")
+  # foreach(item ${CMAKE_D_DDOC_FILES})
+  #  set(DDOC_FLAGS "${DDOC_FLAGS} ${item}")
+  # endforeach()
+endif()
 
-SET(CMAKE_D_OUTPUT_EXTENSION .o)
-SET(CMAKE_D_DASH_O "-of")
-SET(CMAKE_BASE_NAME ldc2)
+set(CMAKE_D_OUTPUT_EXTENSION .o)
+set(CMAKE_D_DASH_O "-of")
+set(CMAKE_BASE_NAME ldc2)
 
-SET(CMAKE_STATIC_LIBRARY_CREATE_D_FLAGS "-lib")
+set(CMAKE_STATIC_LIBRARY_CREATE_D_FLAGS "-lib")
 
-SET(CMAKE_SHARED_LIBRARY_D_FLAGS "")            # -pic
-SET(CMAKE_SHARED_LIBRARY_CREATE_D_FLAGS "-shared")       # -shared
-SET(CMAKE_SHARED_LIBRARY_LINK_D_FLAGS "")         # +s, flag for exe link to use shared lib
-SET(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG "")       # -rpath
-SET(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG_SEP "")   # : or empty
-SET(CMAKE_INCLUDE_FLAG_D "-I")       # -I
-SET(CMAKE_INCLUDE_FLAG_D_SEP "")     # , or empty
-SET(CMAKE_LIBRARY_PATH_FLAG "-L-L")
-SET(CMAKE_LIBRARY_PATH_TERMINATOR "")  # for the Digital Mars D compiler the link paths have to be terminated with a "/"
-SET(CMAKE_LINK_LIBRARY_FLAG "-L-l")
+set(CMAKE_SHARED_LIBRARY_D_FLAGS "")            # -pic
+set(CMAKE_SHARED_LIBRARY_CREATE_D_FLAGS "-shared")       # -shared
+set(CMAKE_SHARED_LIBRARY_LINK_D_FLAGS "")         # +s, flag for exe link to use shared lib
+set(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG "")       # -rpath
+set(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG_SEP "")   # : or empty
+set(CMAKE_INCLUDE_FLAG_D "-I")       # -I
+set(CMAKE_INCLUDE_FLAG_D_SEP "")     # , or empty
+set(CMAKE_LIBRARY_PATH_FLAG "-L-L")
+set(CMAKE_LIBRARY_PATH_TERMINATOR "")  # for the Digital Mars D compiler the link paths have to be terminated with a "/"
+set(CMAKE_LINK_LIBRARY_FLAG "-L-l")
 
-SET(CMAKE_LINK_LIBRARY_SUFFIX "")
-SET(CMAKE_STATIC_LIBRARY_PREFIX "lib")
-SET(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
-SET(CMAKE_SHARED_LIBRARY_PREFIX "lib")          # lib
-SET(CMAKE_SHARED_LIBRARY_SUFFIX ".so")          # .so
-SET(CMAKE_EXECUTABLE_SUFFIX "")          # .exe
-SET(CMAKE_DL_LIBS "dl")
+set(CMAKE_LINK_LIBRARY_SUFFIX "")
+set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
+set(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
+set(CMAKE_SHARED_LIBRARY_PREFIX "lib")          # lib
+set(CMAKE_SHARED_LIBRARY_SUFFIX ".so")          # .so
+set(CMAKE_EXECUTABLE_SUFFIX "")          # .exe
+set(CMAKE_DL_LIBS "dl")
 
-SET(CMAKE_FIND_LIBRARY_PREFIXES "lib")
-SET(CMAKE_FIND_LIBRARY_SUFFIXES ".so" ".a")
+set(CMAKE_FIND_LIBRARY_PREFIXES "lib")
+set(CMAKE_FIND_LIBRARY_SUFFIXES ".so" ".a")
 
-#SET(CMAKE_D_STDLIBS "-L-lphobos2 -L-lpthread -L-lm" )
+# set(CMAKE_D_STDLIBS "-L-lphobos2 -L-lpthread -L-lm" )
 
-#SET (CMAKE_D_FLAGS_INIT "-version=${CMAKE_BUILD_TYPE}Build ${DSTDLIB_FLAGS} ${DSTDLIB_TYPE} -I$ENV{D_PATH}/include -I$ENV{D_PATH}/import -I${CMAKE_PROJECT_SOURCE_DIR}")
-SET (CMAKE_D_FLAGS_INIT "")
+# set(CMAKE_D_FLAGS_INIT "-version=${CMAKE_BUILD_TYPE}Build ${DSTDLIB_FLAGS} ${DSTDLIB_TYPE} -I$ENV{D_PATH}/include -I$ENV{D_PATH}/import -I${CMAKE_PROJECT_SOURCE_DIR}")
+set(CMAKE_D_FLAGS_INIT "")
 # DMD can only produce 32-bit binaries for now
-SET (CMAKE_D_LINK_FLAGS "")
-SET (CMAKE_D_FLAGS_DEBUG_INIT "-g -d-debug -L--export-dynamic ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_MINSIZEREL_INIT "-Os ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELEASE_INIT "-O -release -inline ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O -g -L--export-dynamic ${DDOC_FLAGS}")
-#  SET (CMAKE_D_CREATE_PREPROCESSED_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
-SET (CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -of<ASSEMBLY_SOURCE>")
-#  SET (CMAKE_INCLUDE_SYSTEM_FLAG_D "-isystem ")
+set(CMAKE_D_LINK_FLAGS "")
+set(CMAKE_D_FLAGS_DEBUG_INIT "-g -d-debug -L--export-dynamic ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_MINSIZEREL_INIT "-Os ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELEASE_INIT "-O -release -inline ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O -g -L--export-dynamic ${DDOC_FLAGS}")
+# set(CMAKE_D_CREATE_PREPROCESSED_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+set(CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -of<ASSEMBLY_SOURCE>")
+# set(CMAKE_INCLUDE_SYSTEM_FLAG_D "-isystem ")
diff --git a/cmake-d/Platform/Windows-dmd.cmake b/cmake-d/Platform/Windows-dmd.cmake
index c4e53af..def1fd3 100644
--- a/cmake-d/Platform/Windows-dmd.cmake
+++ b/cmake-d/Platform/Windows-dmd.cmake
@@ -12,45 +12,45 @@
 # See http://www.cmake.org/HTML/Copyright.html for details
 #
 
-#SET(DSTDLIB_FLAGS "-version=Phobos")
+#set(DSTDLIB_FLAGS "-version=Phobos")
 IF(CMAKE_D_BUILD_DOCS)
-	SET(DDOC_FLAGS "-D -Dddocumentation")
-	#FOREACH(item ${CMAKE_D_DDOC_FILES})
-	#	SET(DDOC_FLAGS "${DDOC_FLAGS} ${item}")
-	#ENDFOREACH(item)
-ENDIF(CMAKE_D_BUILD_DOCS)
+  set(DDOC_FLAGS "-D -Dddocumentation")
+  # foreach(item ${CMAKE_D_DDOC_FILES})
+  #  set(DDOC_FLAGS "${DDOC_FLAGS} ${item}")
+  # endforeach()
+endif()
 
-SET(CMAKE_D_OUTPUT_EXTENSION .obj)
-SET(CMAKE_D_DASH_O "-of")
-SET(CMAKE_BASE_NAME dmd)
+set(CMAKE_D_OUTPUT_EXTENSION .obj)
+set(CMAKE_D_DASH_O "-of")
+set(CMAKE_BASE_NAME dmd)
 
-SET(CMAKE_STATIC_LIBRARY_CREATE_D_FLAGS "-lib")
+set(CMAKE_STATIC_LIBRARY_CREATE_D_FLAGS "-lib")
 
-SET(CMAKE_SHARED_LIBRARY_D_FLAGS "")            # -pic
-SET(CMAKE_SHARED_LIBRARY_CREATE_D_FLAGS "-shared")       # -shared
-SET(CMAKE_SHARED_LIBRARY_LINK_D_FLAGS "")         # +s, flag for exe link to use shared lib
-SET(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG "")       # -rpath
-SET(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG_SEP "")   # : or empty
-SET(CMAKE_INCLUDE_FLAG_D "-I")       # -I
-SET(CMAKE_INCLUDE_FLAG_D_SEP "")     # , or empty
-SET(CMAKE_LIBRARY_PATH_FLAG "-L-L")
-SET(CMAKE_LIBRARY_PATH_TERMINATOR "")  # for the Digital Mars D compiler the link paths have to be terminated with a "/"
+set(CMAKE_SHARED_LIBRARY_D_FLAGS "")            # -pic
+set(CMAKE_SHARED_LIBRARY_CREATE_D_FLAGS "-shared")       # -shared
+set(CMAKE_SHARED_LIBRARY_LINK_D_FLAGS "")         # +s, flag for exe link to use shared lib
+set(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG "")       # -rpath
+set(CMAKE_SHARED_LIBRARY_RUNTIME_D_FLAG_SEP "")   # : or empty
+set(CMAKE_INCLUDE_FLAG_D "-I")       # -I
+set(CMAKE_INCLUDE_FLAG_D_SEP "")     # , or empty
+set(CMAKE_LIBRARY_PATH_FLAG "-L-L")
+set(CMAKE_LIBRARY_PATH_TERMINATOR "")  # for the Digital Mars D compiler the link paths have to be terminated with a "/"
 
-SET(CMAKE_LINK_LIBRARY_FLAG "-L-l")
-SET(CMAKE_STATIC_LIBRARY_PREFIX "")				#
-SET(CMAKE_STATIC_LIBRARY_SUFFIX ".lib")			# lib
-SET(CMAKE_SHARED_LIBRARY_PREFIX "")          	#
-SET(CMAKE_SHARED_LIBRARY_SUFFIX ".dll")         # .dll
-SET(CMAKE_EXECUTABLE_SUFFIX ".exe")          	# .exe
-SET(CMAKE_DL_LIBS "dl")
+set(CMAKE_LINK_LIBRARY_FLAG "-L-l")
+set(CMAKE_STATIC_LIBRARY_PREFIX "")				#
+set(CMAKE_STATIC_LIBRARY_SUFFIX ".lib")			# lib
+set(CMAKE_SHARED_LIBRARY_PREFIX "")          	#
+set(CMAKE_SHARED_LIBRARY_SUFFIX ".dll")         # .dll
+set(CMAKE_EXECUTABLE_SUFFIX ".exe")          	# .exe
+set(CMAKE_DL_LIBS "dl")
 
-SET(CMAKE_FIND_LIBRARY_PREFIXES "")
-SET(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll")
+set(CMAKE_FIND_LIBRARY_PREFIXES "")
+set(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll")
 
-SET (CMAKE_D_FLAGS_INIT "")
+set(CMAKE_D_FLAGS_INIT "")
 # DMD can only produce 32-bit binaries for now
-SET (CMAKE_D_LINK_FLAGS "")
-SET (CMAKE_D_FLAGS_DEBUG_INIT "-g -debug ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELEASE_INIT "-O -release -inline ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O -g ${DDOC_FLAGS}")
-SET (CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -of<ASSEMBLY_SOURCE>")
+set(CMAKE_D_LINK_FLAGS "")
+set(CMAKE_D_FLAGS_DEBUG_INIT "-g -debug ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELEASE_INIT "-O -release -inline ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O -g ${DDOC_FLAGS}")
+set(CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -of<ASSEMBLY_SOURCE>")
diff --git a/cmake-d/Platform/Windows-gdc.cmake b/cmake-d/Platform/Windows-gdc.cmake
index 6f8fcc3..a476fe3 100644
--- a/cmake-d/Platform/Windows-gdc.cmake
+++ b/cmake-d/Platform/Windows-gdc.cmake
@@ -12,24 +12,24 @@
 # See http://www.cmake.org/HTML/Copyright.html for details
 #
 
-IF(CMAKE_D_USE_TANGO)
-	SET(DSTDLIB_FLAGS "-fversion=Tango")
-ENDIF(CMAKE_D_USE_TANGO)
-IF(CMAKE_D_USE_PHOBOS)
-	SET(DSTDLIB_FLAGS "-fversion=Phobos")
-ENDIF(CMAKE_D_USE_PHOBOS)
-IF(CMAKE_D_BUILD_DOCS)
-	SET(DDOC_FLAGS "-fdoc -fdoc-dir=documentation")
-	FOREACH(item ${CMAKE_D_DDOC_FILES})
-		SET(DDOC_FLAGS "${DDOC_FLAGS} -fdoc-inc=${item}")
-	ENDFOREACH(item)
-ENDIF(CMAKE_D_BUILD_DOCS)
+if(CMAKE_D_USE_TANGO)
+  set(DSTDLIB_FLAGS "-fversion=Tango")
+endif()
+if(CMAKE_D_USE_PHOBOS)
+  set(DSTDLIB_FLAGS "-fversion=Phobos")
+endif()
+if(CMAKE_D_BUILD_DOCS)
+	set(DDOC_FLAGS "-fdoc -fdoc-dir=documentation")
+	foreach(item ${CMAKE_D_DDOC_FILES})
+		set(DDOC_FLAGS "${DDOC_FLAGS} -fdoc-inc=${item}")
+	endforeach()
+endif()
 
-SET (CMAKE_D_FLAGS_INIT "-fversion=Win -fversion=${CMAKE_BUILD_TYPE}Build ${DSTDLIB_FLAGS}")
-SET (CMAKE_D_FLAGS_DEBUG_INIT "-g ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_MINSIZEREL_INIT "-Os ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELEASE_INIT "-O3 -fomit-frame-pointer -fweb -frelease -finline-functions ${DDOC_FLAGS}")
-SET (CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O2 -g ${DDOC_FLAGS}")
-#  SET (CMAKE_D_CREATE_PREPROCESSED_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
-SET (CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
-#SET (CMAKE_INCLUDE_SYSTEM_FLAG_D "-isystem ")
+set(CMAKE_D_FLAGS_INIT "-fversion=Win -fversion=${CMAKE_BUILD_TYPE}Build ${DSTDLIB_FLAGS}")
+set(CMAKE_D_FLAGS_DEBUG_INIT "-g ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_MINSIZEREL_INIT "-Os ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELEASE_INIT "-O3 -fomit-frame-pointer -fweb -frelease -finline-functions ${DDOC_FLAGS}")
+set(CMAKE_D_FLAGS_RELWITHDEBINFO_INIT "-O2 -g ${DDOC_FLAGS}")
+# set(CMAKE_D_CREATE_PREPROCESSED_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+set(CMAKE_D_CREATE_ASSEMBLY_SOURCE "<CMAKE_D_COMPILER> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+# set(CMAKE_INCLUDE_SYSTEM_FLAG_D "-isystem ")
diff --git a/cmake-d/UseDDeps.cmake b/cmake-d/UseDDeps.cmake
index 6374ae1..41284f5 100644
--- a/cmake-d/UseDDeps.cmake
+++ b/cmake-d/UseDDeps.cmake
@@ -8,57 +8,56 @@
 #
 
 macro(add_executable_with_dependencies _target)
-	# extract D source files from arguments
-	foreach(file ${ARGV})
-		if(${file} MATCHES "\\.d$")
-			list(APPEND d_source_files ${file})
-		endif()
-	endforeach()
+  # extract D source files from arguments
+  foreach(file ${ARGV})
+    if(${file} MATCHES "\\.d$")
+      list(APPEND d_source_files ${file})
+    endif()
+  endforeach()
 
-	#message("D files in arguments: ${d_source_files}")
+  #message("D files in arguments: ${d_source_files}")
 
-	foreach(file IN LISTS d_source_files)
-		set(source_file "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
-		set(dependency_file "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${file}-depend.cmake")
-		set(dependency_files ${dependency_files} ${dependency_file})
+  foreach(file IN LISTS d_source_files)
+    set(source_file "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
+    set(dependency_file "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/${file}-depend.cmake")
+    set(dependency_files ${dependency_files} ${dependency_file})
 
-		#message("Checking dependencies for ${source_file}")
-		#message("Put into ${dependency_file}")
-		# TODO
-		# better way to get the included directories
-		get_directory_property(include_dirs INCLUDE_DIRECTORIES)
-		set(INCLUDES )
-		foreach(include_dir IN LISTS include_dirs)
-			list(APPEND INCLUDES "${CMAKE_INCLUDE_FLAG_D}${include_dir}")
-		endforeach()
+    #message("Checking dependencies for ${source_file}")
+    #message("Put into ${dependency_file}")
+    # TODO
+    # better way to get the included directories
+    get_directory_property(include_dirs INCLUDE_DIRECTORIES)
+    set(INCLUDES )
+    foreach(include_dir IN LISTS include_dirs)
+      list(APPEND INCLUDES "${CMAKE_INCLUDE_FLAG_D}${include_dir}")
+    endforeach()
 
-		execute_process(
-			COMMAND ${CMAKE_COMMAND}
-			-D "CMAKE_D_COMPILER:STRING=${CMAKE_D_COMPILER}"
-			-D "CMAKE_D_FLAGS:STRING=${CMAKE_D_FLAGS}"
-			-D "include_directories:STRING=${INCLUDES}"
-			-D "source_file:STRING=${source_file}"
-			-D "dependency_file:STRING=${dependency_file}"
-			-P "${CMAKE_ROOT}/Modules/dependencies.cmake" # TODO hard coded path
-			)
+    execute_process(
+      COMMAND ${CMAKE_COMMAND}
+      -D "CMAKE_D_COMPILER:STRING=${CMAKE_D_COMPILER}"
+      -D "CMAKE_D_FLAGS:STRING=${CMAKE_D_FLAGS}"
+      -D "include_directories:STRING=${INCLUDES}"
+      -D "source_file:STRING=${source_file}"
+      -D "dependency_file:STRING=${dependency_file}"
+      -P "${CMAKE_ROOT}/Modules/dependencies.cmake" # TODO hard coded path
+    )
 
-		# load dependencies from file
-		include(${dependency_file})
-		#message("DEPENDENCIES ${D_DMD_DEPEND}")
+    # load dependencies from file
+    include(${dependency_file})
+    #message("DEPENDENCIES ${D_DMD_DEPEND}")
 
-		add_custom_command(
-			OUTPUT ${dependency_file}
-			DEPENDS ${D_DMD_DEPEND}
-			COMMAND ${CMAKE_COMMAND}
-			-D "CMAKE_D_COMPILER:STRING=${CMAKE_D_COMPILER}"
-			-D "CMAKE_D_FLAGS:STRING=${CMAKE_D_FLAGS}"
-			-D "include_directories:STRING=${INCLUDES}"
-			-D "source_file:STRING=${source_file}"
-			-D "dependency_file:STRING=${dependency_file}"
-			-P "${CMAKE_ROOT}/Modules/dependencies.cmake" # TODO hard coded path
-			COMMENT "Scanning for dependencies"
-			)
-	endforeach()
+    add_custom_command(
+      OUTPUT ${dependency_file}
+      DEPENDS ${D_DMD_DEPEND}
+      COMMAND ${CMAKE_COMMAND}
+      -D "CMAKE_D_COMPILER:STRING=${CMAKE_D_COMPILER}"
+      -D "CMAKE_D_FLAGS:STRING=${CMAKE_D_FLAGS}"
+      -D "include_directories:STRING=${INCLUDES}"
+      -D "source_file:STRING=${source_file}"
+      -D "dependency_file:STRING=${dependency_file}"
+      -P "${CMAKE_ROOT}/Modules/dependencies.cmake" # TODO hard coded path
+      COMMENT "Scanning for dependencies")
+  endforeach()
 
-	add_executable(${ARGV} ${dependency_files})
-endmacro(add_executable_with_dependencies)
+  add_executable(${ARGV} ${dependency_files})
+endmacro()
diff --git a/cmake-d/UseDDoc.cmake b/cmake-d/UseDDoc.cmake
index 589aed6..5fc6cc6 100644
--- a/cmake-d/UseDDoc.cmake
+++ b/cmake-d/UseDDoc.cmake
@@ -8,66 +8,65 @@
 #
 
 # Do not build documentation by default
-if (NOT CMAKE_D_BUILD_DOCS)
-	set(CMAKE_D_BUILD_DOCS False CACHE BOOLEAN TRUE FORCE)
-else (NOT CMAKE_D_BUILD_DOCS)
-	# check for specified ddoc files
-	# default to the candydoc usual
-	set(CMAKE_D_BUILD_DOCS True CACHE BOOLEAN FALSE FORCE)	
-	if (NOT CMAKE_D_DDOC_FILES)
-		set(CMAKE_D_DDOC_FILES "documentation/candydoc/candy.ddoc;documentation/candydoc/modules.ddoc" CACHE STRING FALSE FORCE)
-	else (NOT CMAKE_D_DDOC_FILES)
-		set(CMAKE_D_DDOC_FILES "${CMAKE_D_DDOC_FILES}" CACHE STRING FALSE FORCE)
-	endif (NOT CMAKE_D_DDOC_FILES)
+if(NOT CMAKE_D_BUILD_DOCS)
+  set(CMAKE_D_BUILD_DOCS False CACHE BOOLEAN TRUE FORCE)
+else()
+  # check for specified ddoc files
+  # default to the candydoc usual
+  set(CMAKE_D_BUILD_DOCS True CACHE BOOLEAN FALSE FORCE)  
+  if(NOT CMAKE_D_DDOC_FILES)
+    set(CMAKE_D_DDOC_FILES "documentation/candydoc/candy.ddoc;documentation/candydoc/modules.ddoc" CACHE STRING FALSE FORCE)
+  else()
+    set(CMAKE_D_DDOC_FILES "${CMAKE_D_DDOC_FILES}" CACHE STRING FALSE FORCE)
+  endif()
 
-	# copy the candydoc files
-	file(GLOB_RECURSE CANDY_DOC_FILES "${CMAKE_CURRENT_SOURCE_DIR}/candydoc/*")
-	foreach(item ${CANDY_DOC_FILES})
-		string(REGEX REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" item ${item})
-		configure_file(${item} ${CMAKE_CURRENT_BINARY_DIR}/documentation/${item} COPYONLY)
-	endforeach(item)
-	
-	# create modules.ddoc
-	file(GLOB_RECURSE sources "${CMAKE_CURRENT_SOURCE_DIR}/*.d")
-	set(first True)
-	foreach(item ${sources})
-		# first make sure we're not config.d
-		string(REGEX MATCH "config\\.d" ignore ${item})
-		if (NOT ${ignore} MATCHES "")
-			# fix up the output
-			string(REGEX REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" item ${item})
-			string(REGEX REPLACE "\\.d" ".html" htmlFile ${item})
-			string(REGEX REPLACE "^.*/" "" htmlFile ${htmlFile})
-			string(REGEX REPLACE "\\.d" "" item ${item})
-			string(REGEX REPLACE "/" "." item ${item})
-			if (first)
-				set(modules "${item}")
-				set(first False)
-				set(CMAKE_D_DDOC_CLEAN_FILES "${CMAKE_CURRENT_BINARY_DIR}/documentation/${htmlFile}" CACHE STRING FALSE FORCE)
-			else (first)
-				set(modules "${modules};${item}")
-				set(CMAKE_D_DDOC_CLEAN_FILES "${CMAKE_D_DDOC_CLEAN_FILES}" "${CMAKE_CURRENT_BINARY_DIR}/documentation/${htmlFile}" CACHE STRING FALSE FORCE)
-			endif (first)
-		endif (NOT ${ignore} MATCHES "")
-	endforeach(item)
-	
-	# create formatted modules string
-	set(modString "MODULES = \n")
-	foreach(item ${modules})
-		set(modString "${modString}\t$(MODULE ${item})\n")
-	endforeach(item)
-	file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/documentation/candydoc/modules.ddoc" ${modString})
-
-	# create index.html
-	set(modString "<html><head><title>${PROJECT_NAME} API Documentation</title></head><body>\n")
-	set(modString "<h>${PROJECT_NAME} API Documentation:<br /></h>\n")
-	set(modString "${modString}<ul>\n")
-	foreach(item ${modules})
-		string(REGEX REPLACE "[a-z0-9]*\\." "" filename ${item})
-		set(modString "${modString}\t<li> <a href=\"${filename}.html\">${item}</a> </li>\n")
-	endforeach(item)
-	set(modString "${modString}</ul>\n")
-	set(modString "${modString}</body></html>\n")
-	file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/documentation/index.html" ${modString})
-endif (NOT CMAKE_D_BUILD_DOCS)
+  # copy the candydoc files
+  file(GLOB_RECURSE CANDY_DOC_FILES "${CMAKE_CURRENT_SOURCE_DIR}/candydoc/*")
+  foreach(item ${CANDY_DOC_FILES})
+    string(REGEX REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" item ${item})
+    configure_file(${item} ${CMAKE_CURRENT_BINARY_DIR}/documentation/${item} COPYONLY)
+  endforeach()
+  
+  # create modules.ddoc
+  file(GLOB_RECURSE sources "${CMAKE_CURRENT_SOURCE_DIR}/*.d")
+  set(first True)
+  foreach(item ${sources})
+    # first make sure we're not config.d
+    string(REGEX MATCH "config\\.d" ignore ${item})
+    if(NOT ${ignore} MATCHES "")
+      # fix up the output
+      string(REGEX REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" item ${item})
+      string(REGEX REPLACE "\\.d" ".html" htmlFile ${item})
+      string(REGEX REPLACE "^.*/" "" htmlFile ${htmlFile})
+      string(REGEX REPLACE "\\.d" "" item ${item})
+      string(REGEX REPLACE "/" "." item ${item})
+      if(first)
+        set(modules "${item}")
+        set(first False)
+        set(CMAKE_D_DDOC_CLEAN_FILES "${CMAKE_CURRENT_BINARY_DIR}/documentation/${htmlFile}" CACHE STRING FALSE FORCE)
+      else()
+        set(modules "${modules};${item}")
+        set(CMAKE_D_DDOC_CLEAN_FILES "${CMAKE_D_DDOC_CLEAN_FILES}" "${CMAKE_CURRENT_BINARY_DIR}/documentation/${htmlFile}" CACHE STRING FALSE FORCE)
+      endif()
+    endif()
+  endforeach()
+  
+  # create formatted modules string
+  set(modString "MODULES = \n")
+  foreach(item ${modules})
+    set(modString "${modString}\t$(MODULE ${item})\n")
+  endforeach()
+  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/documentation/candydoc/modules.ddoc" ${modString})
 
+  # create index.html
+  set(modString "<html><head><title>${PROJECT_NAME} API Documentation</title></head><body>\n")
+  set(modString "<h>${PROJECT_NAME} API Documentation:<br /></h>\n")
+  set(modString "${modString}<ul>\n")
+  foreach(item ${modules})
+    string(REGEX REPLACE "[a-z0-9]*\\." "" filename ${item})
+    set(modString "${modString}\t<li> <a href=\"${filename}.html\">${item}</a> </li>\n")
+  endforeach()
+  set(modString "${modString}</ul>\n")
+  set(modString "${modString}</body></html>\n")
+  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/documentation/index.html" ${modString})
+endif()
diff --git a/cmake-d/UseDUnittest.cmake b/cmake-d/UseDUnittest.cmake
index 1757ee6..9f4ac70 100644
--- a/cmake-d/UseDUnittest.cmake
+++ b/cmake-d/UseDUnittest.cmake
@@ -9,29 +9,29 @@
 
 macro(add_unittests _sourcefile)
 
-	set(_testname "${_sourcefile}")
-	set(main_unittest "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/unittest.d")
-	set(_source_file "${CMAKE_CURRENT_SOURCE_DIR}/${_sourcefile}")
+  set(_testname "${_sourcefile}")
+  set(main_unittest "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/unittest.d")
+  set(_source_file "${CMAKE_CURRENT_SOURCE_DIR}/${_sourcefile}")
 
-	#message("main_unittest ${main_unittest}")
-	#message("testname ${_testname}")
-	#message("_sourcefile ${_source_file}")
+  #message("main_unittest ${main_unittest}")
+  #message("testname ${_testname}")
+  #message("_sourcefile ${_source_file}")
 
-	if(NOT EXISTS ${main_unittest})
-		file(WRITE ${main_unittest} "// Generated by UseDUnittest.cmake\nint main() { return 0; }")
-	endif()
+  if(NOT EXISTS ${main_unittest})
+    file(WRITE ${main_unittest} "// Generated by UseDUnittest.cmake\nint main() { return 0; }")
+  endif()
 
-	# TODO
-	# better way to get the included directories
-	get_directory_property(include_dirs INCLUDE_DIRECTORIES)
-	set(INCLUDES )
-	foreach(include_dir IN LISTS include_dirs)
-		list(APPEND INCLUDES "${CMAKE_INCLUDE_FLAG_D}${include_dir}")
-	endforeach()
+  # TODO
+  # better way to get the included directories
+  get_directory_property(include_dirs INCLUDE_DIRECTORIES)
+  set(INCLUDES )
+  foreach(include_dir IN LISTS include_dirs)
+    list(APPEND INCLUDES "${CMAKE_INCLUDE_FLAG_D}${include_dir}")
+  endforeach()
 
-	separate_arguments(CMAKE_D_FLAGS)
+  separate_arguments(CMAKE_D_FLAGS)
 
-	add_test(NAME ${_testname}
-	         COMMAND ${CMAKE_D_COMPILER} ${CMAKE_D_FLAGS} ${INCLUDES} ${main_unittest} -unittest -run ${_source_file})
+  add_test(NAME ${_testname}
+  	COMMAND ${CMAKE_D_COMPILER} ${CMAKE_D_FLAGS} ${INCLUDES} ${main_unittest} -unittest -run ${_source_file})
 
-endmacro(add_unittests)
+endmacro()
diff --git a/cmake-d/UseDub.cmake b/cmake-d/UseDub.cmake
index 8a6fca0..18da419 100644
--- a/cmake-d/UseDub.cmake
+++ b/cmake-d/UseDub.cmake
@@ -15,14 +15,14 @@
 
 if(NOT DUB_DIRECTORY)
 	set(DUB_DIRECTORY ${CMAKE_BINARY_DIR}/UseDub CACHE PATH "Dub packages directory")
-endif(NOT DUB_DIRECTORY)
+endif()
 
 set(DUB_REGISTRY "http://code.dlang.org/packages")
 file(MAKE_DIRECTORY ${DUB_DIRECTORY}/CMakeTmp)
 
 if(NOT CMAKE_D_COMPILER)
 	message(FATAL_ERROR "UseDub needs a D compiler or use it in a D project.")
-endif(NOT CMAKE_D_COMPILER)
+endif()
 
 #compile json parsers
 if(NOT EXISTS ${DUB_DIRECTORY}/CMakeTmp/DubUrl)
@@ -36,7 +36,7 @@ if(NOT EXISTS ${DUB_DIRECTORY}/CMakeTmp/DubUrl)
 	execute_process(COMMAND ${CMAKE_D_COMPILER} -I${SEMVER_PATH} ${DUB_GET_PACKAGE_URL_D_SRC} ${SEMVER_SRC}
 		WORKING_DIRECTORY ${DUB_DIRECTORY}/CMakeTmp)
 	unset(DUB_GET_PACKAGE_URL_D_SRC CACHE)
-endif(NOT EXISTS ${DUB_DIRECTORY}/CMakeTmp/DubUrl)
+endif()
 if(NOT EXISTS ${DUB_DIRECTORY}/CMakeTmp/DubToCMake)
 	find_file(DUB_PACKAGE_TO_CMAKE_D_SRC "DubToCMake.d"
 		PATHS ${CMAKE_ROOT}/Modules ${CMAKE_MODULE_PATH} NO_DEFAULT_PATH
@@ -44,7 +44,7 @@ if(NOT EXISTS ${DUB_DIRECTORY}/CMakeTmp/DubToCMake)
 	execute_process(COMMAND ${CMAKE_D_COMPILER} ${DUB_PACKAGE_TO_CMAKE_D_SRC}
 		WORKING_DIRECTORY ${DUB_DIRECTORY}/CMakeTmp)
 	unset(DUB_PACKAGE_TO_CMAKE_D_SRC CACHE)
-endif(NOT EXISTS ${DUB_DIRECTORY}/CMakeTmp/DubToCMake)
+endif()
 
 include(ExternalProject)
 
@@ -56,16 +56,16 @@ function(DubProject_Add name)
 		if(NOT statusCode EQUAL 0)
 			file(REMOVE ${DUB_DIRECTORY}/${name}.json)
 			message(FATAL_ERROR "Failed to download ${DUB_REGISTRY}/${name}.json")
-		endif(NOT statusCode EQUAL 0)
-	endif(NOT EXISTS ${DUB_DIRECTORY}/${name}.json)
+		endif()
+	endif()
 
 	if(${ARGC} GREATER 1)
 		execute_process(COMMAND ${DUB_DIRECTORY}/CMakeTmp/DubUrl -p ${name}.json -t ${ARGN}
 			WORKING_DIRECTORY ${DUB_DIRECTORY})
-	else(${ARGC} GREATER 1)
+	else()
 		execute_process(COMMAND ${DUB_DIRECTORY}/CMakeTmp/DubUrl -p ${name}.json
 			WORKING_DIRECTORY ${DUB_DIRECTORY})
-	endif(${ARGC} GREATER 1)
+	endif()
 
 	include(${DUB_DIRECTORY}/${name}.cmake)
 
diff --git a/cmake-d/UseDub/DubToCMake.d b/cmake-d/UseDub/DubToCMake.d
index d232f08..aafac60 100644
--- a/cmake-d/UseDub/DubToCMake.d
+++ b/cmake-d/UseDub/DubToCMake.d
@@ -35,7 +35,7 @@ find_file(APP_MAIN_FILE
 file(GLOB_RECURSE SRC_FILES source/*.d src/*.d)
 if(APP_MAIN_FILE)
     list(REMOVE_ITEM SRC_FILES ${APP_MAIN_FILE})
-endif(APP_MAIN_FILE)
+endif()
 
 include_directories(source src)
 >".format(root["name"].str);
@@ -46,9 +46,9 @@ include_directories(source src)
             cmake ~= q"<
 if(APP_MAIN_FILE)
     add_executable(%1$s ${SRC_FILES} ${APP_MAIN_FILE})
-else(APP_MAIN_FILE)
+else()
     add_library(%1$s ${SRC_FILES})
-endif(APP_MAIN_FILE)
+endif()
 >".format(target);
             break;
         case "none":
diff --git a/cmake-d/dependencies.cmake b/cmake-d/dependencies.cmake
index 66723ac..307aec9 100644
--- a/cmake-d/dependencies.cmake
+++ b/cmake-d/dependencies.cmake
@@ -15,7 +15,7 @@ execute_process(COMMAND ${CMAKE_D_COMPILER} ${CMAKE_D_FLAGS} ${include_directori
 #message("executing:  ${CMAKE_D_COMPILER} ${CMAKE_D_FLAGS} ${include_directories} -deps=${dependency_file}.tmp -o- ${source_file}")
 
 if(NOT EXISTS ${dependency_file})
-	file(WRITE ${dependency_file} "# Generated by: ${CMAKE_CURRENT_LIST_FILE}\nSET(D_DMD_DEPEND\n)\n\n")
+  file(WRITE ${dependency_file} "# Generated by: ${CMAKE_CURRENT_LIST_FILE}\nSET(D_DMD_DEPEND\n)\n\n")
 endif()
 
 file(READ ${dependency_file}.tmp depend_text)
@@ -28,7 +28,7 @@ list(REMOVE_DUPLICATES out)
 list(SORT out)
 
 foreach(file ${out})
-	set(dependencies "${dependencies} \"${file}\"\n")
+  set(dependencies "${dependencies} \"${file}\"\n")
 endforeach()
 
 # write new dependencies to temporary file
@@ -42,8 +42,8 @@ include(${dependency_file}.tmp)
 
 # did the dependencies change?
 if(NOT "${D_DMD_DEPEND}" STREQUAL "${old_dependencies}")
-	message("Dependencies changed. Need to build.")
-	execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${source_file})
+  message("Dependencies changed. Need to build.")
+  execute_process(COMMAND ${CMAKE_COMMAND} -E touch ${source_file})
 endif()
 
 execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${dependency_file}.tmp ${dependency_file})
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 9621161..6601f95 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -4,30 +4,30 @@ cmake_minimum_required(VERSION 2.8.1)
 # We must explicitly indicate we're using the D language
 # in the project declaration.  Listing other languages
 # is fine.
-PROJECT (CMAKE-D_TESTS C D )
-SET( GLOBAL_DMD_DEFS "-w" )
-SET( GLOBAL_GCC_DEFS "-Wall -pedantic" )
+project(CMAKE-D_TESTS C D)
+set(GLOBAL_DMD_DEFS "-w")
+set(GLOBAL_GCC_DEFS "-Wall -pedantic")
 
-# Don't use ADD_DEFINITIONS() with a mixed C + D project
+# Don't use add_definitions() with a mixed C + D project
 # since that adds the same flags to both C and D builds.
 # Also, the D linker preference is set to 40, which is
 # higher than C++ (30) and C (10).  This causes CMAKE
 # to use the D linker in mixed linking cases.
 # Append our own definitions to the defaults.
-SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GLOBAL_GCC_DEFS}" )
-SET( CMAKE_D_FLAGS "${CMAKE_D_FLAGS} ${GLOBAL_DMD_DEFS}" )
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GLOBAL_GCC_DEFS}")
+set(CMAKE_D_FLAGS "${CMAKE_D_FLAGS} ${GLOBAL_DMD_DEFS}")
 
 enable_testing()
 
 # build libs first, then apps
-ADD_SUBDIRECTORY (lib_1)
-ADD_SUBDIRECTORY (lib_2)
-ADD_SUBDIRECTORY (app_1)
-ADD_SUBDIRECTORY (app_2)
-ADD_SUBDIRECTORY (app_3)
-ADD_SUBDIRECTORY (app_5)
-ADD_SUBDIRECTORY (app_4)
-ADD_SUBDIRECTORY (app_6)
-ADD_SUBDIRECTORY (app_7)
-ADD_SUBDIRECTORY (app_8)
-ADD_SUBDIRECTORY (app_9)
+add_subdirectory(lib_2)
+add_subdirectory(lib_1)
+add_subdirectory(app_1)
+add_subdirectory(app_2)
+add_subdirectory(app_3)
+add_subdirectory(app_5)
+add_subdirectory(app_4)
+add_subdirectory(app_6)
+add_subdirectory(app_7)
+add_subdirectory(app_8)
+add_subdirectory(app_9)
diff --git a/tests/app_1/CMakeLists.txt b/tests/app_1/CMakeLists.txt
index 426292d..909206f 100644
--- a/tests/app_1/CMakeLists.txt
+++ b/tests/app_1/CMakeLists.txt
@@ -1,2 +1,2 @@
-ADD_EXECUTABLE( app_1 app_1.d )
-ADD_TEST( app_1 app_1 )
+add_executable(app_1 app_1.d)
+add_test(app_1 app_1)
diff --git a/tests/app_2/CMakeLists.txt b/tests/app_2/CMakeLists.txt
index 0c0d701..852413a 100644
--- a/tests/app_2/CMakeLists.txt
+++ b/tests/app_2/CMakeLists.txt
@@ -1,2 +1,2 @@
-ADD_EXECUTABLE( app_2 app_2.d )
-ADD_TEST( app_2 app_2 )
+add_executable(app_2 app_2.d)
+add_test(app_2 app_2)
diff --git a/tests/app_3/CMakeLists.txt b/tests/app_3/CMakeLists.txt
index b2d7752..4f2bc83 100644
--- a/tests/app_3/CMakeLists.txt
+++ b/tests/app_3/CMakeLists.txt
@@ -1,4 +1,4 @@
-ADD_EXECUTABLE ( app_3 app_3.d )
-INCLUDE_DIRECTORIES( app_3 ${PROJECT_SOURCE_DIR} )
-TARGET_LINK_LIBRARIES ( app_3 lib_1 )
-ADD_TEST( app_3 app_3 )
+add_executable(app_3 app_3.d)
+include_directories(app_3 ${PROJECT_SOURCE_DIR})
+add_test(app_3 app_3)
+target_link_libraries(app_3 lib_1)
diff --git a/tests/app_4/CMakeLists.txt b/tests/app_4/CMakeLists.txt
index 1f401ea..2fb07e8 100644
--- a/tests/app_4/CMakeLists.txt
+++ b/tests/app_4/CMakeLists.txt
@@ -3,7 +3,7 @@
 # The linker preference of D is higher than C (or CXX), so after
 # the objects are created, the D toolchain will drive linking.
 #
-ADD_EXECUTABLE ( app_4 app_4.d )
-INCLUDE_DIRECTORIES( app_4 ${PROJECT_SOURCE_DIR} )
-TARGET_LINK_LIBRARIES( app_4 lib_2 )
-ADD_TEST( app_4 app_4 )
+add_executable(app_4 app_4.d)
+include_directories(app_4 ${PROJECT_SOURCE_DIR})
+add_test(app_4 app_4)
+target_link_libraries(app_4 lib_2)
diff --git a/tests/app_5/CMakeLists.txt b/tests/app_5/CMakeLists.txt
index 6f6938a..1c747f5 100644
--- a/tests/app_5/CMakeLists.txt
+++ b/tests/app_5/CMakeLists.txt
@@ -3,13 +3,5 @@
 # The linker preference of D is higher than C (or CXX), so after
 # the objects are created, the D toolchain will drive linking.
 #
-# TODO
-# dirty fix
-# we should make the CMAKE_D_COMPILER_ID work
-# 
-# This 32-bit environment check no longer needed as of dmd 2.053 on Linux
-#IF("${CMAKE_BASE_NAME}" MATCHES "dmd")
-#	SET(CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}" )
-#ENDIF()
-ADD_EXECUTABLE ( app_5 app_5.d cfunc.c )
-ADD_TEST( app_5 app_5 )
+add_executable(app_5 app_5.d cfunc.c)
+add_test(app_5 app_5)
diff --git a/tests/app_6/CMakeLists.txt b/tests/app_6/CMakeLists.txt
index 048c8ad..0d0f2d3 100644
--- a/tests/app_6/CMakeLists.txt
+++ b/tests/app_6/CMakeLists.txt
@@ -1,2 +1,2 @@
-ADD_EXECUTABLE( app_6 app_6.d )
-ADD_TEST( app_6 app_6 )
+add_executable(app_6 app_6.d)
+add_test(app_6 app_6)
diff --git a/tests/app_7/CMakeLists.txt b/tests/app_7/CMakeLists.txt
index 7e1eee0..8dd51f2 100644
--- a/tests/app_7/CMakeLists.txt
+++ b/tests/app_7/CMakeLists.txt
@@ -1,3 +1,3 @@
 # A more complex library test.
-ADD_EXECUTABLE( app_7 app_7.d )
-ADD_TEST( app_7 app_7 )
+add_executable(app_7 app_7.d)
+add_test(app_7 app_7)
diff --git a/tests/app_9/CMakeLists.txt b/tests/app_9/CMakeLists.txt
index b40a610..f383911 100644
--- a/tests/app_9/CMakeLists.txt
+++ b/tests/app_9/CMakeLists.txt
@@ -7,7 +7,7 @@ include(UseDUnittest)
 # add all files
 file(GLOB files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "*.d")
 foreach(file IN LISTS files)
-	add_unittests(${file})
+  add_unittests(${file})
 endforeach()
 
 #add_unittests(moduleA.d)
diff --git a/tests/lib_1/CMakeLists.txt b/tests/lib_1/CMakeLists.txt
index 6d5545e..b2f63d3 100644
--- a/tests/lib_1/CMakeLists.txt
+++ b/tests/lib_1/CMakeLists.txt
@@ -1 +1 @@
-ADD_LIBRARY (lib_1 lib_1.d)
+add_library(lib_1 lib_1.d)
diff --git a/tests/lib_2/CMakeLists.txt b/tests/lib_2/CMakeLists.txt
index 6cf17b2..8c1a5fa 100644
--- a/tests/lib_2/CMakeLists.txt
+++ b/tests/lib_2/CMakeLists.txt
@@ -1,11 +1,3 @@
 # This project is a C library
-PROJECT( lib_2 C )
-# TODO
-# dirty fix
-# we should make the CMAKE_D_COMPILER_ID work
-#
-# This 32-bit environment check no longer needed as of dmd 2.053 on Linux
-#IF("${CMAKE_BASE_NAME}" MATCHES "dmd")
-#	SET(CMAKE_C_FLAGS "-m32 ${CMAKE_C_FLAGS}" )
-#ENDIF()
-ADD_LIBRARY( lib_2 STATIC lib_2.c )
+project(lib_2 C)
+add_library(lib_2 STATIC lib_2.c)