ENH: more uniform approach to enable language, one step closer to being able...

ENH: more uniform approach to enable language, one step closer to being able to enable a language without modifing cmake source code

Modules/CMake.cmake

+# This file is used by cmake.cxx to compute the CMAKE_ROOT location.
+# Do not remove this file from cvs without updating cmake.cxx to look
+# for a different file.

Modules/CMakeDefaultMakeRuleVariables.cmake → Modules/CMakeCInformation.cmake

-# this file contains rule variables that tell cmake how to 
-# do things like build a .o file, create a shared or static library
-#
+# This file sets the basic flags for the C language in CMake.
+# It also loads the available platform file for the system-compiler
+# if it exists.
+
+GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_C_COMPILER} NAME_WE)
+IF(CMAKE_COMPILER_IS_GNUCC)
+  SET(CMAKE_BASE_NAME gcc)
+ENDIF(CMAKE_COMPILER_IS_GNUCC)
+SET(CMAKE_SYSTEM_AND_C_COMPILER_INFO_FILE 
+  ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}.cmake)
+INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL)
+
+# for most systems a module is the same as a shared library
+# so unless the variable CMAKE_MODULE_EXISTS is set just
+# copy the values from the LIBRARY variables
+IF(NOT CMAKE_MODULE_EXISTS)
+  SET(CMAKE_SHARED_MODULE_C_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
+  SET(CMAKE_SHARED_MODULE_CREATE_C_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
+ENDIF(NOT CMAKE_MODULE_EXISTS)
+
+SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS_ENV_INIT} $ENV{CFLAGS} ${CMAKE_C_FLAGS_INIT}" CACHE STRING
+     "Flags for C compiler.")
+
+SET (CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}
+     CACHE STRING "Flags used by the linker.")
+
+IF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+# default build type is none
+  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_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+  ENDIF(NOT CMAKE_NO_BUILD_TYPE)
+  SET (CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG_INIT}" CACHE STRING
+    "Flags used by the compiler during debug builds.")
+  SET (CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL_INIT}" CACHE STRING
+    "Flags used by the compiler during release minsize builds.")
+  SET (CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE_INIT}" CACHE STRING
+    "Flags used by the compiler during release builds (/MD /Ob1 /Oi /Ot /Oy /Gs will produce slightly less optimized but smaller files).")
+  SET (CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
+    "Flags used by the compiler during Release with Debug Info builds.")
+ENDIF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+
+INCLUDE(CMakeCommonLanguageInclude)
+
+# now define the following rule variables
 
-# this file defines the following rule variables
-# CMAKE_CXX_CREATE_SHARED_LIBRARY
-# CMAKE_CXX_CREATE_SHARED_MODULE
 # CMAKE_C_CREATE_SHARED_LIBRARY
 # CMAKE_C_CREATE_SHARED_MODULE
-# CMAKE_FORTRAN_CREATE_SHARED_LIBRARY
-# CMAKE_FORTRAN_CREATE_SHARED_MODULE
-# CMAKE_CXX_CREATE_STATIC_LIBRARY
 # CMAKE_C_CREATE_STATIC_LIBRARY
-# CMAKE_FORTRAN_CREATE_STATIC_LIBRARY
-# CMAKE_CXX_COMPILE_OBJECT
 # CMAKE_C_COMPILE_OBJECT
-# CMAKE_FORTRAN_COMPILE_OBJECT
 # CMAKE_C_LINK_EXECUTABLE
-# CMAKE_FORTRAN_LINK_EXECUTABLE
-# CMAKE_CXX_LINK_EXECUTABLE
 
 # variables supplied by the generator at use time
 # <TARGET>
@@ -28,12 +59,6 @@
 # <FLAGS>
 # <LINK_FLAGS>
 
-# CXX compiler information
-# <CMAKE_CXX_COMPILER>  
-# <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS>
-# <CMAKE_CXX_SHARED_MODULE_CREATE_FLAGS>
-# <CMAKE_CXX_LINK_FLAGS>
-
 # C compiler information
 # <CMAKE_C_COMPILER>  
 # <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS>
@@ -45,22 +70,6 @@
 # <CMAKE_RANLIB>
 
 
