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

Merge topic 'enable-language-require-compiler' 

3e04946 Require CMAKE_<LANG>_COMPILER to be found as a full path
6007f7c CMakeDetermineCompilerId: Always use compiler detected from IDE
332771c CMakeDetermine*Compiler: Remove temporary cache entry
This commit is contained in:
Brad King 2013-10-28 08:39:29 -04:00 committed by CMake Topic Stage
parent ecc6d7f919 3e04946f7b
commit 16df2456a4
35 changed files with 233 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Modules/CMakeCCompilerId.c.in
View File

@ -228,6 +228,7 @@ char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
#endif
@CMAKE_C_COMPILER_ID_PLATFORM_CONTENT@
@CMAKE_C_COMPILER_ID_ERROR_FOR_TEST@
/*--------------------------------------------------------------------------*/

1
Modules/CMakeCXXCompilerId.cpp.in
View File

@ -221,6 +221,7 @@ char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
#endif
@CMAKE_CXX_COMPILER_ID_PLATFORM_CONTENT@
@CMAKE_CXX_COMPILER_ID_ERROR_FOR_TEST@
/*--------------------------------------------------------------------------*/

2
Modules/CMakeDetermineASMCompiler.cmake
View File

@ -59,10 +59,10 @@ else()
get_filename_component(_CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH "${CMAKE_ASM${ASM_DIALECT}_COMPILER}" PATH)
if(NOT _CMAKE_USER_ASM${ASM_DIALECT}_COMPILER_PATH)
find_program(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH NAMES ${CMAKE_ASM${ASM_DIALECT}_COMPILER})
mark_as_advanced(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
if(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH)
set(CMAKE_ASM${ASM_DIALECT}_COMPILER ${CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH} CACHE FILEPATH "Assembler" FORCE)
endif()
unset(CMAKE_ASM${ASM_DIALECT}_COMPILER_WITH_PATH CACHE)
endif()
endif()
mark_as_advanced(CMAKE_ASM${ASM_DIALECT}_COMPILER)

2
Modules/CMakeDetermineCCompiler.cmake
View File

@ -92,10 +92,10 @@ else()
get_filename_component(_CMAKE_USER_C_COMPILER_PATH "${CMAKE_C_COMPILER}" PATH)
if(NOT _CMAKE_USER_C_COMPILER_PATH)
find_program(CMAKE_C_COMPILER_WITH_PATH NAMES ${CMAKE_C_COMPILER})
mark_as_advanced(CMAKE_C_COMPILER_WITH_PATH)
if(CMAKE_C_COMPILER_WITH_PATH)
set(CMAKE_C_COMPILER ${CMAKE_C_COMPILER_WITH_PATH} CACHE STRING "C compiler" FORCE)
endif()
unset(CMAKE_C_COMPILER_WITH_PATH CACHE)
endif()
endif()
mark_as_advanced(CMAKE_C_COMPILER)

2
Modules/CMakeDetermineCXXCompiler.cmake
View File

@ -91,10 +91,10 @@ else()
get_filename_component(_CMAKE_USER_CXX_COMPILER_PATH "${CMAKE_CXX_COMPILER}" PATH)
if(NOT _CMAKE_USER_CXX_COMPILER_PATH)
find_program(CMAKE_CXX_COMPILER_WITH_PATH NAMES ${CMAKE_CXX_COMPILER})
mark_as_advanced(CMAKE_CXX_COMPILER_WITH_PATH)
if(CMAKE_CXX_COMPILER_WITH_PATH)
set(CMAKE_CXX_COMPILER ${CMAKE_CXX_COMPILER_WITH_PATH} CACHE STRING "CXX compiler" FORCE)
endif()
unset(CMAKE_CXX_COMPILER_WITH_PATH CACHE)
endif()
endif()
mark_as_advanced(CMAKE_CXX_COMPILER)

10
Modules/CMakeDetermineCompilerId.cmake
View File

@ -67,12 +67,10 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
endif()
# Check if compiler id detection gave us the compiler tool.
if(NOT CMAKE_${lang}_COMPILER)
if(CMAKE_${lang}_COMPILER_ID_TOOL)
set(CMAKE_${lang}_COMPILER "${CMAKE_${lang}_COMPILER_ID_TOOL}" PARENT_SCOPE)
else()
set(CMAKE_${lang}_COMPILER "CMAKE_${lang}_COMPILER-NOTFOUND" PARENT_SCOPE)
endif()
if(CMAKE_${lang}_COMPILER_ID_TOOL)
set(CMAKE_${lang}_COMPILER "${CMAKE_${lang}_COMPILER_ID_TOOL}" PARENT_SCOPE)
elseif(NOT CMAKE_${lang}_COMPILER)
set(CMAKE_${lang}_COMPILER "CMAKE_${lang}_COMPILER-NOTFOUND" PARENT_SCOPE)
endif()
set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE)

