kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ENH: unify EnableLanguage across all generators

This commit is contained in:
Bill Hoffman 2002-12-05 13:44:11 -05:00
parent 8d20322160
commit 96189f79d5
22 changed files with 406 additions and 329 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
Modules/CMakeBackwardCompatibilityC.cmake
View File

@ -1,46 +1,56 @@
# Nothing here yet # Nothing here yet
IF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
INCLUDE(${CMAKE_ROOT}/Modules/CMakeVS7BackwardCompatibility.cmake)
SET(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
IF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
INCLUDE(${CMAKE_ROOT}/Modules/CMakeVS6BackwardCompatibility.cmake)
SET(CMAKE_SKIP_COMPATIBILITY_TESTS 1)
ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
INCLUDE (${CMAKE_ROOT}/Modules/CheckSizeOf.cmake) IF(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
CHECK_TYPE_SIZE(int CMAKE_SIZEOF_INT) INCLUDE (${CMAKE_ROOT}/Modules/CheckSizeOf.cmake)
CHECK_TYPE_SIZE(long CMAKE_SIZEOF_LONG) CHECK_TYPE_SIZE(int CMAKE_SIZEOF_INT)
CHECK_TYPE_SIZE("void*" CMAKE_SIZEOF_VOID_P) CHECK_TYPE_SIZE(long CMAKE_SIZEOF_LONG)
CHECK_TYPE_SIZE(char CMAKE_SIZEOF_CHAR) CHECK_TYPE_SIZE("void*" CMAKE_SIZEOF_VOID_P)
CHECK_TYPE_SIZE(short CMAKE_SIZEOF_SHORT) CHECK_TYPE_SIZE(char CMAKE_SIZEOF_CHAR)
CHECK_TYPE_SIZE(float CMAKE_SIZEOF_FLOAT) CHECK_TYPE_SIZE(short CMAKE_SIZEOF_SHORT)
CHECK_TYPE_SIZE(double CMAKE_SIZEOF_DOUBLE) CHECK_TYPE_SIZE(float CMAKE_SIZEOF_FLOAT)
CHECK_TYPE_SIZE(double CMAKE_SIZEOF_DOUBLE)
INCLUDE (${CMAKE_ROOT}/Modules/CheckFunctionExists.cmake) INCLUDE (${CMAKE_ROOT}/Modules/CheckFunctionExists.cmake)
CHECK_FUNCTION_EXISTS(connect CMAKE_HAVE_CONNECT) CHECK_FUNCTION_EXISTS(connect CMAKE_HAVE_CONNECT)
CHECK_FUNCTION_EXISTS(remove CMAKE_HAVE_REMOVE) CHECK_FUNCTION_EXISTS(remove CMAKE_HAVE_REMOVE)
INCLUDE (${CMAKE_ROOT}/Modules/CheckLibraryExists.cmake) INCLUDE (${CMAKE_ROOT}/Modules/CheckLibraryExists.cmake)
CHECK_LIBRARY_EXISTS("ipc" "shmat" "" CMAKE_HAVE_GETHOSTBYNAME) CHECK_LIBRARY_EXISTS("ipc" "shmat" "" CMAKE_HAVE_GETHOSTBYNAME)
INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake) INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
CHECK_INCLUDE_FILE("limits.h" CMAKE_HAVE_LIMITS_H) CHECK_INCLUDE_FILE("limits.h" CMAKE_HAVE_LIMITS_H)
CHECK_INCLUDE_FILE("unistd.h" CMAKE_HAVE_UNISTD_H) CHECK_INCLUDE_FILE("unistd.h" CMAKE_HAVE_UNISTD_H)
CHECK_INCLUDE_FILE("sys/prctl.h" CMAKE_HAVE_SYS_PRCTL_H) CHECK_INCLUDE_FILE("sys/prctl.h" CMAKE_HAVE_SYS_PRCTL_H)
CHECK_INCLUDE_FILE("pthread.h" CMAKE_HAVE_PTHREAD_H) CHECK_INCLUDE_FILE("pthread.h" CMAKE_HAVE_PTHREAD_H)
INCLUDE (${CMAKE_ROOT}/Modules/TestBigEndian.cmake) INCLUDE (${CMAKE_ROOT}/Modules/TestBigEndian.cmake)
TEST_BIG_ENDIAN(CMAKE_WORDS_BIGENDIAN) TEST_BIG_ENDIAN(CMAKE_WORDS_BIGENDIAN)
INCLUDE (${CMAKE_ROOT}/Modules/FindX11.cmake) INCLUDE (${CMAKE_ROOT}/Modules/FindX11.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/FindThreads.cmake) INCLUDE (${CMAKE_ROOT}/Modules/FindThreads.cmake)
SET (CMAKE_THREAD_LIBS "${CMAKE_THREAD_LIBS_INIT}" CACHE STRING SET (CMAKE_THREAD_LIBS "${CMAKE_THREAD_LIBS_INIT}" CACHE STRING
"Thread library used.") "Thread library used.")
SET (CMAKE_USE_PTHREADS "${CMAKE_USE_PTHREADS_INIT}" CACHE BOOL SET (CMAKE_USE_PTHREADS "${CMAKE_USE_PTHREADS_INIT}" CACHE BOOL
"Use the pthreads library.") "Use the pthreads library.")
SET (CMAKE_USE_WIN32_THREADS "${CMAKE_USE_WIN32_THREADS_INIT}" CACHE BOOL SET (CMAKE_USE_WIN32_THREADS "${CMAKE_USE_WIN32_THREADS_INIT}" CACHE BOOL
"Use the win32 thread library.") "Use the win32 thread library.")
SET (CMAKE_HP_PTHREADS ${CMAKE_HP_PTHREADS_INIT} CACHE BOOL SET (CMAKE_HP_PTHREADS ${CMAKE_HP_PTHREADS_INIT} CACHE BOOL
"Use HP pthreads.") "Use HP pthreads.")
SET (CMAKE_USE_SPROC ${CMAKE_USE_SPROC_INIT} CACHE BOOL SET (CMAKE_USE_SPROC ${CMAKE_USE_SPROC_INIT} CACHE BOOL
"Use sproc libs.") "Use sproc libs.")
ENDIF(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
MARK_AS_ADVANCED( MARK_AS_ADVANCED(
CMAKE_THREAD_LIBS CMAKE_THREAD_LIBS

65
Modules/CMakeBackwardCompatibilityCXX.cmake
View File

@ -1,34 +1,35 @@
# #
IF(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
# check for some ANSI flags in the CXX compiler if it is not gnu
IF(NOT CMAKE_COMPILER_IS_GNUCXX)
INCLUDE(${CMAKE_ROOT}/Modules/TestCXXAcceptsFlag.cmake)
SET(CMAKE_TRY_ANSI_CXX_FLAGS "")
IF(CMAKE_SYSTEM MATCHES "IRIX.*")
SET(CMAKE_TRY_ANSI_CXX_FLAGS "-LANG:std")
ENDIF(CMAKE_SYSTEM MATCHES "IRIX.*")
IF(CMAKE_SYSTEM MATCHES "OSF.*")
SET(CMAKE_TRY_ANSI_CXX_FLAGS "-std strict_ansi -nopure_cname")
ENDIF(CMAKE_SYSTEM MATCHES "OSF.*")
# if CMAKE_TRY_ANSI_CXX_FLAGS has something in it, see
# if the compiler accepts it
IF( CMAKE_TRY_ANSI_CXX_FLAGS MATCHES ".+")
CHECK_CXX_ACCEPTS_FLAG(${CMAKE_TRY_ANSI_CXX_FLAGS} CMAKE_CXX_ACCEPTS_FLAGS)
# if the compiler liked the flag then set CMAKE_ANSI_CXXFLAGS
# to the flag
IF(CMAKE_CXX_ACCEPTS_FLAGS)
SET(CMAKE_ANSI_CXXFLAGS ${CMAKE_TRY_ANSI_CXX_FLAGS} CACHE INTERNAL
"What flags are required by the c++ compiler to make it ansi." )
ENDIF(CMAKE_CXX_ACCEPTS_FLAGS)
ENDIF( CMAKE_TRY_ANSI_CXX_FLAGS MATCHES ".+")
ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
# check for some ANSI flags in the CXX compiler if it is not gnu INCLUDE(${CMAKE_ROOT}/Modules/TestForANSIStreamHeaders.cmake)
IF(NOT CMAKE_COMPILER_IS_GNUCXX) INCLUDE(${CMAKE_ROOT}/Modules/CheckIncludeFileCXX.cmake)
INCLUDE(${CMAKE_ROOT}/Modules/TestCXXAcceptsFlag.cmake) INCLUDE(${CMAKE_ROOT}/Modules/TestForSTDNamespace.cmake)
SET(CMAKE_TRY_ANSI_CXX_FLAGS "") INCLUDE(${CMAKE_ROOT}/Modules/TestForANSIForScope.cmake)
IF(CMAKE_SYSTEM MATCHES "IRIX.*") CHECK_INCLUDE_FILE_CXX("sstream" CMAKE_HAS_ANSI_STRING_STREAM)
SET(CMAKE_TRY_ANSI_CXX_FLAGS "-LANG:std") IF(NOT CMAKE_HAS_ANSI_STRING_STREAM)
ENDIF(CMAKE_SYSTEM MATCHES "IRIX.*") SET( CMAKE_NO_ANSI_STRING_STREAM 1 CACHE INTERNAL
IF(CMAKE_SYSTEM MATCHES "OSF.*") "Does the compiler support sstream or stringstream.")
SET(CMAKE_TRY_ANSI_CXX_FLAGS "-std strict_ansi -nopure_cname") ENDIF(NOT CMAKE_HAS_ANSI_STRING_STREAM)
ENDIF(CMAKE_SYSTEM MATCHES "OSF.*") ENDIF(NOT CMAKE_SKIP_COMPATIBILITY_TESTS)
# if CMAKE_TRY_ANSI_CXX_FLAGS has something in it, see
# if the compiler accepts it
IF( CMAKE_TRY_ANSI_CXX_FLAGS MATCHES ".+")
CHECK_CXX_ACCEPTS_FLAG(${CMAKE_TRY_ANSI_CXX_FLAGS} CMAKE_CXX_ACCEPTS_FLAGS)
# if the compiler liked the flag then set CMAKE_ANSI_CXXFLAGS
# to the flag
IF(CMAKE_CXX_ACCEPTS_FLAGS)
SET(CMAKE_ANSI_CXXFLAGS ${CMAKE_TRY_ANSI_CXX_FLAGS} CACHE INTERNAL
"What flags are required by the c++ compiler to make it ansi." )
ENDIF(CMAKE_CXX_ACCEPTS_FLAGS)
ENDIF( CMAKE_TRY_ANSI_CXX_FLAGS MATCHES ".+")
ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
INCLUDE(${CMAKE_ROOT}/Modules/TestForANSIStreamHeaders.cmake)
INCLUDE(${CMAKE_ROOT}/Modules/CheckIncludeFileCXX.cmake)
INCLUDE(${CMAKE_ROOT}/Modules/TestForSTDNamespace.cmake)
INCLUDE(${CMAKE_ROOT}/Modules/TestForANSIForScope.cmake)
CHECK_INCLUDE_FILE_CXX("sstream" CMAKE_HAS_ANSI_STRING_STREAM)
IF(NOT CMAKE_HAS_ANSI_STRING_STREAM)
SET( CMAKE_NO_ANSI_STRING_STREAM 1 CACHE INTERNAL
"Does the compiler support sstream or stringstream.")
ENDIF(NOT CMAKE_HAS_ANSI_STRING_STREAM)

112
Modules/CMakeSystemSpecificInformation.cmake
View File

@ -144,10 +144,6 @@ IF(CMAKE_USER_MAKE_RULES_OVERRIDE)
ENDIF(CMAKE_USER_MAKE_RULES_OVERRIDE) ENDIF(CMAKE_USER_MAKE_RULES_OVERRIDE)
SET(CMAKE_VERBOSE_MAKEFILE FALSE CACHE BOOL "If this value is on, makefiles will be generated without the .SILENT directive, and all commands will be echoed to the console during the make. This is useful for debugging only.") SET(CMAKE_VERBOSE_MAKEFILE FALSE CACHE BOOL "If this value is on, makefiles will be generated without the .SILENT directive, and all commands will be echoed to the console during the make. This is useful for debugging only.")
# default build type is none
SET (CMAKE_BUILD_TYPE "" CACHE STRING
"Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
SET (CMAKE_INSTALL_PREFIX /usr/local CACHE PATH SET (CMAKE_INSTALL_PREFIX /usr/local CACHE PATH
"Install path prefix, prepended onto install directories.") "Install path prefix, prepended onto install directories.")
@ -158,77 +154,89 @@ SET (CMAKE_INSTALL_PREFIX /usr/local CACHE PATH
# and you can set these flags in the cmake cache # 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 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.") "Flags used by the compiler during all build types.")
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.")
SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS_ENV_INIT} $ENV{CFLAGS} ${CMAKE_C_FLAGS_INIT}" CACHE STRING SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS_ENV_INIT} $ENV{CFLAGS} ${CMAKE_C_FLAGS_INIT}" CACHE STRING
"Flags for C compiler.") "Flags for C compiler.")
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.")
SET (CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS_INIT} SET (CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS_INIT}
CACHE STRING "Flags used by the linker.") CACHE STRING "Flags used by the linker.")
SET (CMAKE_EXE_LINKER_FLAGS_DEBUG ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT} CACHE STRING 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_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.")
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.")
SET (CMAKE_EXE_LINKER_FLAGS_DEBUG ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT} CACHE STRING
"Flags used by the linker during debug builds.") "Flags used by the linker during debug builds.")
SET (CMAKE_EXE_LINKER_FLAGS_MINSIZEREL ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL_INIT} CACHE STRING SET (CMAKE_EXE_LINKER_FLAGS_MINSIZEREL ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL_INIT} CACHE STRING
"Flags used by the linker during release minsize builds.") "Flags used by the linker during release minsize builds.")
SET (CMAKE_EXE_LINKER_FLAGS_RELEASE ${CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT} "" CACHE STRING SET (CMAKE_EXE_LINKER_FLAGS_RELEASE ${CMAKE_EXE_LINKER_FLAGS_RELEASE_INIT} "" CACHE STRING
"Flags used by the linker during release builds.") "Flags used by the linker during release builds.")
SET (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO SET (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT} CACHE STRING
"Flags used by the linker during Release with Debug Info builds.") "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 # shared linker flags
SET (CMAKE_SHARED_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS_INIT} SET (CMAKE_SHARED_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS_INIT}
CACHE STRING "Flags used by the linker.") CACHE STRING "Flags used by the linker.")
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.")
# module linker flags # module linker flags
SET (CMAKE_MODULE_LINKER_FLAGS ${CMAKE_MODULE_LINKER_FLAGS_INIT} SET (CMAKE_MODULE_LINKER_FLAGS ${CMAKE_MODULE_LINKER_FLAGS_INIT}
CACHE STRING "Flags used by the linker.") CACHE STRING "Flags used by the linker.")
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.")
SET(CMAKE_BUILD_TOOL ${CMAKE_MAKE_PROGRAM} CACHE INTERNAL SET(CMAKE_BUILD_TOOL ${CMAKE_MAKE_PROGRAM} CACHE INTERNAL
"What is the target build tool cmake is generating for.") "What is the target build tool cmake is generating for.")