-# create a shared C++ library
-IF(NOT CMAKE_CXX_CREATE_SHARED_LIBRARY)
-  SET(CMAKE_CXX_CREATE_SHARED_LIBRARY
-      "<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
-ENDIF(NOT CMAKE_CXX_CREATE_SHARED_LIBRARY)
-
-IF(CMAKE_COMPILER_IS_GNUCXX)
-  SET(CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} -lgcc")
-ENDIF(CMAKE_COMPILER_IS_GNUCXX)
-
-# create a c++ shared module copy the shared library rule by default
-IF(NOT CMAKE_CXX_CREATE_SHARED_MODULE)
-  SET(CMAKE_CXX_CREATE_SHARED_MODULE ${CMAKE_CXX_CREATE_SHARED_LIBRARY})
-ENDIF(NOT CMAKE_CXX_CREATE_SHARED_MODULE)
-
-
 # create a C shared library
 IF(NOT CMAKE_C_CREATE_SHARED_LIBRARY)
   SET(CMAKE_C_CREATE_SHARED_LIBRARY
@@ -72,24 +81,6 @@ IF(NOT CMAKE_C_CREATE_SHARED_MODULE)
   SET(CMAKE_C_CREATE_SHARED_MODULE ${CMAKE_C_CREATE_SHARED_LIBRARY})
 ENDIF(NOT CMAKE_C_CREATE_SHARED_MODULE)
 
-# create a FORTRAN shared library
-IF(NOT CMAKE_FORTRAN_CREATE_SHARED_LIBRARY)
-  SET(CMAKE_FORTRAN_CREATE_SHARED_LIBRARY
-      "<CMAKE_FORTRAN_COMPILER> <CMAKE_SHARED_LIBRARY_FORTRAN_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_FORTRAN_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_FORTRAN_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
-ENDIF(NOT CMAKE_FORTRAN_CREATE_SHARED_LIBRARY)
-
-# create a FORTRAN shared module just copy the shared library rule
-IF(NOT CMAKE_FORTRAN_CREATE_SHARED_MODULE)
-  SET(CMAKE_FORTRAN_CREATE_SHARED_MODULE ${CMAKE_FORTRAN_CREATE_SHARED_LIBRARY})
-ENDIF(NOT CMAKE_FORTRAN_CREATE_SHARED_MODULE)
-
-# create a C++ static library
-IF(NOT CMAKE_CXX_CREATE_STATIC_LIBRARY)
-  SET(CMAKE_CXX_CREATE_STATIC_LIBRARY
-      "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS> "
-      "<CMAKE_RANLIB> <TARGET> ")
-ENDIF(NOT CMAKE_CXX_CREATE_STATIC_LIBRARY)
-
 # create a C static library
 IF(NOT CMAKE_C_CREATE_STATIC_LIBRARY)
   SET(CMAKE_C_CREATE_STATIC_LIBRARY
@@ -97,44 +88,28 @@ IF(NOT CMAKE_C_CREATE_STATIC_LIBRARY)
       "<CMAKE_RANLIB> <TARGET> ")
 ENDIF(NOT CMAKE_C_CREATE_STATIC_LIBRARY)
 
-# create a Fortran static library
-IF(NOT CMAKE_FORTRAN_CREATE_STATIC_LIBRARY)
-  SET(CMAKE_FORTRAN_CREATE_STATIC_LIBRARY
-      "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS> "
-      "<CMAKE_RANLIB> <TARGET> ")
-ENDIF(NOT CMAKE_FORTRAN_CREATE_STATIC_LIBRARY)
-
-# compile a C++ file into an object file
-IF(NOT CMAKE_CXX_COMPILE_OBJECT)
-  SET(CMAKE_CXX_COMPILE_OBJECT
-    "<CMAKE_CXX_COMPILER> -o <OBJECT> <FLAGS> -c <SOURCE>")
-ENDIF(NOT CMAKE_CXX_COMPILE_OBJECT)
-
 # compile a C file into an object file
 IF(NOT CMAKE_C_COMPILE_OBJECT)
   SET(CMAKE_C_COMPILE_OBJECT
     "<CMAKE_C_COMPILER> -o <OBJECT>  <FLAGS> -c <SOURCE>")
 ENDIF(NOT CMAKE_C_COMPILE_OBJECT)
 
-# compile a Fortran file into an object file
-IF(NOT CMAKE_FORTRAN_COMPILE_OBJECT)
-  SET(CMAKE_FORTRAN_COMPILE_OBJECT
-    "<CMAKE_FORTRAN_COMPILER> -o <OBJECT>  <FLAGS> -c <SOURCE>")
-ENDIF(NOT CMAKE_FORTRAN_COMPILE_OBJECT)
-
-
 IF(NOT CMAKE_C_LINK_EXECUTABLE)
   SET(CMAKE_C_LINK_EXECUTABLE
     "<CMAKE_C_COMPILER> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <FLAGS> <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
 ENDIF(NOT CMAKE_C_LINK_EXECUTABLE)
 
-IF(NOT CMAKE_FORTRAN_LINK_EXECUTABLE)
-  SET(CMAKE_FORTRAN_LINK_EXECUTABLE
-    "<CMAKE_FORTRAN_COMPILER> <CMAKE_FORTRAN_LINK_FLAGS> <LINK_FLAGS> <FLAGS> <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
-ENDIF(NOT CMAKE_FORTRAN_LINK_EXECUTABLE)
+IF(CMAKE_USER_MAKE_RULES_OVERRIDE)
+   INCLUDE(${CMAKE_USER_MAKE_RULES_OVERRIDE})
+ENDIF(CMAKE_USER_MAKE_RULES_OVERRIDE)
+
+MARK_AS_ADVANCED(
+CMAKE_C_FLAGS
+CMAKE_C_FLAGS_DEBUG
+CMAKE_C_FLAGS_MINSIZEREL
+CMAKE_C_FLAGS_RELEASE
+CMAKE_C_FLAGS_RELWITHDEBINFO
+)
+SET(CMAKE_C_INFOMATION_LOADED 1)
 
 
-IF(NOT CMAKE_CXX_LINK_EXECUTABLE)
-  SET(CMAKE_CXX_LINK_EXECUTABLE
-    "<CMAKE_CXX_COMPILER> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <FLAGS> <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
-ENDIF(NOT CMAKE_CXX_LINK_EXECUTABLE)

Modules/CMakeCXXInformation.cmake

+# This file sets the basic flags for the C++ language in CMake.
+# It also loads the available platform file for the system-compiler
+# if it exists.
+
+
+GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_CXX_COMPILER} NAME_WE)
+# since the gnu compiler has several names force g++
+IF(CMAKE_COMPILER_IS_GNUCXX)
+  SET(CMAKE_BASE_NAME g++)
+ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+SET(CMAKE_SYSTEM_AND_CXX_COMPILER_INFO_FILE
+  ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}.cmake)
+INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL)
+
+# for most systems a module is the same as a shared library
+# so unless the variable CMAKE_MODULE_EXISTS is set just
+# copy the values from the LIBRARY variables
+IF(NOT CMAKE_MODULE_EXISTS)
+  SET(CMAKE_SHARED_MODULE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CXX_FLAGS})
+ENDIF(NOT CMAKE_MODULE_EXISTS)
+# Create a set of shared library variable specific to C++
+# For 90% of the systems, these are the same flags as the C versions
+# so if these are not set just copy the flags from the c version
+IF(NOT CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS)
+  SET(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
+ENDIF(NOT CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS)
+
+IF(NOT CMAKE_SHARED_LIBRARY_CXX_FLAGS)
+  SET(CMAKE_SHARED_LIBRARY_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
+ENDIF(NOT CMAKE_SHARED_LIBRARY_CXX_FLAGS)
+
+IF(NOT CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
+  SET(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS ${CMAKE_SHARED_LIBRARY_LINK_FLAGS})
+ENDIF(NOT CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
+
+IF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG)
+  SET(CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_FLAG}) 
+ENDIF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG)
+
+IF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP)
+  SET(CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_FLAG_SEP})
+ENDIF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CXX_FLAG_SEP)
+
+# repeat for modules
+IF(NOT CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS)
+  SET(CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS ${CMAKE_SHARED_MODULE_CREATE_C_FLAGS})
+ENDIF(NOT CMAKE_SHARED_MODULE_CREATE_CXX_FLAGS)
+
+IF(NOT CMAKE_SHARED_MODULE_CXX_FLAGS)
+  SET(CMAKE_SHARED_MODULE_CXX_FLAGS ${CMAKE_SHARED_MODULE_C_FLAGS})
+ENDIF(NOT CMAKE_SHARED_MODULE_CXX_FLAGS)
+
+IF(NOT CMAKE_SHARED_MODULE_LINK_CXX_FLAGS)
+  SET(CMAKE_SHARED_MODULE_LINK_CXX_FLAGS ${CMAKE_SHARED_MODULE_LINK_FLAGS})
+ENDIF(NOT CMAKE_SHARED_MODULE_LINK_CXX_FLAGS)
+
+IF(NOT CMAKE_SHARED_MODULE_RUNTIME_CXX_FLAG)
+  SET(CMAKE_SHARED_MODULE_RUNTIME_CXX_FLAG ${CMAKE_SHARED_MODULE_RUNTIME_FLAG}) 
+ENDIF(NOT CMAKE_SHARED_MODULE_RUNTIME_CXX_FLAG)
+
+IF(NOT CMAKE_SHARED_MODULE_RUNTIME_CXX_FLAG_SEP)
+  SET(CMAKE_SHARED_MODULE_RUNTIME_CXX_FLAG_SEP ${CMAKE_SHARED_MODULE_RUNTIME_FLAG_SEP})
+ENDIF(NOT CMAKE_SHARED_MODULE_RUNTIME_CXX_FLAG_SEP)
+
+# add the flags to the cache based
+# on the initial values computed in the platform/*.cmake files
+# use _INIT variables so that this only happens the first time
+# and you can set these flags in the cmake cache
+SET (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_ENV_INIT} $ENV{CXXFLAGS} ${CMAKE_CXX_FLAGS_INIT}" CACHE STRING
+     "Flags used by the compiler during all build types.")
+
+
+IF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+  SET (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG_INIT}" CACHE STRING
+     "Flags used by the compiler during debug builds.")
+  SET (CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL_INIT}" CACHE STRING
+      "Flags used by the compiler during release minsize builds.")
+  SET (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE_INIT}" CACHE STRING
+     "Flags used by the compiler during release builds (/MD /Ob1 /Oi /Ot /Oy /Gs will produce slightly less optimized but smaller files).")
+  SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT}" CACHE STRING
+     "Flags used by the compiler during Release with Debug Info builds.")
+
+ENDIF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+
+
+INCLUDE(CMakeCommonLanguageInclude)
+
+# now define the following rules:
+# CMAKE_CXX_CREATE_SHARED_LIBRARY
+# CMAKE_CXX_CREATE_SHARED_MODULE
+# CMAKE_CXX_CREATE_STATIC_LIBRARY
+# CMAKE_CXX_COMPILE_OBJECT
+# CMAKE_CXX_LINK_EXECUTABLE
+
+# variables supplied by the generator at use time
+# <TARGET>
+# <TARGET_BASE> the target without the suffix
+# <OBJECTS>
+# <OBJECT>
+# <LINK_LIBRARIES>
+# <FLAGS>
+# <LINK_FLAGS>
+
+# CXX compiler information
+# <CMAKE_CXX_COMPILER>  
+# <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS>
+# <CMAKE_CXX_SHARED_MODULE_CREATE_FLAGS>
+# <CMAKE_CXX_LINK_FLAGS>
+
+# Static library tools
+# <CMAKE_AR> 
+# <CMAKE_RANLIB>
+
+
+# create a shared C++ library
+IF(NOT CMAKE_CXX_CREATE_SHARED_LIBRARY)
+  SET(CMAKE_CXX_CREATE_SHARED_LIBRARY
+      "<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>")
+ENDIF(NOT CMAKE_CXX_CREATE_SHARED_LIBRARY)
+
+IF(CMAKE_COMPILER_IS_GNUCXX)
+  SET(CMAKE_CXX_CREATE_SHARED_LIBRARY "${CMAKE_CXX_CREATE_SHARED_LIBRARY} -lgcc")
+ENDIF(CMAKE_COMPILER_IS_GNUCXX)
+
+# create a c++ shared module copy the shared library rule by default
+IF(NOT CMAKE_CXX_CREATE_SHARED_MODULE)
+  SET(CMAKE_CXX_CREATE_SHARED_MODULE ${CMAKE_CXX_CREATE_SHARED_LIBRARY})
+ENDIF(NOT CMAKE_CXX_CREATE_SHARED_MODULE)
+
+
+# create a C++ static library
+IF(NOT CMAKE_CXX_CREATE_STATIC_LIBRARY)
+  SET(CMAKE_CXX_CREATE_STATIC_LIBRARY
+      "<CMAKE_AR> cr <TARGET> <LINK_FLAGS> <OBJECTS> "
+      "<CMAKE_RANLIB> <TARGET> ")
+ENDIF(NOT CMAKE_CXX_CREATE_STATIC_LIBRARY)
+
+# compile a C++ file into an object file
+IF(NOT CMAKE_CXX_COMPILE_OBJECT)
+  SET(CMAKE_CXX_COMPILE_OBJECT
+    "<CMAKE_CXX_COMPILER> -o <OBJECT> <FLAGS> -c <SOURCE>")
+ENDIF(NOT CMAKE_CXX_COMPILE_OBJECT)
+
+IF(NOT CMAKE_CXX_LINK_EXECUTABLE)
+  SET(CMAKE_CXX_LINK_EXECUTABLE
+    "<CMAKE_CXX_COMPILER> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <FLAGS> <OBJECTS>  -o <TARGET> <LINK_LIBRARIES>")
+ENDIF(NOT CMAKE_CXX_LINK_EXECUTABLE)
+
+IF(CMAKE_USER_MAKE_RULES_OVERRIDE)
+   INCLUDE(${CMAKE_USER_MAKE_RULES_OVERRIDE})
+ENDIF(CMAKE_USER_MAKE_RULES_OVERRIDE)
+
+
+MARK_AS_ADVANCED(
+CMAKE_BUILD_TOOL
+CMAKE_VERBOSE_MAKEFILE 
+CMAKE_CXX_FLAGS
+CMAKE_CXX_FLAGS_RELEASE
+CMAKE_CXX_FLAGS_RELWITHDEBINFO
+CMAKE_CXX_FLAGS_MINSIZEREL
+CMAKE_CXX_FLAGS_DEBUG)
+
+SET(CMAKE_CXX_INFOMATION_LOADED 1)
+