2
Modules/CMakeDetermineFortranCompiler.cmake
View File

@ -109,11 +109,11 @@ else()
get_filename_component(_CMAKE_USER_Fortran_COMPILER_PATH "${CMAKE_Fortran_COMPILER}" PATH)
if(NOT _CMAKE_USER_Fortran_COMPILER_PATH)
find_program(CMAKE_Fortran_COMPILER_WITH_PATH NAMES ${CMAKE_Fortran_COMPILER})
mark_as_advanced(CMAKE_Fortran_COMPILER_WITH_PATH)
if(CMAKE_Fortran_COMPILER_WITH_PATH)
set(CMAKE_Fortran_COMPILER ${CMAKE_Fortran_COMPILER_WITH_PATH}
CACHE STRING "Fortran compiler" FORCE)
endif()
unset(CMAKE_Fortran_COMPILER_WITH_PATH CACHE)
endif()
endif()
mark_as_advanced(CMAKE_Fortran_COMPILER)

120
Source/cmGlobalGenerator.cxx
View File

@ -138,15 +138,7 @@ void cmGlobalGenerator::ResolveLanguageCompiler(const std::string &lang,
if((path.size() == 0 || !cmSystemTools::FileExists(path.c_str()))
&& (optional==false))
{
std::string message = "your ";
message += lang;
message += " compiler: \"";
message += name;
message += "\" was not found. Please set ";
message += langComp;
message += " to a valid compiler path or name.";
cmSystemTools::Error(message.c_str());
path = name;
return;
}
std::string doc = lang;
doc += " compiler.";
@ -334,7 +326,7 @@ void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
void
cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *mf, bool)
cmMakefile *mf, bool optional)
{
if(languages.size() == 0)
{
@ -370,6 +362,8 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
}
}
bool fatalError = false;
mf->AddDefinition("RUN_CONFIGURE", true);
std::string rootBin = mf->GetHomeOutputDirectory();
rootBin += cmake::GetCMakeFilesDirectory();
@ -556,6 +550,65 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
this->SetLanguageEnabled("NONE", mf);
continue;
}
// Check that the compiler was found.
std::string compilerName = "CMAKE_";
compilerName += lang;
compilerName += "_COMPILER";
std::string compilerEnv = "CMAKE_";
compilerEnv += lang;
compilerEnv += "_COMPILER_ENV_VAR";
cmOStringStream noCompiler;
const char* compilerFile = mf->GetDefinition(compilerName.c_str());
if(!compilerFile || !*compilerFile ||
cmSystemTools::IsNOTFOUND(compilerFile))
{
noCompiler <<
"No " << compilerName << " could be found.\n"
;
}
else if(strcmp(lang, "RC") != 0)
{
if(!cmSystemTools::FileIsFullPath(compilerFile))
{
noCompiler <<
"The " << compilerName << ":\n"
" " << compilerFile << "\n"
"is not a full path and was not found in the PATH.\n"
;
}
else if(!cmSystemTools::FileExists(compilerFile))
{
noCompiler <<
"The " << compilerName << ":\n"
" " << compilerFile << "\n"
"is not a full path to an existing compiler tool.\n"
;
}
}
if(!noCompiler.str().empty())
{
// Skip testing this language since the compiler is not found.
needTestLanguage[lang] = false;
if(!optional)
{
// The compiler was not found and it is not optional. Remove
// CMake(LANG)Compiler.cmake so we try again next time CMake runs.
std::string compilerLangFile = rootBin;
compilerLangFile += "/CMake";
compilerLangFile += lang;
compilerLangFile += "Compiler.cmake";
cmSystemTools::RemoveFile(compilerLangFile.c_str());
if(!this->CMakeInstance->GetIsInTryCompile())
{
this->PrintCompilerAdvice(noCompiler, lang,
mf->GetDefinition(compilerEnv.c_str()));
mf->IssueMessage(cmake::FATAL_ERROR, noCompiler.str());
fatalError = true;
}
}
}
std::string langLoadedVar = "CMAKE_";
langLoadedVar += lang;
langLoadedVar += "_INFORMATION_LOADED";
@ -582,26 +635,12 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
}
this->LanguagesReady.insert(lang);
std::string compilerName = "CMAKE_";
compilerName += lang;
compilerName += "_COMPILER";
std::string compilerLangFile = rootBin;
compilerLangFile += "/CMake";
compilerLangFile += lang;
compilerLangFile += "Compiler.cmake";
// Test the compiler for the language just setup
// (but only if a compiler has been actually found)
// At this point we should have enough info for a try compile
// which is used in the backward stuff
// If the language is untested then test it now with a try compile.
if (!mf->IsSet(compilerName.c_str()))
{
// if the compiler did not work, then remove the
// CMake(LANG)Compiler.cmake file so that it will get tested the
// next time cmake is run
cmSystemTools::RemoveFile(compilerLangFile.c_str());
}
else if(needTestLanguage[lang])
if(needTestLanguage[lang])
{
if (!this->CMakeInstance->GetIsInTryCompile())
{
@ -622,6 +661,10 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
// next time cmake is run
if(!mf->IsOn(compilerWorks.c_str()))
{
std::string compilerLangFile = rootBin;
compilerLangFile += "/CMake";
compilerLangFile += lang;
compilerLangFile += "Compiler.cmake";
cmSystemTools::RemoveFile(compilerLangFile.c_str());
}
} // end if in try compile
@ -652,6 +695,33 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
{
mf->ReadListFile(0,projectCompatibility.c_str());
}
if(fatalError)
{
cmSystemTools::SetFatalErrorOccured();
}
}
//----------------------------------------------------------------------------
void cmGlobalGenerator::PrintCompilerAdvice(std::ostream& os,
std::string lang,
const char* envVar)
{
// Subclasses override this method if they do not support this advice.
os <<
"Tell CMake where to find the compiler by setting "
;
if(envVar)
{
os <<
"either the environment variable \"" << envVar << "\" or "
;
}
os <<
"the CMake cache entry CMAKE_" << lang << "_COMPILER "
"to the full path to the compiler, or to the compiler name "
"if it is in the PATH."
;
}
//----------------------------------------------------------------------------