10
Modules/CMakeVS6BackwardCompatibility.cmake Normal file
View File

@ -0,0 +1,10 @@
# hard code these for fast backwards compatibility tests
SET (CMAKE_SIZEOF_INT 4 CACHE INTERNAL "Size of int data type")
SET (CMAKE_SIZEOF_LONG 4 CACHE INTERNAL "Size of long data type")
SET (CMAKE_SIZEOF_VOID_P 4 CACHE INTERNAL "Size of void* data type")
SET (CMAKE_SIZEOF_CHAR 1 CACHE INTERNAL "Size of char data type")
SET (CMAKE_SIZEOF_SHORT 2 CACHE INTERNAL "Size of short data type")
SET (CMAKE_SIZEOF_FLOAT 4 CACHE INTERNAL "Size of float data type")
SET (CMAKE_SIZEOF_DOUBLE 8 CACHE INTERNAL "Size of double data type")
SET (CMAKE_NO_ANSI_FOR_SCOPE 1 CACHE INTERNAL
"Does the compiler support ansi for scope.")

9
Modules/CMakeVS6FindMake.cmake Normal file
View File

@ -0,0 +1,9 @@
FIND_PROGRAM(CMAKE_MAKE_PROGRAM
NAMES msdev
PATHS
[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\6.0\\Setup;VsCommonDir]/MSDev98/Bin/msdev
"c:/Program Files/Microsoft Visual Studio/Common/MSDev98/Bin"
"c:/Program Files/Microsoft Visual Studio/Common/MSDev98/Bin"
"/Program Files/Microsoft Visual Studio/Common/MSDev98/Bin"
)
MARK_AS_ADVANCED(CMAKE_MAKE_PROGRAM)