Modules/CMakeCommonLanguageInclude.cmake

+# this file has flags that are shared across languages and sets
+# cache values that can be initialized in the platform-compiler.cmake file
+# it may be included by more than one language.
+
+IF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+# default build type is none
+  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_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+  ENDIF(NOT CMAKE_NO_BUILD_TYPE)
+  
+  SET (CMAKE_EXE_LINKER_FLAGS_DEBUG ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
+     "Flags used by the linker during debug builds.")
+
+  SET (CMAKE_EXE_LINKER_FLAGS_MINSIZEREL ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL_INIT} CACHE STRING
+     "Flags used by the linker during release minsize builds.")
+
+  SET (CMAKE_EXE_LINKER_FLAGS_RELEASE ${CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT} "" CACHE STRING
+     "Flags used by the linker during release builds.")
+
+  SET (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO 
+     ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING
+     "Flags used by the linker during Release with Debug Info builds.")
+  
+  SET (CMAKE_SHARED_LINKER_FLAGS_DEBUG ${CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
+     "Flags used by the linker during debug builds.")
+
+  SET (CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL ${CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL_INIT}
+     CACHE STRING
+     "Flags used by the linker during release minsize builds.")
+
+  SET (CMAKE_SHARED_LINKER_FLAGS_RELEASE ${CMAKE_SHARED_LINKER_FLAGS_RELEASE_INIT} "" CACHE STRING
+     "Flags used by the linker during release builds.")
+
+  SET (CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO 
+     ${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING
+     "Flags used by the linker during Release with Debug Info builds.")
+
+  SET (CMAKE_MODULE_LINKER_FLAGS_DEBUG ${CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
+     "Flags used by the linker during debug builds.")
+
+  SET (CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL ${CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL_INIT}
+     CACHE STRING
+     "Flags used by the linker during release minsize builds.")
+
+  SET (CMAKE_MODULE_LINKER_FLAGS_RELEASE ${CMAKE_MODULE_LINKER_FLAGS_RELEASE_INIT} "" CACHE STRING
+     "Flags used by the linker during release builds.")
+
+  SET (CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO 
+     ${CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING
+     "Flags used by the linker during Release with Debug Info builds.")
+
+ENDIF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
+# shared linker flags
+SET (CMAKE_SHARED_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS_INIT} $ENV{LDFLAGS}
+     CACHE STRING "Flags used by the linker during the creation of dll's.")
+
+# module linker flags
+SET (CMAKE_MODULE_LINKER_FLAGS ${CMAKE_MODULE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}
+     CACHE STRING "Flags used by the linker during the creation of modules.")
+
+SET(CMAKE_BUILD_TOOL ${CMAKE_MAKE_PROGRAM} CACHE INTERNAL 
+     "What is the target build tool cmake is generating for.")
+
+
+MARK_AS_ADVANCED(
+CMAKE_BUILD_TOOL
+CMAKE_VERBOSE_MAKEFILE 
+
+CMAKE_EXE_LINKER_FLAGS
+CMAKE_EXE_LINKER_FLAGS_DEBUG
+CMAKE_EXE_LINKER_FLAGS_MINSIZEREL
+CMAKE_EXE_LINKER_FLAGS_RELEASE
+CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
+
+CMAKE_SHARED_LINKER_FLAGS
+CMAKE_SHARED_LINKER_FLAGS_DEBUG
+CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL
+CMAKE_SHARED_LINKER_FLAGS_RELEASE
+CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
+
+CMAKE_MODULE_LINKER_FLAGS
+CMAKE_MODULE_LINKER_FLAGS_DEBUG
+CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL
+CMAKE_MODULE_LINKER_FLAGS_RELEASE
+CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
+
+)
+

Modules/CMakeDetermineCCompiler.cmake

@@ -37,7 +37,6 @@ IF(NOT CMAKE_C_COMPILER)
   SET(CMAKE_C_COMPILER ${CMAKE_C_COMPILER_INIT} CACHE STRING "C compiler")
 ENDIF(NOT CMAKE_C_COMPILER)
 MARK_AS_ADVANCED(CMAKE_C_COMPILER)  
-
 FIND_PROGRAM(CMAKE_AR NAMES ar )
 
 FIND_PROGRAM(CMAKE_RANLIB NAMES ranlib)
@@ -81,3 +80,4 @@ ENDIF(NOT CMAKE_COMPILER_IS_GNUCC_RUN)
 CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCCompiler.cmake.in 
                ${CMAKE_BINARY_DIR}/CMakeCCompiler.cmake IMMEDIATE)
 MARK_AS_ADVANCED(CMAKE_AR)
+SET(CMAKE_C_COMPILER_ENV_VAR "CC")

Modules/CMakeDetermineCXXCompiler.cmake

@@ -60,6 +60,4 @@ ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX_RUN)
 CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in 
                ${CMAKE_BINARY_DIR}/CMakeCXXCompiler.cmake IMMEDIATE)
 