2
Source/cmGlobalGenerator.h
View File

@ -392,6 +392,8 @@ private:
void WriteSummary();
void WriteSummary(cmTarget* target);
virtual void PrintCompilerAdvice(std::ostream& os, std::string lang,
const char* envVar);
void CheckCompilerIdCompatibility(cmMakefile* mf, std::string lang);
cmExternalMakefileProjectGenerator* ExtraGenerator;

1
Source/cmGlobalVisualStudioGenerator.h
View File

@ -107,6 +107,7 @@ protected:
const char* AdditionalPlatformDefinition;
private:
void PrintCompilerAdvice(std::ostream&, std::string, const char*) {}
void ComputeTargetObjects(cmGeneratorTarget* gt) const;
void FollowLinkDepends(cmTarget* target, std::set<cmTarget*>& linked);

1
Source/cmGlobalXCodeGenerator.h
View File

@ -210,6 +210,7 @@ protected:
std::vector<cmXCodeObject*> XCodeObjects;
cmXCodeObject* RootObject;
private:
void PrintCompilerAdvice(std::ostream&, std::string, const char*) {}
void ComputeTargetObjects(cmGeneratorTarget* gt) const;
std::string GetObjectsNormalDirectory(

1
Tests/RunCMake/CMakeLists.txt
View File

@ -60,6 +60,7 @@ add_RunCMake_test(CTest)
if(UNIX AND "${CMAKE_TEST_GENERATOR}" MATCHES "Unix Makefiles")
add_RunCMake_test(CompilerChange)
endif()
add_RunCMake_test(CompilerNotFound)
add_RunCMake_test(Configure)
add_RunCMake_test(DisallowedCommands)
add_RunCMake_test(ExternalData)

2
Tests/RunCMake/CompilerChange/EmptyCompiler-override.cmake Normal file
View File

@ -0,0 +1,2 @@
message(STATUS "CMAKE_C_COMPILER is \"${CMAKE_C_COMPILER}\"")
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/cc.cmake" "set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\")\n")