10
Modules/CMakeVS7BackwardCompatibility.cmake Normal file
View File

@ -0,0 +1,10 @@
# hard code these for fast backwards compatibility tests
SET (CMAKE_SIZEOF_INT 4 CACHE INTERNAL "Size of int data type")
SET (CMAKE_SIZEOF_LONG 4 CACHE INTERNAL "Size of long data type")
SET (CMAKE_SIZEOF_VOID_P 4 CACHE INTERNAL "Size of void* data type")
SET (CMAKE_SIZEOF_CHAR 1 CACHE INTERNAL "Size of char data type")
SET (CMAKE_SIZEOF_SHORT 2 CACHE INTERNAL "Size of short data type")
SET (CMAKE_SIZEOF_FLOAT 4 CACHE INTERNAL "Size of float data type")
SET (CMAKE_SIZEOF_DOUBLE 8 CACHE INTERNAL "Size of double data type")
SET (CMAKE_NO_ANSI_FOR_SCOPE 0 CACHE INTERNAL
"Does the compiler support ansi for scope.")

9
Modules/CMakeVS7FindMake.cmake Normal file
View File

@ -0,0 +1,9 @@
FIND_PROGRAM(CMAKE_MAKE_PROGRAM
NAMES devenv
PATHS
[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\7.0\\Setup\\VS;EnvironmentDirectory]
"c:/Program Files/Microsoft Visual Studio .NET/Common7/IDE"
"c:/Program Files/Microsoft Visual Studio.NET/Common7/IDE"
"/Program Files/Microsoft Visual Studio .NET/Common7/IDE/"
)
MARK_AS_ADVANCED(CMAKE_MAKE_PROGRAM)