-
-   
-      
+SET(CMAKE_CXX_COMPILER_ENV_VAR "CXX")

Modules/CMakeDetermineFortranCompiler.cmake

@@ -5,38 +5,55 @@
 # the cmake variable CMAKE_GENERATOR_CC which can be defined by a generator
 # as a default compiler
 
-IF(NOT CMAKE_FORTRAN_COMPILER)
+IF(NOT CMAKE_Fortran_COMPILER)
   # prefer the environment variable CC
   IF($ENV{FC} MATCHES ".+")
-    GET_FILENAME_COMPONENT(CMAKE_FORTRAN_COMPILER_INIT $ENV{FC} PROGRAM PROGRAM_ARGS CMAKE_FORTRAN_FLAGS_ENV_INIT)
-    IF(EXISTS ${CMAKE_FORTRAN_COMPILER_INIT})
-    ELSE(EXISTS ${CMAKE_FORTRAN_COMPILER_INIT})
+    GET_FILENAME_COMPONENT(CMAKE_Fortran_COMPILER_INIT $ENV{FC} PROGRAM PROGRAM_ARGS CMAKE_Fortran_FLAGS_ENV_INIT)
+    IF(EXISTS ${CMAKE_Fortran_COMPILER_INIT})
+    ELSE(EXISTS ${CMAKE_Fortran_COMPILER_INIT})
       MESSAGE(FATAL_ERROR "Could not find compiler set in environment variable FC:\n$ENV{FC}.") 