12
Tests/RunCMake/CompilerChange/EmptyCompiler-stderr.txt
View File

@ -1,5 +1,13 @@
You have changed variables that require your cache to be deleted.
Configure will be re-run and you may have to reset some variables.
The following variables have changed:
CMAKE_C_COMPILER= *(
|$)
CMAKE_C_COMPILER= *
+
CMake Error at EmptyCompiler.cmake:2 \(enable_language\):
No CMAKE_C_COMPILER could be found.
Tell CMake where to find the compiler by setting either the environment
variable "CC" or the CMake cache entry CMAKE_C_COMPILER to the full path to
the compiler, or to the compiler name if it is in the PATH.
Call Stack \(most recent call first\):
CMakeLists.txt:6 \(include\)$

3
Tests/RunCMake/CompilerChange/EmptyCompiler.cmake
View File

@ -1,3 +1,2 @@
set(CMAKE_USER_MAKE_RULES_OVERRIDE_C ${CMAKE_CURRENT_LIST_DIR}/EmptyCompiler-override.cmake)
enable_language(C)
message(STATUS "CMAKE_C_COMPILER is \"${CMAKE_C_COMPILER}\"")
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/cc.cmake" "set(CMAKE_C_COMPILER \"${CMAKE_C_COMPILER}\")\n")

1
Tests/RunCMake/CompilerNotFound/BadCompilerC-result.txt Normal file
View File

@ -0,0 +1 @@
1

12
Tests/RunCMake/CompilerNotFound/BadCompilerC-stderr.txt Normal file
View File

@ -0,0 +1,12 @@
CMake Error at BadCompilerC.cmake:2 \(enable_language\):
The CMAKE_C_COMPILER:
no-C-compiler
is not a full path and was not found in the PATH.
Tell CMake where to find the compiler by setting either the environment
variable "CC" or the CMake cache entry CMAKE_C_COMPILER to the full path to
the compiler, or to the compiler name if it is in the PATH.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)$

3
Tests/RunCMake/CompilerNotFound/BadCompilerC.cmake Normal file
View File

@ -0,0 +1,3 @@
set(CMAKE_C_COMPILER "no-C-compiler")
enable_language(C)
message(FATAL_ERROR "This error should not be reached.")

1
Tests/RunCMake/CompilerNotFound/BadCompilerCXX-result.txt Normal file
View File

@ -0,0 +1 @@
1

12
Tests/RunCMake/CompilerNotFound/BadCompilerCXX-stderr.txt Normal file
View File

@ -0,0 +1,12 @@
CMake Error at BadCompilerCXX.cmake:2 \(enable_language\):
The CMAKE_CXX_COMPILER:
no-CXX-compiler
is not a full path and was not found in the PATH.
Tell CMake where to find the compiler by setting either the environment
variable "CXX" or the CMake cache entry CMAKE_CXX_COMPILER to the full path
to the compiler, or to the compiler name if it is in the PATH.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)$

3
Tests/RunCMake/CompilerNotFound/BadCompilerCXX.cmake Normal file
View File

@ -0,0 +1,3 @@
set(CMAKE_CXX_COMPILER "no-CXX-compiler")
enable_language(CXX)
message(FATAL_ERROR "This error should not be reached.")

1
Tests/RunCMake/CompilerNotFound/BadCompilerCandCXX-result.txt Normal file
View File

@ -0,0 +1 @@
1

25
Tests/RunCMake/CompilerNotFound/BadCompilerCandCXX-stderr.txt Normal file
View File

@ -0,0 +1,25 @@
CMake Error at BadCompilerCandCXX.cmake:3 \(project\):
The CMAKE_C_COMPILER:
no-C-compiler
is not a full path and was not found in the PATH.
Tell CMake where to find the compiler by setting either the environment
variable "CC" or the CMake cache entry CMAKE_C_COMPILER to the full path to
the compiler, or to the compiler name if it is in the PATH.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
+
CMake Error at BadCompilerCandCXX.cmake:3 \(project\):
The CMAKE_CXX_COMPILER:
no-CXX-compiler
is not a full path and was not found in the PATH.
Tell CMake where to find the compiler by setting either the environment
variable "CXX" or the CMake cache entry CMAKE_CXX_COMPILER to the full path
to the compiler, or to the compiler name if it is in the PATH.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)$