4
Modules/Dart.cmake
View File

@ -107,7 +107,7 @@ IF(BUILD_TESTING)
# for non IDE based builds nmake and make # for non IDE based builds nmake and make
# add all these extra targets # add all these extra targets
IF(${CMAKE_BUILD_TOOL} MATCHES make) IF(${CMAKE_MAKE_PROGRAM} MATCHES make)
# Make targets for Experimental builds # Make targets for Experimental builds
ADD_CUSTOM_TARGET(ExperimentalStart ADD_CUSTOM_TARGET(ExperimentalStart
${TCL_TCLSH} ${DART_ROOT}/Source/Client/DashboardManager.tcl ${PROJECT_BINARY_DIR}/DartConfiguration.tcl Experimental Start) ${TCL_TCLSH} ${DART_ROOT}/Source/Client/DashboardManager.tcl ${PROJECT_BINARY_DIR}/DartConfiguration.tcl Experimental Start)
@ -161,7 +161,7 @@ IF(BUILD_TESTING)
${TCL_TCLSH} ${DART_ROOT}/Source/Client/DashboardManager.tcl ${PROJECT_BINARY_DIR}/DartConfiguration.tcl Nightly DashboardStart) ${TCL_TCLSH} ${DART_ROOT}/Source/Client/DashboardManager.tcl ${PROJECT_BINARY_DIR}/DartConfiguration.tcl Nightly DashboardStart)
ADD_CUSTOM_TARGET(NightlyDashboardEnd ADD_CUSTOM_TARGET(NightlyDashboardEnd
${TCL_TCLSH} ${DART_ROOT}/Source/Client/DashboardManager.tcl ${PROJECT_BINARY_DIR}/DartConfiguration.tcl Nightly DashboardEnd) ${TCL_TCLSH} ${DART_ROOT}/Source/Client/DashboardManager.tcl ${PROJECT_BINARY_DIR}/DartConfiguration.tcl Nightly DashboardEnd)
ENDIF (${CMAKE_BUILD_TOOL} MATCHES make) ENDIF (${CMAKE_MAKE_PROGRAM} MATCHES make)
ELSE(TCL_TCLSH) ELSE(TCL_TCLSH)
MESSAGE("Could not find TCL_TCLSH, disabling testing." "Error") MESSAGE("Could not find TCL_TCLSH, disabling testing." "Error")

21
Modules/Platform/Windows-cl.cmake
View File

@ -44,11 +44,9 @@ SET(CMAKE_COMPILE_RESOURCE "rc <FLAGS> /fo<OBJECT> <SOURCE>")
SET(CMAKE_CXX_LINK_EXECUTABLE SET(CMAKE_CXX_LINK_EXECUTABLE
"<CMAKE_CXX_COMPILER> /nologo ${CMAKE_START_TEMP_FILE} <FLAGS> <OBJECTS> /Fe<TARGET> -link <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}") "<CMAKE_CXX_COMPILER> /nologo ${CMAKE_START_TEMP_FILE} <FLAGS> <OBJECTS> /Fe<TARGET> -link <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
SET (CMAKE_BUILD_TYPE Debug CACHE STRING
"Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel.")
SET(CMAKE_CREATE_WIN32_EXE /subsystem:windows) SET(CMAKE_CREATE_WIN32_EXE /subsystem:windows)
# default to Debug builds
SET(CMAKE_BUILD_TYPE_INIT Debug)
SET (CMAKE_CXX_FLAGS_INIT "/W3 /Zm1000 /GX /GR") SET (CMAKE_CXX_FLAGS_INIT "/W3 /Zm1000 /GX /GR")
SET (CMAKE_CXX_FLAGS_DEBUG_INIT "/MDd /Zi /Od /GZ") SET (CMAKE_CXX_FLAGS_DEBUG_INIT "/MDd /Zi /Od /GZ")
SET (CMAKE_CXX_FLAGS_MINSIZEREL_INIT "/MD /O1") SET (CMAKE_CXX_FLAGS_MINSIZEREL_INIT "/MD /O1")
@ -65,6 +63,21 @@ SET (CMAKE_STANDARD_LIBRARIES "kernel32.lib user32.lib gdi32.lib winspool.lib co
"Libraries linked by defalut with all applications.") "Libraries linked by defalut with all applications.")
MARK_AS_ADVANCED(CMAKE_STANDARD_LIBRARIES) MARK_AS_ADVANCED(CMAKE_STANDARD_LIBRARIES)
IF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
SET (CMAKE_NO_BUILD_TYPE 1)
ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
IF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
SET (CMAKE_CONFIGURATION_TYPES "Debug Release MinSizeRel RelWithDebInfo" CACHE STRING
"Space separated list of supported configuration types, only supports Debug, Release, MinSizeRel, and RelWithDebInfo, anything else will be ignored.")
SET (CMAKE_CXX_WARNING_LEVEL "3" CACHE STRING
"Size of stack for programs.")
SET (CMAKE_CXX_STACK_SIZE "10000000" CACHE STRING
"Size of stack for programs.")
MARK_AS_ADVANCED(CMAKE_CONFIGURATION_TYPES CMAKE_CXX_STACK_SIZE CMAKE_CXX_WARNING_LEVEL)
SET (CMAKE_NOT_USING_CONFIG_FLAGS 1)
ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 7")
# executable linker flags # executable linker flags
SET (CMAKE_LINK_DEF_FILE_FLAG "/DEF:") SET (CMAKE_LINK_DEF_FILE_FLAG "/DEF:")
SET (CMAKE_EXE_LINKER_FLAGS_INIT "/STACK:10000000 /machine:I386 /INCREMENTAL:YES") SET (CMAKE_EXE_LINKER_FLAGS_INIT "/STACK:10000000 /machine:I386 /INCREMENTAL:YES")