-    ENDIF(EXISTS ${CMAKE_FORTRAN_COMPILER_INIT})
+    ENDIF(EXISTS ${CMAKE_Fortran_COMPILER_INIT})
   ENDIF($ENV{FC} MATCHES ".+")
 
   # next try prefer the compiler specified by the generator
   IF(CMAKE_GENERATOR_FC) 
-    IF(NOT CMAKE_FORTRAN_COMPILER_INIT)
-      SET(CMAKE_FORTRAN_COMPILER_INIT ${CMAKE_GENERATOR_FC})
-    ENDIF(NOT CMAKE_FORTRAN_COMPILER_INIT)
+    IF(NOT CMAKE_Fortran_COMPILER_INIT)
+      SET(CMAKE_Fortran_COMPILER_INIT ${CMAKE_GENERATOR_FC})
+    ENDIF(NOT CMAKE_Fortran_COMPILER_INIT)
   ENDIF(CMAKE_GENERATOR_FC)
 
 
   # if no compiler has been specified yet, then look for one
-  IF(NOT CMAKE_FORTRAN_COMPILER_INIT)
-  # if not in the envionment then search for the compiler in the path
-    SET(CMAKE_FORTRAN_COMPILER_LIST g77 ifort f77 f90 epcf90 efc ecc)  
-    FIND_PROGRAM(CMAKE_FORTRAN_COMPILER_FULLPATH NAMES ${CMAKE_FORTRAN_COMPILER_LIST} )
-    GET_FILENAME_COMPONENT(CMAKE_FORTRAN_COMPILER_INIT
-                           ${CMAKE_FORTRAN_COMPILER_FULLPATH} NAME)
-    SET(CMAKE_FORTRAN_COMPILER_FULLPATH "${CMAKE_FORTRAN_COMPILER_FULLPATH}" CACHE INTERNAL "full path to the compiler cmake found")
-  ENDIF(NOT CMAKE_FORTRAN_COMPILER_INIT)
+  IF(NOT CMAKE_Fortran_COMPILER_INIT)
+  # if not in the envionment then search for the compiler in the path# Known compilers:
+  #  f77/f90/f95: generic compiler names
+  #  g77: GNU Fortran 77 compiler
+  #  gfortran: putative GNU Fortran 95+ compiler (in progress)
+  #  fort77: native F77 compiler under HP-UX (and some older Crays)
+  #  frt: Fujitsu F77 compiler
+  #  pgf77/pgf90/pgf95: Portland Group F77/F90/F95 compilers
+  #  xlf/xlf90/xlf95: IBM (AIX) F77/F90/F95 compilers
+  #  lf95: Lahey-Fujitsu F95 compiler
+  #  fl32: Microsoft Fortran 77 "PowerStation" compiler
+  #  af77: Apogee F77 compiler for Intergraph hardware running CLIX
+  #  epcf90: "Edinburgh Portable Compiler" F90
+  #  fort: Compaq (now HP) Fortran 90/95 compiler for Tru64 and Linux/Alpha
+  #  ifc: Intel Fortran 95 compiler for Linux/x86
+  #  efc: Intel Fortran 95 compiler for IA64
+  #  the order is 95 or newer compilers first, then 90, then 77 or older compilers, gnu is always last in the group,
+  #  so if you paid for a compiler it is picked by default
+    SET(CMAKE_Fortran_COMPILER_LIST ifort ifc efc f95 pgf95  lf95 xlf95 fort gfortran f90  pgf90   xlf90   epcf90 
+        f77  fort77 frt pgf77  xlf  fl32 af77 g77  )  
+    FIND_PROGRAM(CMAKE_Fortran_COMPILER_FULLPATH NAMES ${CMAKE_Fortran_COMPILER_LIST} )
+    GET_FILENAME_COMPONENT(CMAKE_Fortran_COMPILER_INIT
+                           ${CMAKE_Fortran_COMPILER_FULLPATH} NAME)
+    SET(CMAKE_Fortran_COMPILER_FULLPATH "${CMAKE_Fortran_COMPILER_FULLPATH}" CACHE INTERNAL "full path to the compiler cmake found")
+  ENDIF(NOT CMAKE_Fortran_COMPILER_INIT)
 