4
Tests/RunCMake/CompilerNotFound/BadCompilerCandCXX.cmake Normal file
View File

@ -0,0 +1,4 @@
set(CMAKE_C_COMPILER "no-C-compiler")
set(CMAKE_CXX_COMPILER "no-CXX-compiler")
project(BadCompilerCandCXXInner C CXX)
message(FATAL_ERROR "This error should not be reached.")

3
Tests/RunCMake/CompilerNotFound/CMakeLists.txt Normal file
View File

@ -0,0 +1,3 @@
cmake_minimum_required(VERSION 2.8.4)
project(${RunCMake_TEST} NONE)
include(${RunCMake_TEST}.cmake)

1
Tests/RunCMake/CompilerNotFound/NoCompilerC-IDE-result.txt Normal file
View File

@ -0,0 +1 @@
1

5
Tests/RunCMake/CompilerNotFound/NoCompilerC-IDE-stderr.txt Normal file
View File

@ -0,0 +1,5 @@
CMake Error at NoCompilerC-IDE.cmake:2 \(enable_language\):
No CMAKE_C_COMPILER could be found.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)$

3
Tests/RunCMake/CompilerNotFound/NoCompilerC-IDE.cmake Normal file
View File

@ -0,0 +1,3 @@
set(CMAKE_C_COMPILER_ID_ERROR_FOR_TEST "#error NoCompilerC-IDE")
enable_language(C)
message(FATAL_ERROR "This error should not be reached.")

1
Tests/RunCMake/CompilerNotFound/NoCompilerCXX-IDE-result.txt Normal file
View File

@ -0,0 +1 @@
1

5
Tests/RunCMake/CompilerNotFound/NoCompilerCXX-IDE-stderr.txt Normal file
View File

@ -0,0 +1,5 @@
CMake Error at NoCompilerCXX-IDE.cmake:2 \(enable_language\):
No CMAKE_CXX_COMPILER could be found.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)$

3
Tests/RunCMake/CompilerNotFound/NoCompilerCXX-IDE.cmake Normal file
View File

@ -0,0 +1,3 @@
set(CMAKE_CXX_COMPILER_ID_ERROR_FOR_TEST "#error NoCompilerCXX-IDE")
enable_language(CXX)
message(FATAL_ERROR "This error should not be reached.")

1
Tests/RunCMake/CompilerNotFound/NoCompilerCandCXX-IDE-result.txt Normal file
View File

@ -0,0 +1 @@
1

11
Tests/RunCMake/CompilerNotFound/NoCompilerCandCXX-IDE-stderr.txt Normal file
View File

@ -0,0 +1,11 @@
CMake Error at NoCompilerCandCXX-IDE.cmake:3 \(project\):
No CMAKE_C_COMPILER could be found.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
+
CMake Error at NoCompilerCandCXX-IDE.cmake:3 \(project\):
No CMAKE_CXX_COMPILER could be found.
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)$

4
Tests/RunCMake/CompilerNotFound/NoCompilerCandCXX-IDE.cmake Normal file
View File

@ -0,0 +1,4 @@
set(CMAKE_C_COMPILER_ID_ERROR_FOR_TEST "#error NoCompilerCandCXX-IDE")
set(CMAKE_CXX_COMPILER_ID_ERROR_FOR_TEST "#error NoCompilerCandCXX-IDE")
project(NoCompilerCandCXXInner C CXX)
message(FATAL_ERROR "This error should not be reached.")

11
Tests/RunCMake/CompilerNotFound/RunCMakeTest.cmake Normal file
View File

@ -0,0 +1,11 @@
include(RunCMake)
if("${RunCMake_GENERATOR}" MATCHES "Visual Studio|Xcode")
run_cmake(NoCompilerC-IDE)
run_cmake(NoCompilerCXX-IDE)
run_cmake(NoCompilerCandCXX-IDE)
else()
run_cmake(BadCompilerC)
run_cmake(BadCompilerCXX)
run_cmake(BadCompilerCandCXX)
endif()