11
Source/cmGlobalBorlandMakefileGenerator.cxx
View File

@ -18,6 +18,10 @@
#include "cmLocalUnixMakefileGenerator.h" #include "cmLocalUnixMakefileGenerator.h"
#include "cmMakefile.h" #include "cmMakefile.h"
#include "cmake.h" #include "cmake.h"
cmGlobalBorlandMakefileGenerator::cmGlobalBorlandMakefileGenerator()
{
m_FindMakeProgramFile = "CMakeBorlandFindMake.cmake";
}
void cmGlobalBorlandMakefileGenerator::EnableLanguage(const char* l, void cmGlobalBorlandMakefileGenerator::EnableLanguage(const char* l,
cmMakefile *mf) cmMakefile *mf)
@ -40,13 +44,6 @@ void cmGlobalBorlandMakefileGenerator::EnableLanguage(const char* l,
mf->AddDefinition("BORLAND", "1"); mf->AddDefinition("BORLAND", "1");
mf->AddDefinition("CMAKE_GENERATOR_CC", "bcc32"); mf->AddDefinition("CMAKE_GENERATOR_CC", "bcc32");
mf->AddDefinition("CMAKE_GENERATOR_CXX", "bcc32"); mf->AddDefinition("CMAKE_GENERATOR_CXX", "bcc32");
if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM")
|| cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
{
std::string setMakeProgram = mf->GetDefinition("CMAKE_ROOT");
setMakeProgram += "/Modules/CMakeBorlandFindMake.cmake";
mf->ReadListFile(0, setMakeProgram.c_str());
}
this->cmGlobalUnixMakefileGenerator::EnableLanguage(l, mf); this->cmGlobalUnixMakefileGenerator::EnableLanguage(l, mf);
} }

1
Source/cmGlobalBorlandMakefileGenerator.h
View File

@ -27,6 +27,7 @@
class cmGlobalBorlandMakefileGenerator : public cmGlobalNMakeMakefileGenerator class cmGlobalBorlandMakefileGenerator : public cmGlobalNMakeMakefileGenerator
{ {
public: public:
cmGlobalBorlandMakefileGenerator();
///! Get the name for the generator. ///! Get the name for the generator.
virtual const char* GetName() { virtual const char* GetName() {
return cmGlobalBorlandMakefileGenerator::GetActualName();} return cmGlobalBorlandMakefileGenerator::GetActualName();}

177
Source/cmGlobalGenerator.cxx
View File

@ -34,6 +34,155 @@ cmGlobalGenerator::~cmGlobalGenerator()
m_LocalGenerators.clear(); m_LocalGenerators.clear();
} }
void cmGlobalGenerator::EnableLanguage(const char* lang,
cmMakefile *mf)
{
if(m_FindMakeProgramFile.size() == 0)
{
cmSystemTools::Error(
"Generator implementation error, "
"all generators must specify m_FindMakeProgramFile");
}
std::string root = mf->GetDefinition("CMAKE_ROOT");
if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM")
|| cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
{
std::string setMakeProgram = root;
setMakeProgram += "/Modules/";
setMakeProgram += m_FindMakeProgramFile;
mf->ReadListFile(0, setMakeProgram.c_str());
}
if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM")
|| cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
{
cmSystemTools::Error("EnableLanguage was unable to find a CMAKE_MAKE_PROGRAM");
return;
}
std::string makeProgram = mf->GetDefinition("CMAKE_MAKE_PROGRAM");
if(makeProgram.find(' ') != makeProgram.npos)
{
cmSystemTools::GetShortPath(makeProgram.c_str(), makeProgram);
this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", makeProgram.c_str(),
"make program",
cmCacheManager::FILEPATH);
}
bool isLocal = m_CMakeInstance->GetLocal();
// if no lang specified use CXX
if(!lang )
{
lang = "CXX";
}
std::string rootBin = mf->GetHomeOutputDirectory();
if(m_ConfiguredFilesPath.size())
{
rootBin = m_ConfiguredFilesPath;
}
bool needCBackwards = false;
bool needCXXBackwards = false;
// check for a C compiler and configure it
if(!isLocal &&
!this->GetLanguageEnabled("C") &&
lang[0] == 'C')
{
if (m_CMakeInstance->GetIsInTryCompile())
{
cmSystemTools::Error("This should not have happen. "
"If you see this message, you are probably using a "
"broken CMakeLists.txt file or a problematic release of "
"CMake");
}
needCBackwards = true;
// Read the DetermineSystem file
std::string systemFile = root;
systemFile += "/Modules/CMakeDetermineSystem.cmake";
mf->ReadListFile(0, systemFile.c_str());
// read determine C compiler
std::string determineCFile = root;
determineCFile += "/Modules/CMakeDetermineCCompiler.cmake";
mf->ReadListFile(0,determineCFile.c_str());
this->SetLanguageEnabled("C");
}
// check for a CXX compiler and configure it
if(!isLocal &&
!this->GetLanguageEnabled("CXX") &&
strcmp(lang, "CXX") == 0)
{
needCXXBackwards = true;
std::string determineCFile = root;
determineCFile += "/Modules/CMakeDetermineCXXCompiler.cmake";
mf->ReadListFile(0,determineCFile.c_str());
this->SetLanguageEnabled("CXX");
}
std::string fpath = rootBin;
if(!mf->GetDefinition("CMAKE_SYSTEM_LOADED"))
{
fpath += "/CMakeSystem.cmake";
mf->ReadListFile(0,fpath.c_str());
}
// if C, then enable C
if(lang[0] == 'C' && !mf->GetDefinition("CMAKE_C_COMPILER_LOADED"))
{
fpath = rootBin;
fpath += "/CMakeCCompiler.cmake";
mf->ReadListFile(0,fpath.c_str());
}
if(strcmp(lang, "CXX") == 0 && !mf->GetDefinition("CMAKE_CXX_COMPILER_LOADED"))
{
fpath = rootBin;
fpath += "/CMakeCXXCompiler.cmake";
mf->ReadListFile(0,fpath.c_str());
}
if(!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INFORMATION_LOADED"))
{
fpath = root;
fpath += "/Modules/CMakeSystemSpecificInformation.cmake";
mf->ReadListFile(0,fpath.c_str());
}
if(!isLocal)
{
// At this point we should have enough info for a try compile
// which is used in the backward stuff
if(needCBackwards)
{
if (!m_CMakeInstance->GetIsInTryCompile())
{
// for old versions of CMake ListFiles
const char* versionValue
= mf->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
if (!versionValue || atof(versionValue) <= 1.4)
{
std::string ifpath = root + "/Modules/CMakeBackwardCompatibilityC.cmake";
mf->ReadListFile(0,ifpath.c_str());
}
}
}
if(needCXXBackwards)
{
if (!m_CMakeInstance->GetIsInTryCompile())
{
// for old versions of CMake ListFiles
const char* versionValue
= mf->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
if (!versionValue || atof(versionValue) <= 1.4)
{
std::string fpath = root + "/Modules/CMakeBackwardCompatibilityCXX.cmake";
mf->ReadListFile(0,fpath.c_str());
}
}
}
// if we are from the top, always define this
mf->AddDefinition("RUN_CONFIGURE", true);
}
}
void cmGlobalGenerator::SetLanguageEnabled(const char* l) void cmGlobalGenerator::SetLanguageEnabled(const char* l)
{ {
m_LanguageEnabled[l] = true; m_LanguageEnabled[l] = true;
@ -215,19 +364,23 @@ cmLocalGenerator *cmGlobalGenerator::CreateLocalGenerator()
void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen ) void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen )
{ {
// create a temp generator this->SetConfiguredFilesPath(
cmLocalGenerator *lg = this->CreateLocalGenerator(); gen->GetCMakeInstance()->GetHomeOutputDirectory());
lg->GetMakefile()->SetStartDirectory(m_CMakeInstance->GetStartDirectory()); const char* make =
lg->GetMakefile()->SetStartOutputDirectory(m_CMakeInstance->GetStartOutputDirectory()); gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
lg->GetMakefile()->MakeStartDirectoriesCurrent(); this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make,
"make program",
// for each existing language call enable Language cmCacheManager::FILEPATH);
std::map<cmStdString, bool>::const_iterator i = // if C, then enable C
gen->m_LanguageEnabled.begin(); if(gen->GetLanguageEnabled("C"))
for (;i != gen->m_LanguageEnabled.end(); ++i)
{ {
this->EnableLanguage(i->first.c_str(),lg->GetMakefile()); this->SetLanguageEnabled("C");
}
// if CXX
if(gen->GetLanguageEnabled("CXX"))
{
this->SetLanguageEnabled("CXX");
} }
delete lg;
} }