-  SET(CMAKE_FORTRAN_COMPILER ${CMAKE_FORTRAN_COMPILER_INIT} CACHE STRING "Fortran compiler")
-ENDIF(NOT CMAKE_FORTRAN_COMPILER)
+  SET(CMAKE_Fortran_COMPILER ${CMAKE_Fortran_COMPILER_INIT} CACHE STRING "Fortran compiler")
+ENDIF(NOT CMAKE_Fortran_COMPILER)
 
-MARK_AS_ADVANCED(CMAKE_FORTRAN_COMPILER)  
+MARK_AS_ADVANCED(CMAKE_Fortran_COMPILER)  
 
 FIND_PROGRAM(CMAKE_AR NAMES ar )
 
@@ -49,12 +66,12 @@ MARK_AS_ADVANCED(CMAKE_RANLIB)
 IF(NOT CMAKE_COMPILER_IS_GNUG77_RUN)
   # test to see if the Fortran compiler is gnu
   
-  IF(CMAKE_FORTRAN_FLAGS)
-    SET(CMAKE_BOOT_FORTRAN_FLAGS ${CMAKE_FORTRAN_FLAGS})
-  ELSE(CMAKE_FORTRAN_FLAGS)
-    SET(CMAKE_BOOT_FORTRAN_FLAGS $ENV{FFLAGS})
-  ENDIF(CMAKE_FORTRAN_FLAGS)
-  EXEC_PROGRAM(${CMAKE_FORTRAN_COMPILER} ARGS ${CMAKE_BOOT_FORTRAN_FLAGS} -E "\"${CMAKE_ROOT}/Modules/CMakeTestGNU.c\"" OUTPUT_VARIABLE CMAKE_COMPILER_OUTPUT RETURN_VALUE CMAKE_COMPILER_RETURN)
+  IF(CMAKE_Fortran_FLAGS)
+    SET(CMAKE_BOOT_Fortran_FLAGS ${CMAKE_Fortran_FLAGS})
+  ELSE(CMAKE_Fortran_FLAGS)
+    SET(CMAKE_BOOT_Fortran_FLAGS $ENV{FFLAGS})
+  ENDIF(CMAKE_Fortran_FLAGS)
+  EXEC_PROGRAM(${CMAKE_Fortran_COMPILER} ARGS ${CMAKE_BOOT_Fortran_FLAGS} -E "\"${CMAKE_ROOT}/Modules/CMakeTestGNU.c\"" OUTPUT_VARIABLE CMAKE_COMPILER_OUTPUT RETURN_VALUE CMAKE_COMPILER_RETURN)
   SET(CMAKE_COMPILER_IS_GNUG77_RUN 1)
   IF(NOT CMAKE_COMPILER_RETURN)
     IF("${CMAKE_COMPILER_OUTPUT}" MATCHES ".*THIS_IS_GNU.*" )
