reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-24 12:09:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'policy-CMP0022-fixes' into policy-CMP0022-fixes-for-master

Browse Source 
Resolve conflict in Source/cmTarget.cxx by integrating the changes to
the internal copy constructor from both sides.  Also resolve a logical
conflict by dropping the special case for INTERFACE_LIBRARY targets.
Since cmTarget::SetMakefile already forces CMP0022 to NEW for such
targets we need no special handling.

Resolve conflict in Source/cmTargetLinkLibrariesCommand.h by dropping
the documentation change.  We will make the same change in the new
location of the same documentation in a separate commit.

Resolve conflicts in

 Tests/RunCMake/CMP0022/CMP0022-WARN-empty-old-stderr.txt
 Tests/RunCMake/CMP0022/RunCMakeTest.cmake

by taking the side from the 'policy-CMP0022-fixes' branch.
This commit is contained in:
Brad King 2013-11-03 09:20:47 -05:00
commit 25b7f87eca
22 changed files with 232 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Source/cmExportFileGenerator.cxx
View File

@ -191,6 +191,10 @@ bool cmExportFileGenerator::PopulateInterfaceLinkLibrariesProperty(
ImportPropertyMap &properties,
std::vector<std::string> &missingTargets)
{
if(!target->IsLinkable())
{
return false;
}
const char *input = target->GetProperty("INTERFACE_LINK_LIBRARIES");
if (input)
{
@ -654,6 +658,7 @@ cmExportFileGenerator
if (iface->ImplementationIsInterface)
{
// Policy CMP0022 must not be NEW.
this->SetImportLinkProperty(suffix, target,
"IMPORTED_LINK_INTERFACE_LIBRARIES",
iface->Libraries, properties, missingTargets);

242
Source/cmTarget.cxx
View File

@ -81,10 +81,12 @@ class cmTargetInternals
public:
cmTargetInternals()
{
this->PolicyWarnedCMP0022 = false;
this->SourceFileFlagsConstructed = false;
}
cmTargetInternals(cmTargetInternals const&)
{
this->PolicyWarnedCMP0022 = false;
this->SourceFileFlagsConstructed = false;
}
~cmTargetInternals();
@ -104,6 +106,7 @@ public:
typedef std::map<TargetConfigPair, OptionalLinkInterface>
LinkInterfaceMapType;
LinkInterfaceMapType LinkInterfaceMap;
bool PolicyWarnedCMP0022;
typedef std::map<cmStdString, cmTarget::OutputInfo> OutputInfoMapType;
OutputInfoMapType OutputInfoMap;
@ -685,21 +688,10 @@ void cmTarget::MergeLinkLibraries( cmMakefile& mf,
i += this->PrevLinkedLibraries.size();
for( ; i != libs.end(); ++i )
{
const char *lib = i->first.c_str();
// We call this so that the dependencies get written to the cache
this->AddLinkLibrary( mf, selfname, lib, i->second );
if (this->GetType() == cmTarget::STATIC_LIBRARY)
{
std::string configLib = this->GetDebugGeneratorExpressions(lib,
i->second);
if (cmGeneratorExpression::IsValidTargetName(lib)
|| cmGeneratorExpression::Find(lib) != std::string::npos)
{
configLib = "$<LINK_ONLY:" + configLib + ">";
}
this->AppendProperty("INTERFACE_LINK_LIBRARIES", configLib.c_str());
}
// This is equivalent to the target_link_libraries plain signature.
this->AddLinkLibrary( mf, selfname, i->first.c_str(), i->second );
this->AppendProperty("INTERFACE_LINK_LIBRARIES",
this->GetDebugGeneratorExpressions(i->first.c_str(), i->second).c_str());
}
this->PrevLinkedLibraries = libs;
}
@ -5030,12 +5022,20 @@ bool cmTarget::ComputeLinkInterface(const char* config, LinkInterface& iface,
// An explicit list of interface libraries may be set for shared
// libraries and executables that export symbols.
const char* explicitLibraries = 0;
const char* newExplicitLibraries =
this->GetProperty("INTERFACE_LINK_LIBRARIES");
std::string linkIfaceProp;
if(this->GetType() == cmTarget::SHARED_LIBRARY ||
if(this->PolicyStatusCMP0022 != cmPolicies::OLD &&
this->PolicyStatusCMP0022 != cmPolicies::WARN)
{
// CMP0022 NEW behavior is to use INTERFACE_LINK_LIBRARIES.
linkIfaceProp = "INTERFACE_LINK_LIBRARIES";
explicitLibraries = this->GetProperty(linkIfaceProp.c_str());
}
else if(this->GetType() == cmTarget::SHARED_LIBRARY ||
this->IsExecutableWithExports())
{
// CMP0022 OLD behavior is to use LINK_INTERFACE_LIBRARIES if set on a
// shared lib or executable.
// Lookup the per-configuration property.
linkIfaceProp = "LINK_INTERFACE_LIBRARIES";
linkIfaceProp += suffix;
@ -5047,126 +5047,33 @@ bool cmTarget::ComputeLinkInterface(const char* config, LinkInterface& iface,
linkIfaceProp = "LINK_INTERFACE_LIBRARIES";
explicitLibraries = this->GetProperty(linkIfaceProp.c_str());
}
if (newExplicitLibraries
&& (!explicitLibraries ||
(explicitLibraries
&& strcmp(newExplicitLibraries, explicitLibraries) != 0)))
{
switch(this->GetPolicyStatusCMP0022())
{
case cmPolicies::WARN:
{
cmOStringStream w;
w << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0022)) << "\n"
<< "Target \"" << this->GetName() << "\" has a "
"INTERFACE_LINK_LIBRARIES property which differs from its "
<< linkIfaceProp << " properties."
"\n"
"INTERFACE_LINK_LIBRARIES:\n "
<< newExplicitLibraries
<< "\n"
<< linkIfaceProp << ":\n "
<< (explicitLibraries ? explicitLibraries : "(empty)") << "\n";
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
}
// Fall through
case cmPolicies::OLD:
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::NEW:
explicitLibraries = newExplicitLibraries;
linkIfaceProp = "INTERFACE_LINK_LIBRARIES";
break;
}
}
}
else if(this->GetType() == cmTarget::STATIC_LIBRARY)
{
if (newExplicitLibraries)
{
cmListFileBacktrace lfbt;
cmGeneratorExpression ge(lfbt);
cmGeneratorExpressionDAGChecker dagChecker(lfbt, this->GetName(),
"INTERFACE_LINK_LIBRARIES", 0, 0);
std::vector<std::string> ifaceLibs;
cmSystemTools::ExpandListArgument(
ge.Parse(newExplicitLibraries)->Evaluate(
this->Makefile,
config,
false,
headTarget,
this, &dagChecker), ifaceLibs);
LinkImplementation const* impl = this->GetLinkImplementation(config,
headTarget);
if (ifaceLibs != impl->Libraries)
{
switch(this->GetPolicyStatusCMP0022())
{
case cmPolicies::WARN:
{
std::string oldLibraries;
std::string newLibraries;
const char *sep = "";
for(std::vector<std::string>::const_iterator it
= impl->Libraries.begin(); it != impl->Libraries.end(); ++it)
{
oldLibraries += sep;
oldLibraries += *it;
sep = ";";
}
sep = "";
for(std::vector<std::string>::const_iterator it
= ifaceLibs.begin(); it != ifaceLibs.end(); ++it)
{
newLibraries += sep;
newLibraries += *it;
sep = ";";
}
if(explicitLibraries && this->PolicyStatusCMP0022 == cmPolicies::WARN &&
!this->Internal->PolicyWarnedCMP0022)
{
// Compare the explicitly set old link interface properties to the
// preferred new link interface property one and warn if different.
const char* newExplicitLibraries =
this->GetProperty("INTERFACE_LINK_LIBRARIES");
if (newExplicitLibraries
&& strcmp(newExplicitLibraries, explicitLibraries) != 0)
{
cmOStringStream w;
w << (this->Makefile->GetPolicies()
w <<
(this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0022)) << "\n"
<< "Static library target \"" << this->GetName() << "\" has a "
"INTERFACE_LINK_LIBRARIES property. This should be preferred "
"as the source of the link interface for this library. "
"Ignoring the property and using the link implementation "
"as the link interface instead."
"Target \"" << this->GetName() << "\" has an "
"INTERFACE_LINK_LIBRARIES property which differs from its " <<
linkIfaceProp << " properties."
"\n"
"INTERFACE_LINK_LIBRARIES:\n"
<< newLibraries
<< "\n"
<< "Link implementation:\n "
<< oldLibraries << "\n";
" " << newExplicitLibraries << "\n" <<
linkIfaceProp << ":\n"
" " << (explicitLibraries ? explicitLibraries : "(empty)") << "\n";
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
this->Internal->PolicyWarnedCMP0022 = true;
}
// Fall through
case cmPolicies::OLD:
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::NEW:
explicitLibraries = newExplicitLibraries;
linkIfaceProp = "INTERFACE_LINK_LIBRARIES";
break;
}
}
else
{
iface.Libraries = impl->Libraries;
if(this->LinkLanguagePropagatesToDependents())
{
// Targets using this archive need its language runtime libraries.
iface.Languages = impl->Languages;
}
}
}
}
else if (this->GetType() == cmTarget::INTERFACE_LIBRARY)
{
explicitLibraries = newExplicitLibraries;
linkIfaceProp = "INTERFACE_LINK_LIBRARIES";
}
// There is no implicit link interface for executables or modules
@ -5235,11 +5142,12 @@ bool cmTarget::ComputeLinkInterface(const char* config, LinkInterface& iface,
}
}
}
else if (this->GetPolicyStatusCMP0022() == cmPolicies::WARN
|| this->GetPolicyStatusCMP0022() == cmPolicies::OLD)
// The implementation shouldn't be the interface if CMP0022 is NEW. That
// way, the LINK_LIBRARIES property can be set directly without having to
// empty the INTERFACE_LINK_LIBRARIES
else if (this->PolicyStatusCMP0022 == cmPolicies::WARN
|| this->PolicyStatusCMP0022 == cmPolicies::OLD)
// If CMP0022 is NEW then the plain tll signature sets the
// INTERFACE_LINK_LIBRARIES, so if we get here then the project
// cleared the property explicitly and we should not fall back
// to the link implementation.
{
// The link implementation is the default link interface.
LinkImplementation const* impl = this->GetLinkImplementation(config,
@ -5252,6 +5160,70 @@ bool cmTarget::ComputeLinkInterface(const char* config, LinkInterface& iface,
// Targets using this archive need its language runtime libraries.
iface.Languages = impl->Languages;
}
if(this->PolicyStatusCMP0022 == cmPolicies::WARN &&
!this->Internal->PolicyWarnedCMP0022)
{
// Compare the link implementation fallback link interface to the
// preferred new link interface property and warn if different.
cmListFileBacktrace lfbt;
cmGeneratorExpression ge(lfbt);
cmGeneratorExpressionDAGChecker dagChecker(lfbt, this->GetName(),
"INTERFACE_LINK_LIBRARIES", 0, 0);
std::vector<std::string> ifaceLibs;
const char* newExplicitLibraries =
this->GetProperty("INTERFACE_LINK_LIBRARIES");
cmSystemTools::ExpandListArgument(
ge.Parse(newExplicitLibraries)->Evaluate(this->Makefile,
config,
false,
headTarget,
this, &dagChecker),
ifaceLibs);
if (ifaceLibs != impl->Libraries)
{
std::string oldLibraries;
std::string newLibraries;
const char *sep = "";
for(std::vector<std::string>::const_iterator it
= impl->Libraries.begin(); it != impl->Libraries.end(); ++it)
{
oldLibraries += sep;
oldLibraries += *it;
sep = ";";
}
sep = "";
for(std::vector<std::string>::const_iterator it
= ifaceLibs.begin(); it != ifaceLibs.end(); ++it)
{
newLibraries += sep;
newLibraries += *it;
sep = ";";
}
if(oldLibraries.empty())
{ oldLibraries = "(empty)"; }
if(newLibraries.empty())
{ newLibraries = "(empty)"; }
cmOStringStream w;
w <<
(this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0022)) << "\n"
"Target \"" << this->GetName() << "\" has an "
"INTERFACE_LINK_LIBRARIES property. "
"This should be preferred as the source of the link interface "
"for this library but because CMP0022 is not set CMake is "
"ignoring the property and using the link implementation "
"as the link interface instead."
"\n"
"INTERFACE_LINK_LIBRARIES:\n"
" " << newLibraries << "\n"
"Link implementation:\n"
" " << oldLibraries << "\n";
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
this->Internal->PolicyWarnedCMP0022 = true;
}
}
}
if(this->GetType() == cmTarget::STATIC_LIBRARY)

8
Source/cmTargetLinkLibrariesCommand.cxx
View File

@ -390,7 +390,13 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const char* lib,
{
this->Makefile
->AddLinkLibraryForTarget(this->Target->GetName(), lib, llt);
if (this->CurrentProcessingState != ProcessingKeywordPublicInterface
if(this->CurrentProcessingState == ProcessingLinkLibraries)
{
this->Target->AppendProperty("INTERFACE_LINK_LIBRARIES",
this->Target->GetDebugGeneratorExpressions(lib, llt).c_str());
return true;
}
else if(this->CurrentProcessingState != ProcessingKeywordPublicInterface
&& this->CurrentProcessingState != ProcessingPlainPublicInterface)
{
if (this->Target->GetType() == cmTarget::STATIC_LIBRARY)

7
Tests/CMakeCommands/target_link_libraries/cmp0022/CMakeLists.txt
View File

@ -28,3 +28,10 @@ endif()
add_executable(staticlib_exe staticlib_exe.cpp)
target_link_libraries(staticlib_exe staticlib1)
add_library(onlyplainlib1 SHARED onlyplainlib1.cpp)
add_library(onlyplainlib2 SHARED onlyplainlib2.cpp)
target_link_libraries(onlyplainlib2 onlyplainlib1)
add_executable(onlyplainlib_user onlyplainlib_user.cpp)
target_link_libraries(onlyplainlib_user onlyplainlib2)

13
Tests/CMakeCommands/target_link_libraries/cmp0022/onlyplainlib1.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "onlyplainlib1.h"
OnlyPlainLib1::OnlyPlainLib1()
: result(0)
{
}
int OnlyPlainLib1::GetResult()
{
return result;
}

14
Tests/CMakeCommands/target_link_libraries/cmp0022/onlyplainlib1.h Normal file
View File

@ -0,0 +1,14 @@
struct
#ifdef _WIN32
__declspec(dllexport)
#endif
OnlyPlainLib1
{
OnlyPlainLib1();
int GetResult();
private:
int result;
};

8
Tests/CMakeCommands/target_link_libraries/cmp0022/onlyplainlib2.cpp Normal file
View File

@ -0,0 +1,8 @@
#include "onlyplainlib2.h"
OnlyPlainLib1 onlyPlainLib2()
{
OnlyPlainLib1 opl1;
return opl1;
}

7
Tests/CMakeCommands/target_link_libraries/cmp0022/onlyplainlib2.h Normal file
View File

@ -0,0 +1,7 @@
#include "onlyplainlib1.h"
#ifdef _WIN32
__declspec(dllexport)
#endif
OnlyPlainLib1 onlyPlainLib2();

7
Tests/CMakeCommands/target_link_libraries/cmp0022/onlyplainlib_user.cpp Normal file
View File

@ -0,0 +1,7 @@
#include "onlyplainlib2.h"
int main(int argc, char **argv)
{
return onlyPlainLib2().GetResult();
}

1
Tests/RunCMake/CMP0022/CMP0022-NOWARN-exe-stderr.txt Normal file
View File

@ -0,0 +1 @@
^$

7
Tests/RunCMake/CMP0022/CMP0022-NOWARN-exe.cmake Normal file
View File

@ -0,0 +1,7 @@
enable_language(CXX)
add_library(testLib empty_vs6_1.cpp)
add_executable(testExe empty_vs6_2.cpp)
target_link_libraries(testExe testLib)
export(TARGETS testExe FILE "${CMAKE_CURRENT_BINARY_DIR}/cmp0022NOWARN-exe.cmake")

1
Tests/RunCMake/CMP0022/CMP0022-NOWARN-shared-stderr.txt Normal file
View File

@ -0,0 +1 @@
^$

8
Tests/RunCMake/CMP0022/CMP0022-NOWARN-shared.cmake Normal file
View File

@ -0,0 +1,8 @@
enable_language(CXX)
add_library(foo SHARED empty_vs6_1.cpp)
add_library(bar SHARED empty_vs6_2.cpp)
target_link_libraries(bar foo)
add_executable(zot empty.cpp)
target_link_libraries(zot bar)

8
Tests/RunCMake/CMP0022/CMP0022-WARN-empty-old-stderr.txt
View File

@ -3,14 +3,16 @@ CMake Warning \(dev\) in CMakeLists.txt:
interface. Run "cmake --help-policy CMP0022" for policy details. Use the
cmake_policy command to set the policy and suppress this warning.
Target "bar" has a INTERFACE_LINK_LIBRARIES property which differs from its
LINK_INTERFACE_LIBRARIES properties.
Target "bar" has an INTERFACE_LINK_LIBRARIES property. This should be
preferred as the source of the link interface for this library but because
CMP0022 is not set CMake is ignoring the property and using the link
implementation as the link interface instead.
INTERFACE_LINK_LIBRARIES:
foo
LINK_INTERFACE_LIBRARIES:
Link implementation:
\(empty\)

8
Tests/RunCMake/CMP0022/CMP0022-WARN-static-stderr.txt
View File

@ -3,10 +3,10 @@ CMake Warning \(dev\) in CMakeLists.txt:
interface. Run "cmake --help-policy CMP0022" for policy details. Use the
cmake_policy command to set the policy and suppress this warning.
Static library target "bar" has a INTERFACE_LINK_LIBRARIES property. This
should be preferred as the source of the link interface for this library.
Ignoring the property and using the link implementation as the link
interface instead.
Target "bar" has an INTERFACE_LINK_LIBRARIES property. This should be
preferred as the source of the link interface for this library but because
CMP0022 is not set CMake is ignoring the property and using the link
implementation as the link interface instead.
INTERFACE_LINK_LIBRARIES:

6
Tests/RunCMake/CMP0022/CMP0022-WARN-stderr.txt
View File

@ -1,10 +1,10 @@
CMake Warning \(dev\) in CMakeLists.txt:
^CMake Warning \(dev\) in CMakeLists.txt:
Policy CMP0022 is not set: INTERFACE_LINK_LIBRARIES defines the link
interface. Run "cmake --help-policy CMP0022" for policy details. Use the
cmake_policy command to set the policy and suppress this warning.
Target "bar" has a INTERFACE_LINK_LIBRARIES property which differs from its
LINK_INTERFACE_LIBRARIES properties.
Target "bar" has an INTERFACE_LINK_LIBRARIES property which differs from
its LINK_INTERFACE_LIBRARIES properties.
INTERFACE_LINK_LIBRARIES:

4
Tests/RunCMake/CMP0022/CMP0022-WARN-tll-stderr.txt
View File

@ -3,8 +3,8 @@ CMake Warning \(dev\) in CMakeLists.txt:
interface. Run "cmake --help-policy CMP0022" for policy details. Use the
cmake_policy command to set the policy and suppress this warning.
Target "bar" has a INTERFACE_LINK_LIBRARIES property which differs from its
LINK_INTERFACE_LIBRARIES properties.
Target "bar" has an INTERFACE_LINK_LIBRARIES property which differs from
its LINK_INTERFACE_LIBRARIES properties.
INTERFACE_LINK_LIBRARIES:

5
Tests/RunCMake/CMP0022/CMP0022-WARN.cmake
View File

@ -9,3 +9,8 @@ set_property(TARGET bar PROPERTY LINK_INTERFACE_LIBRARIES bat)
add_library(user empty.cpp)
target_link_libraries(user bar)
# Use "bar" again with a different "head" target to check
# that the warning does not appear again.
add_library(user2 empty_vs6_3.cpp)
target_link_libraries(user2 bar)

1
Tests/RunCMake/CMP0022/CMP0022-export-exe-stderr.txt Normal file
View File

@ -0,0 +1 @@
^$

9
Tests/RunCMake/CMP0022/CMP0022-export-exe.cmake Normal file
View File

@ -0,0 +1,9 @@
enable_language(CXX)
cmake_policy(SET CMP0022 NEW)
add_library(testLib empty_vs6_1.cpp)
add_executable(testExe empty_vs6_2.cpp)
target_link_libraries(testExe testLib)
export(TARGETS testExe FILE "${CMAKE_CURRENT_BINARY_DIR}/cmp0022NEW-exe.cmake")

3
Tests/RunCMake/CMP0022/RunCMakeTest.cmake
View File

@ -4,7 +4,10 @@ run_cmake(CMP0022-WARN)
run_cmake(CMP0022-WARN-tll)
run_cmake(CMP0022-WARN-static)
run_cmake(CMP0022-WARN-empty-old)
run_cmake(CMP0022-NOWARN-exe)
run_cmake(CMP0022-NOWARN-shared)
run_cmake(CMP0022-NOWARN-static)
run_cmake(CMP0022-NOWARN-static-link_libraries)
run_cmake(CMP0022-export)
run_cmake(CMP0022-export-exe)
run_cmake(CMP0022-install-export)

1
Tests/RunCMake/CMP0022/empty_vs6_4.cpp Normal file
View File

@ -0,0 +1 @@
#include "empty.cpp"