3
Source/cmGlobalGenerator.h
View File

@ -74,7 +74,7 @@ public:
* Try to determine system infomation such as shared library * Try to determine system infomation such as shared library
* extension, pthreads, byte order etc. * extension, pthreads, byte order etc.
*/ */
virtual void EnableLanguage(const char*, cmMakefile *) {}; virtual void EnableLanguage(const char*, cmMakefile *);
/** /**
* Try to determine system infomation, get it from another generator * Try to determine system infomation, get it from another generator
@ -99,6 +99,7 @@ public:
void SetConfiguredFilesPath(const char* s){m_ConfiguredFilesPath = s;} void SetConfiguredFilesPath(const char* s){m_ConfiguredFilesPath = s;}
protected: protected:
cmStdString m_FindMakeProgramFile;
cmStdString m_ConfiguredFilesPath; cmStdString m_ConfiguredFilesPath;
cmake *m_CMakeInstance; cmake *m_CMakeInstance;
std::vector<cmLocalGenerator *> m_LocalGenerators; std::vector<cmLocalGenerator *> m_LocalGenerators;

15
Source/cmGlobalNMakeMakefileGenerator.cxx
View File

@ -18,21 +18,18 @@
#include "cmLocalUnixMakefileGenerator.h" #include "cmLocalUnixMakefileGenerator.h"
#include "cmMakefile.h" #include "cmMakefile.h"
cmGlobalNMakeMakefileGenerator::cmGlobalNMakeMakefileGenerator()
{
m_FindMakeProgramFile = "CMakeNMakeFindMake.cmake";
}
void cmGlobalNMakeMakefileGenerator::EnableLanguage(const char* l, void cmGlobalNMakeMakefileGenerator::EnableLanguage(const char* l,
cmMakefile *mf) cmMakefile *mf)
{ {
// pick a default // pick a default
mf->AddDefinition("CMAKE_GENERATOR_CC", "cl"); mf->AddDefinition("CMAKE_GENERATOR_CC", "cl");
mf->AddDefinition("CMAKE_GENERATOR_CXX", "cl"); mf->AddDefinition("CMAKE_GENERATOR_CXX", "cl");
if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM")
|| cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
{
std::string setMakeProgram = mf->GetDefinition("CMAKE_ROOT");
setMakeProgram += "/Modules/CMakeNMakeFindMake.cmake";
mf->ReadListFile(0, setMakeProgram.c_str());
}
this->cmGlobalUnixMakefileGenerator::EnableLanguage(l, mf); this->cmGlobalUnixMakefileGenerator::EnableLanguage(l, mf);
} }

1
Source/cmGlobalNMakeMakefileGenerator.h
View File

@ -27,6 +27,7 @@
class cmGlobalNMakeMakefileGenerator : public cmGlobalUnixMakefileGenerator class cmGlobalNMakeMakefileGenerator : public cmGlobalUnixMakefileGenerator
{ {
public: public:
cmGlobalNMakeMakefileGenerator();
///! Get the name for the generator. ///! Get the name for the generator.
virtual const char* GetName() { virtual const char* GetName() {
return cmGlobalNMakeMakefileGenerator::GetActualName();} return cmGlobalNMakeMakefileGenerator::GetActualName();}

148
Source/cmGlobalUnixMakefileGenerator.cxx
View File

@ -20,130 +20,15 @@
#include "cmMakefile.h" #include "cmMakefile.h"
#include "cmake.h" #include "cmake.h"
cmGlobalUnixMakefileGenerator::cmGlobalUnixMakefileGenerator()
{
m_FindMakeProgramFile = "CMakeUnixFindMake.cmake";
}
void cmGlobalUnixMakefileGenerator::EnableLanguage(const char* lang, void cmGlobalUnixMakefileGenerator::EnableLanguage(const char* lang,
cmMakefile *mf) cmMakefile *mf)
{ {
if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM") this->cmGlobalGenerator::EnableLanguage(lang, mf);
|| cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM")))
{
std::string setMakeProgram = mf->GetDefinition("CMAKE_ROOT");
setMakeProgram += "/Modules/CMakeUnixFindMake.cmake";
mf->ReadListFile(0, setMakeProgram.c_str());
}
bool isLocal = m_CMakeInstance->GetLocal();
// if no lang specified use CXX
if(!lang )
{
lang = "CXX";
}
std::string root = mf->GetDefinition("CMAKE_ROOT");
std::string rootBin = mf->GetHomeOutputDirectory();
if(m_ConfiguredFilesPath.size())
{
rootBin = m_ConfiguredFilesPath;
}
bool needCBackwards = false;
bool needCXXBackwards = false;
// check for a C compiler and configure it
if(!isLocal &&
!this->GetLanguageEnabled("C") &&
lang[0] == 'C')
{
if (m_CMakeInstance->GetIsInTryCompile())
{
cmSystemTools::Error("This should not have happen. "
"If you see this message, you are probably using a "
"broken CMakeLists.txt file or a problematic release of "
"CMake");
}
needCBackwards = true;
// Read the DetermineSystem file
std::string systemFile = root;
systemFile += "/Modules/CMakeDetermineSystem.cmake";
mf->ReadListFile(0, systemFile.c_str());
// read determine C compiler
std::string determineCFile = root;
determineCFile += "/Modules/CMakeDetermineCCompiler.cmake";
mf->ReadListFile(0,determineCFile.c_str());
this->SetLanguageEnabled("C");
}
// check for a CXX compiler and configure it
if(!isLocal &&
!this->GetLanguageEnabled("CXX") &&
strcmp(lang, "CXX") == 0)
{
needCXXBackwards = true;
std::string determineCFile = root;
determineCFile += "/Modules/CMakeDetermineCXXCompiler.cmake";
mf->ReadListFile(0,determineCFile.c_str());
this->SetLanguageEnabled("CXX");
}
std::string fpath = rootBin;
if(!mf->GetDefinition("CMAKE_SYSTEM_LOADED"))
{
fpath += "/CMakeSystem.cmake";
mf->ReadListFile(0,fpath.c_str());
}
// if C, then enable C
if(lang[0] == 'C' && !mf->GetDefinition("CMAKE_C_COMPILER_LOADED"))
{
fpath = rootBin;
fpath += "/CMakeCCompiler.cmake";
mf->ReadListFile(0,fpath.c_str());
}
if(strcmp(lang, "CXX") == 0 && !mf->GetDefinition("CMAKE_CXX_COMPILER_LOADED"))
{
fpath = rootBin;
fpath += "/CMakeCXXCompiler.cmake";
mf->ReadListFile(0,fpath.c_str());
}
if(!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INFORMATION_LOADED"))
{
fpath = root;
fpath += "/Modules/CMakeSystemSpecificInformation.cmake";
mf->ReadListFile(0,fpath.c_str());
}
if(!isLocal)
{
// At this point we should have enough info for a try compile
// which is used in the backward stuff
if(needCBackwards)
{
if (!m_CMakeInstance->GetIsInTryCompile())
{
// for old versions of CMake ListFiles
const char* versionValue
= mf->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
if (!versionValue || atof(versionValue) <= 1.4)
{
std::string ifpath = root + "/Modules/CMakeBackwardCompatibilityC.cmake";
mf->ReadListFile(0,ifpath.c_str());
}
}
}
if(needCXXBackwards)
{
if (!m_CMakeInstance->GetIsInTryCompile())
{
// for old versions of CMake ListFiles
const char* versionValue
= mf->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
if (!versionValue || atof(versionValue) <= 1.4)
{
std::string fpath = root + "/Modules/CMakeBackwardCompatibilityCXX.cmake";
mf->ReadListFile(0,fpath.c_str());
}
}
}
// if we are from the top, always define this
mf->AddDefinition("RUN_CONFIGURE", true);
}
} }
///! Create a local generator appropriate to this Global Generator ///! Create a local generator appropriate to this Global Generator
@ -154,24 +39,3 @@ cmLocalGenerator *cmGlobalUnixMakefileGenerator::CreateLocalGenerator()
return lg; return lg;
} }
void cmGlobalUnixMakefileGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen)
{
this->SetConfiguredFilesPath(
gen->GetCMakeInstance()->GetHomeOutputDirectory());
const char* make =
gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make,
"make program",
cmCacheManager::FILEPATH);
// if C, then enable C
if(gen->GetLanguageEnabled("C"))
{
this->SetLanguageEnabled("C");
}
// if CXX
if(gen->GetLanguageEnabled("CXX"))
{
this->SetLanguageEnabled("CXX");
}
}

6
Source/cmGlobalUnixMakefileGenerator.h
View File

@ -27,6 +27,7 @@
class cmGlobalUnixMakefileGenerator : public cmGlobalGenerator class cmGlobalUnixMakefileGenerator : public cmGlobalGenerator
{ {
public: public:
cmGlobalUnixMakefileGenerator();
///! Get the name for the generator. ///! Get the name for the generator.
virtual const char* GetName() { virtual const char* GetName() {
return cmGlobalUnixMakefileGenerator::GetActualName();} return cmGlobalUnixMakefileGenerator::GetActualName();}
@ -41,11 +42,6 @@ public:
*/ */
virtual void EnableLanguage(const char*, cmMakefile *mf); virtual void EnableLanguage(const char*, cmMakefile *mf);
/**
* Try to determine system infomation, get it from another generator
*/
virtual void EnableLanguagesFromGenerator(cmGlobalGenerator *);
}; };
#endif #endif