@@ -81,3 +98,4 @@ ENDIF(NOT CMAKE_COMPILER_IS_GNUG77_RUN)
 CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in 
                ${CMAKE_BINARY_DIR}/CMakeFortranCompiler.cmake IMMEDIATE)
 MARK_AS_ADVANCED(CMAKE_AR)
+SET(CMAKE_Fortran_COMPILER_ENV_VAR "FC")

Modules/CMakeDetermineJavaCompiler.cmake

@@ -73,3 +73,4 @@ MARK_AS_ADVANCED(CMAKE_JAVA_COMPILER)
 CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeJavaCompiler.cmake.in 
                ${CMAKE_BINARY_DIR}/CMakeJavaCompiler.cmake IMMEDIATE @ONLY)
 MARK_AS_ADVANCED(CMAKE_AR CMAKE_JAVA_COMPILER_FULLPATH)
+SET(CMAKE_JAVA_COMPILER_ENV_VAR "JC")

Modules/CMakeFortranCompiler.cmake.in

-SET(CMAKE_FORTRAN_COMPILER "@CMAKE_FORTRAN_COMPILER@")
+SET(CMAKE_Fortran_COMPILER "@CMAKE_Fortran_COMPILER@")
 SET(CMAKE_AR "@CMAKE_AR@")
 SET(CMAKE_RANLIB "@CMAKE_RANLIB@")
 SET(CMAKE_COMPILER_IS_GNUCC @CMAKE_COMPILER_IS_GNUCC@)
