CMake/Source/cmTarget.cxx

414 lines
13 KiB
C++
Raw Normal View History

2001-04-25 00:49:12 +04:00
/*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
2002-01-21 23:30:43 +03:00
Copyright (c) 2002 Insight Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
2001-04-25 00:49:12 +04:00
2002-01-21 23:30:43 +03:00
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
2001-04-25 00:49:12 +04:00
=========================================================================*/
#include "cmTarget.h"
#include "cmMakefile.h"
2002-05-01 22:00:21 +04:00
#include <map>
#include <set>
2002-05-04 00:34:05 +04:00
void cmTarget::GenerateSourceFilesFromSourceLists( cmMakefile &mf)
2001-04-25 00:49:12 +04:00
{
2001-05-23 19:31:43 +04:00
// this is only done for non install targets
if ((this->m_TargetType == cmTarget::INSTALL_FILES)
|| (this->m_TargetType == cmTarget::INSTALL_PROGRAMS))
2001-05-23 19:31:43 +04:00
{
return;
}
2001-04-25 00:49:12 +04:00
// for each src lists add the classes
for (std::vector<std::string>::const_iterator s = m_SourceLists.begin();
s != m_SourceLists.end(); ++s)
{
// replace any variables
std::string temps = *s;
mf.ExpandVariablesInString(temps);
// look for a srclist
if (mf.GetSources().find(temps) != mf.GetSources().end())
{
const std::vector<cmSourceFile*> &clsList =
2001-04-25 00:49:12 +04:00
mf.GetSources().find(temps)->second;
2001-06-13 21:49:24 +04:00
// if we ahave a limited build list, use it
2001-06-13 21:53:11 +04:00
m_SourceFiles.insert(m_SourceFiles.end(),
clsList.begin(),
clsList.end());
2001-04-25 00:49:12 +04:00
}
// if one wasn't found then assume it is a single class
else
{
cmSourceFile file;
file.SetIsAnAbstractClass(false);
file.SetName(temps.c_str(), mf.GetCurrentDirectory(),
mf.GetSourceExtensions(),
mf.GetHeaderExtensions());
m_SourceFiles.push_back(mf.AddSource(file));
2001-04-25 00:49:12 +04:00
}
}
// expand any link library variables whle we are at it
LinkLibraries::iterator p = m_LinkLibraries.begin();
for (;p != m_LinkLibraries.end(); ++p)
{
2002-05-01 22:00:21 +04:00
mf.ExpandVariablesInString(p->first);
}
2001-04-25 00:49:12 +04:00
}
2002-05-04 00:34:05 +04:00
void cmTarget::MergeLinkLibraries( cmMakefile& mf,
const char *selfname,
const LinkLibraries& libs )
{
// Only add on libraries we haven't added on before.
// Assumption: the global link libraries could only grow, never shrink
LinkLibraries::const_iterator i = libs.begin();
i += m_PrevLinkedLibraries.size();
for( ; i != libs.end(); ++i )
2002-05-04 00:34:05 +04:00
{
// We call this so that the dependencies get written to the cache
this->AddLinkLibrary( mf, selfname, i->first.c_str(), i->second );
2002-05-04 00:34:05 +04:00
}
m_PrevLinkedLibraries = libs;
2002-05-04 00:34:05 +04:00
}
void cmTarget::AddLinkDirectory(const char* d)
{
// Make sure we don't add unnecessary search directories.
if( std::find( m_LinkDirectories.begin(), m_LinkDirectories.end(), d )
== m_LinkDirectories.end() )
m_LinkDirectories.push_back( d );
}
2002-05-01 22:00:21 +04:00
void cmTarget::AddLinkLibrary(const std::string& lib,
LinkLibraryType llt)
{
m_LinkLibraries.push_back( std::pair<std::string, cmTarget::LinkLibraryType>(lib,llt) );
}
void cmTarget::AddLinkLibrary(cmMakefile& mf,
const char *target, const char* lib,
LinkLibraryType llt)
{
m_LinkLibraries.push_back( std::pair<std::string, cmTarget::LinkLibraryType>(lib,llt) );
2002-05-02 23:10:19 +04:00
if(llt != cmTarget::GENERAL)
{
std::string linkTypeName = lib;
2002-05-02 23:10:19 +04:00
linkTypeName += "_LINK_TYPE";
switch(llt)
{
case cmTarget::DEBUG:
mf.AddCacheDefinition(linkTypeName.c_str(),
"debug", "Library is used for debug links only",
cmCacheManager::STATIC);
2002-05-02 23:10:19 +04:00
break;
case cmTarget::OPTIMIZED:
mf.AddCacheDefinition(linkTypeName.c_str(),
"optimized", "Library is used for debug links only",
cmCacheManager::STATIC);
2002-05-02 23:10:19 +04:00
break;
}
}
// Add the explicit dependency information for this target. This is
// simply a set of libraries separated by ";". There should always
// be a trailing ";". These library names are not canonical, in that
// they may be "-framework x", "-ly", "/path/libz.a", etc.
std::string targetEntry = target;
targetEntry += "_LIB_DEPENDS";
std::string dependencies;
const char* old_val = mf.GetDefinition( targetEntry.c_str() );
if( old_val )
{
dependencies += old_val;
}
if( dependencies.find( lib ) == std::string::npos )
{
dependencies += lib;
dependencies += ";";
}
mf.AddCacheDefinition( targetEntry.c_str(), dependencies.c_str(),
"Dependencies for the target", cmCacheManager::STATIC );
}
bool cmTarget::HasCxx() const
{
for(std::vector<cmSourceFile*>::const_iterator i = m_SourceFiles.begin();
i != m_SourceFiles.end(); ++i)
{
if((*i)->GetSourceExtension() != "c")
{
return true;
}
}
return false;
}
2002-05-01 22:00:21 +04:00
2002-05-01 22:00:21 +04:00
void
cmTarget::AnalyzeLibDependencies( const cmMakefile& mf )
{
// There are two key parts of the dependency analysis: (1)
// determining the libraries in the link line, and (2) constructing
// the dependency graph for those libraries.
//
// The latter is done using the cache entries that record the
// dependencies of each library.
//
// The former is a more thorny issue, since it is not clear how to
// determine if two libraries listed on the link line refer to the a
// single library or not. For example, consider the link "libraries"
// /usr/lib/libtiff.so -ltiff
// Is this one library or two? The solution implemented here is the
// simplest (and probably the only practical) one: two libraries are
// the same if their "link strings" are identical. Thus, the two
// libraries above are considered distinct. This also means that for
// dependency analysis to be effective, the CMake user must specify
// libraries build by his project without using any linker flags or
// file extensions. That is,
// LINK_LIBRARIES( One Two )
// instead of
// LINK_LIBRARIES( -lOne ${binarypath}/libTwo.a )
// The former is probably what most users would do, but it never
// hurts to document the assumptions. :-) Therefore, in the analysis
// code, the "canonical name" of a library is simply its name as
// given to a LINK_LIBRARIES command.
2002-05-04 00:34:05 +04:00
//
// Also, we will leave the original link line intact; we will just add any
// dependencies that were missing.
2002-05-01 22:00:21 +04:00
typedef std::vector< std::string > LinkLine;
2002-05-04 00:34:05 +04:00
// The dependency map.
DependencyMap dep_map;
// Keeps track of which dependencies have already been emitted for a given
// target. This could be via this function, or because they were already
// satisfied on the original link line.
DependencyMap satisfied;
// If LIBRARY_OUTPUT_PATH is not set, then we must add search paths
// for all the new libraries added by the dependency analysis.
const char* libOutPath = mf.GetDefinition("LIBRARY_OUTPUT_PATH");
bool addLibDirs = (libOutPath==0 || strcmp(libOutPath,"")==0);
2002-05-04 00:34:05 +04:00
// 1. Determine the dependencies already satisfied by the original link
// line.
for(LinkLibraries::iterator lib = m_LinkLibraries.begin();
lib != m_LinkLibraries.end(); ++lib)
2002-05-01 22:00:21 +04:00
{
2002-05-04 00:34:05 +04:00
for( LinkLibraries::iterator lib2 = lib;
lib2 != m_LinkLibraries.end(); ++lib2)
2002-05-01 22:00:21 +04:00
{
2002-05-04 00:34:05 +04:00
satisfied[ lib->first ].insert( lib2->first );
2002-05-01 22:00:21 +04:00
}
}
2002-05-04 00:34:05 +04:00
// 2. Build the explicit dependency map
for(LinkLibraries::reverse_iterator lib = m_LinkLibraries.rbegin();
lib != m_LinkLibraries.rend(); ++lib)
2002-05-01 22:00:21 +04:00
{
2002-05-04 00:34:05 +04:00
this->GatherDependencies( mf, lib->first, dep_map );
2002-05-01 22:00:21 +04:00
}
2002-05-04 00:34:05 +04:00
// 3. Create the new link line by simply emitting any dependencies that are
// missing. Start from the back and keep adding.
std::set<cmStdString> done, visited;
std::vector<std::string> newLinkLibraries;
2002-05-04 00:34:05 +04:00
for(LinkLibraries::reverse_iterator lib = m_LinkLibraries.rbegin();
lib != m_LinkLibraries.rend(); ++lib)
2002-05-01 22:00:21 +04:00
{
2002-05-04 00:34:05 +04:00
// skip zero size library entries, this may happen
// if a variable expands to nothing.
if (lib->first.size() == 0) continue;
// Emit all the dependencies that are not already satisfied on the
// original link line.
if( dep_map.find(lib->first) != dep_map.end() ) // does it have dependencies?
2002-05-04 00:34:05 +04:00
{
const std::set<cmStdString>& dep_on = dep_map.find( lib->first )->second;
std::set<cmStdString>::const_iterator i;
for( i = dep_on.begin(); i != dep_on.end(); ++i )
{
if( satisfied[lib->first].end() == satisfied[lib->first].find( *i ) )
{
Emit( *i, dep_map, done, visited, newLinkLibraries );
}
}
2002-05-04 00:34:05 +04:00
}
}
// 4. Add the new libraries to the link line.
for( std::vector<std::string>::reverse_iterator k = newLinkLibraries.rbegin();
k != newLinkLibraries.rend(); ++k )
{
if( addLibDirs )
2002-05-01 22:00:21 +04:00
{
const char* libpath = mf.GetDefinition( k->c_str() );
if( libpath )
2002-05-01 22:00:21 +04:00
{
// Don't add a link directory that is already present.
if(std::find(m_LinkDirectories.begin(),
m_LinkDirectories.end(), libpath) == m_LinkDirectories.end())
2002-05-01 22:00:21 +04:00
{
m_LinkDirectories.push_back(libpath);
2002-05-01 22:00:21 +04:00
}
}
}
std::string linkType = *k;
linkType += "_LINK_TYPE";
cmTarget::LinkLibraryType llt = cmTarget::GENERAL;
const char* linkTypeString = mf.GetDefinition( linkType.c_str() );
if(linkTypeString)
{
if(strcmp(linkTypeString, "debug") == 0)
{
llt = cmTarget::DEBUG;
}
if(strcmp(linkTypeString, "optimized") == 0)
{
llt = cmTarget::OPTIMIZED;
}
}
m_LinkLibraries.push_back( std::make_pair(*k,llt) );
2002-05-01 22:00:21 +04:00
}
}
void cmTarget::Emit( const std::string& lib,
const DependencyMap& dep_map,
std::set<cmStdString>& emitted,
std::set<cmStdString>& visited,
2002-05-01 22:00:21 +04:00
std::vector<std::string>& link_line ) const
{
// It's already been emitted
if( emitted.find(lib) != emitted.end() )
{
2002-05-01 22:00:21 +04:00
return;
}
2002-05-01 22:00:21 +04:00
// If this library hasn't been visited before, then emit all its
// dependencies before emitting the library itself. If it has been
// visited before, then there is a dependency cycle. Just emit the
// library itself, and let the recursion that got us here deal with
// emitting the dependencies for the library.
if( visited.insert(lib).second )
{
if( dep_map.find(lib) != dep_map.end() ) // does it have dependencies?
{
const std::set<cmStdString>& dep_on = dep_map.find( lib )->second;
std::set<cmStdString>::const_iterator i;
2002-05-01 22:00:21 +04:00
for( i = dep_on.begin(); i != dep_on.end(); ++i )
{
Emit( *i, dep_map, emitted, visited, link_line );
}
}
}
link_line.push_back( lib );
emitted.insert(lib);
}
void cmTarget::GatherDependencies( const cmMakefile& mf,
const std::string& lib,
2002-05-04 00:34:05 +04:00
DependencyMap& dep_map )
2002-05-01 22:00:21 +04:00
{
// If the library is already in the dependency map, then it has
// already been fully processed.
if( dep_map.find(lib) != dep_map.end() )
return;
const char* deps = mf.GetDefinition( (lib+"_LIB_DEPENDS").c_str() );
if( deps && strcmp(deps,"") != 0 )
2002-05-01 22:00:21 +04:00
{
// Make sure this library is in the map, even if it has an empty
// set of dependencies. This distinguishes the case of explicitly
// no dependencies with that of unspecified dependencies.
dep_map[lib];
// Parse the dependency information, which is simply a set of
// libraries separated by ";". There is always a trailing ";".
std::string depline = deps;
std::string::size_type start = 0;
std::string::size_type end;
end = depline.find( ";", start );
while( end != std::string::npos )
{
std::string l = depline.substr( start, end-start );
if( l.size() != 0 )
{
2002-05-04 00:34:05 +04:00
dep_map[ lib ].insert( l );
GatherDependencies( mf, l, dep_map );
2002-05-01 22:00:21 +04:00
}
start = end+1; // skip the ;
end = depline.find( ";", start );
}
dep_map[lib].erase(lib); // cannot depend on itself
}
}
2002-05-04 00:34:05 +04:00
// return true if lib1 depends on lib2
2002-05-01 22:00:21 +04:00
bool cmTarget::DependsOn( const std::string& lib1, const std::string& lib2,
const DependencyMap& dep_map,
std::set<cmStdString>& visited ) const
2002-05-01 22:00:21 +04:00
{
if( !visited.insert( lib1 ).second )
2002-05-04 00:34:05 +04:00
{
2002-05-01 22:00:21 +04:00
return false; // already visited here
2002-05-04 00:34:05 +04:00
}
2002-05-01 22:00:21 +04:00
if( lib1 == lib2 )
2002-05-04 00:34:05 +04:00
{
2002-05-01 22:00:21 +04:00
return false;
2002-05-04 00:34:05 +04:00
}
2002-05-01 22:00:21 +04:00
if( dep_map.find(lib1) == dep_map.end() )
2002-05-04 00:34:05 +04:00
{
2002-05-01 22:00:21 +04:00
return false; // lib1 doesn't have any dependencies
2002-05-04 00:34:05 +04:00
}
2002-05-01 22:00:21 +04:00
const std::set<cmStdString>& dep_set = dep_map.find(lib1)->second;
2002-05-01 22:00:21 +04:00
if( dep_set.end() != dep_set.find( lib2 ) )
2002-05-04 00:34:05 +04:00
{
2002-05-01 22:00:21 +04:00
return true; // lib1 doesn't directly depend on lib2.
2002-05-04 00:34:05 +04:00
}
2002-05-01 22:00:21 +04:00
// Do a recursive check: does lib1 depend on x which depends on lib2?
for( std::set<cmStdString>::const_iterator itr = dep_set.begin();
2002-05-01 22:00:21 +04:00
itr != dep_set.end(); ++itr )
{
2002-05-04 00:34:05 +04:00
if( this->DependsOn( *itr, lib2, dep_map, visited ) )
{
2002-05-01 22:00:21 +04:00
return true;
2002-05-04 00:34:05 +04:00
}
2002-05-01 22:00:21 +04:00
}
return false;
}