25
Source/cmGlobalVisualStudio6Generator.cxx
View File

@ -19,24 +19,15 @@
#include "cmMakefile.h" #include "cmMakefile.h"
#include "cmake.h" #include "cmake.h"
void cmGlobalVisualStudio6Generator::EnableLanguage(const char*, cmGlobalVisualStudio6Generator::cmGlobalVisualStudio6Generator()
{
m_FindMakeProgramFile = "CMakeVS6FindMake.cmake";
}
void cmGlobalVisualStudio6Generator::EnableLanguage(const char* lang,
cmMakefile *mf) cmMakefile *mf)
{ {
// now load the settings this->cmGlobalGenerator::EnableLanguage(lang, mf);
if(!mf->GetDefinition("CMAKE_ROOT"))
{
cmSystemTools::Error(
"CMAKE_ROOT has not been defined, bad GUI or driver program");
return;
}
if(!this->GetLanguageEnabled("CXX"))
{
std::string fpath =
mf->GetDefinition("CMAKE_ROOT");
fpath += "/Templates/CMakeWindowsSystemConfig.cmake";
mf->ReadListFile(NULL,fpath.c_str());
this->SetLanguageEnabled("CXX");
}
} }
int cmGlobalVisualStudio6Generator::TryCompile(const char *, int cmGlobalVisualStudio6Generator::TryCompile(const char *,
@ -63,7 +54,6 @@ int cmGlobalVisualStudio6Generator::TryCompile(const char *,
*/ */
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
cmSystemTools::ChangeDirectory(bindir); cmSystemTools::ChangeDirectory(bindir);
// if there are spaces in the makeCommand, assume a full path // if there are spaces in the makeCommand, assume a full path
// and convert it to a path with no spaces in it as the // and convert it to a path with no spaces in it as the
// RunCommand does not like spaces // RunCommand does not like spaces
@ -85,7 +75,6 @@ int cmGlobalVisualStudio6Generator::TryCompile(const char *,
makeCommand += "ALL_BUILD"; makeCommand += "ALL_BUILD";
} }
makeCommand += " - Debug\""; makeCommand += " - Debug\"";
int retVal; int retVal;
if (!cmSystemTools::RunCommand(makeCommand.c_str(), *output, retVal, 0, false)) if (!cmSystemTools::RunCommand(makeCommand.c_str(), *output, retVal, 0, false))
{ {

2
Source/cmGlobalVisualStudio6Generator.h
View File

@ -29,6 +29,8 @@ class cmTarget;
class cmGlobalVisualStudio6Generator : public cmGlobalGenerator class cmGlobalVisualStudio6Generator : public cmGlobalGenerator
{ {
public: public:
cmGlobalVisualStudio6Generator();
///! Get the name for the generator. ///! Get the name for the generator.
virtual const char* GetName() { virtual const char* GetName() {
return cmGlobalVisualStudio6Generator::GetActualName();} return cmGlobalVisualStudio6Generator::GetActualName();}

29
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -20,26 +20,23 @@
#include "cmake.h" #include "cmake.h"
#include "windows.h" #include "windows.h"
void cmGlobalVisualStudio7Generator::EnableLanguage(const char*,
cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator()
{
m_FindMakeProgramFile = "CMakeVS7FindMake.cmake";
}
void cmGlobalVisualStudio7Generator::EnableLanguage(const char* lang,
cmMakefile *mf) cmMakefile *mf)
{ {
// now load the settings mf->AddDefinition("CMAKE_GENERATOR_CC", "cl");
if(!mf->GetDefinition("CMAKE_ROOT")) mf->AddDefinition("CMAKE_GENERATOR_CXX", "cl");
{ this->cmGlobalGenerator::EnableLanguage(lang, mf);
cmSystemTools::Error(
"CMAKE_ROOT has not been defined, bad GUI or driver program");
return;
}
if(!this->GetLanguageEnabled("CXX"))
{
std::string fpath =
mf->GetDefinition("CMAKE_ROOT");
fpath += "/Templates/CMakeDotNetSystemConfig.cmake";
mf->ReadListFile(NULL,fpath.c_str());
this->SetLanguageEnabled("CXX");
}
} }
int cmGlobalVisualStudio7Generator::TryCompile(const char *, int cmGlobalVisualStudio7Generator::TryCompile(const char *,
const char *bindir, const char *bindir,
const char *projectName, const char *projectName,

1
Source/cmGlobalVisualStudio7Generator.h
View File

@ -29,6 +29,7 @@ class cmTarget;
class cmGlobalVisualStudio7Generator : public cmGlobalGenerator class cmGlobalVisualStudio7Generator : public cmGlobalGenerator
{ {
public: public:
cmGlobalVisualStudio7Generator();
///! Get the name for the generator. ///! Get the name for the generator.
virtual const char* GetName() { virtual const char* GetName() {
return cmGlobalVisualStudio7Generator::GetActualName();} return cmGlobalVisualStudio7Generator::GetActualName();}

12
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -737,8 +737,16 @@ void cmLocalVisualStudio6Generator::WriteDSPHeader(std::ostream& fout, const cha
} }
} }
} }
std::string extraLinkOptions = std::string extraLinkOptions;
m_Makefile->GetDefinition("CMAKE_EXTRA_LINK_FLAGS"); if(target.GetType() == cmTarget::EXECUTABLE)
{
extraLinkOptions = m_Makefile->GetDefinition("CMAKE_EXE_LINKER_FLAGS");
}
if(target.GetType() == cmTarget::SHARED_LIBRARY)
{
extraLinkOptions = m_Makefile->GetDefinition("CMAKE_SHARED_LINKER_FLAGS");
}
if(extraLinkOptions.size()) if(extraLinkOptions.size())
{ {
libOptions += " "; libOptions += " ";