-SET(CMAKE_FORTRAN_COMPILER_LOADED 1)
+SET(CMAKE_Fortran_COMPILER_LOADED 1)
 SET(CMAKE_COMPILER_IS_MINGW @CMAKE_COMPILER_IS_MINGW@)
 SET(CMAKE_COMPILER_IS_CYGWIN @CMAKE_COMPILER_IS_CYGWIN@)
 IF(CMAKE_COMPILER_IS_CYGWIN)

Modules/CMakeFortranInformation.cmake

+# This file sets the basic flags for the Fortran language in CMake.
+# It also loads the available platform file for the system-compiler
+# if it exists.
+
+GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_Fortran_COMPILER} NAME_WE)
+# since the gnu compiler has several names force g++
+IF(CMAKE_COMPILER_IS_GNUG77)
+  SET(CMAKE_BASE_NAME g77)
+ENDIF(CMAKE_COMPILER_IS_GNUG77)
+SET(CMAKE_SYSTEM_AND_Fortran_COMPILER_INFO_FILE
+  ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}.cmake)
+INCLUDE(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL)
+
+
+# Create a set of shared library variable specific to Fortran
+# For 90% of the systems, these are the same flags as the C versions
+# so if these are not set just copy the flags from the c version
+IF(NOT CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS)
+  SET(CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
+ENDIF(NOT CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS)
+
+IF(NOT CMAKE_SHARED_LIBRARY_Fortran_FLAGS)
+  SET(CMAKE_SHARED_LIBRARY_Fortran_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
+ENDIF(NOT CMAKE_SHARED_LIBRARY_Fortran_FLAGS)
+
+IF(NOT CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS)
+  SET(CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS ${CMAKE_SHARED_LIBRARY_LINK_FLAGS})
+ENDIF(NOT CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS)
+
+IF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG)
+  SET(CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_FLAG}) 
+ENDIF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG)
+
+IF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG_SEP)