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

Merge branch 'cleanup-object-file-names' into object-library

This commit is contained in:
Brad King 2012-03-09 15:15:37 -05:00
parent c7bdef5b48 0996f2a228
commit 51b67366ed
18 changed files with 76 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
Source/cmGlobalXCodeGenerator.cxx
View File

@ -179,8 +179,6 @@ void cmGlobalXCodeGenerator::EnableLanguage(std::vector<std::string>const&
mf->AddDefinition("CMAKE_GENERATOR_CC", "gcc");
mf->AddDefinition("CMAKE_GENERATOR_CXX", "g++");
mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
// initialize Architectures so it can be used by
// GetTargetObjectFileDirectories
this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
const char* osxArch =
mf->GetDefinition("CMAKE_OSX_ARCHITECTURES");
@ -3362,37 +3360,6 @@ std::string cmGlobalXCodeGenerator::XCodeEscapePath(const char* p)
return ret;
}
//----------------------------------------------------------------------------
void cmGlobalXCodeGenerator::
GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>&
dirs)
{
std::string dir = this->CurrentMakefile->GetCurrentOutputDirectory();
dir += "/";
dir += this->CurrentMakefile->GetProjectName();
dir += ".build/";
dir += this->GetCMakeCFGInitDirectory();
dir += "/";
dir += target->GetName();
dir += ".build/Objects-normal/";
std::string dirsave = dir;
if(this->Architectures.size())
{
for(std::vector<std::string>::iterator i = this->Architectures.begin();
i != this->Architectures.end(); ++i)
{
dir += *i;
dirs.push_back(dir);
dir = dirsave;
}
}
else
{
dirs.push_back(dir);
}
}
//----------------------------------------------------------------------------
void
cmGlobalXCodeGenerator

3
Source/cmGlobalXCodeGenerator.h
View File

@ -76,9 +76,6 @@ public:
///! What is the configurations directory variable called?
virtual const char* GetCMakeCFGInitDirectory();
void GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>&
dirs);
void SetCurrentLocalGenerator(cmLocalGenerator*);
/** Return true if the generated build tree may contain multiple builds.

11
Source/cmLocalGenerator.cxx
View File

@ -2963,17 +2963,6 @@ cmLocalGenerator::GetTargetDirectory(cmTarget const&) const
return "";
}
//----------------------------------------------------------------------------
void
cmLocalGenerator::GetTargetObjectFileDirectories(cmTarget* ,
std::vector<std::string>&
)
{
cmSystemTools::Error("GetTargetObjectFileDirectories"
" called on cmLocalGenerator");
}
//----------------------------------------------------------------------------
unsigned int cmLocalGenerator::GetBackwardsCompatibility()
{

8
Source/cmLocalGenerator.h
View File

@ -261,14 +261,6 @@ public:
};
FortranFormat GetFortranFormat(const char* value);
/** Return the directories into which object files will be put.
* There maybe more than one for fat binary systems like OSX.
*/
virtual void
GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>&
dirs);
/**
* Convert the given remote path to a relative path with respect to
* the given local path. The local path must be given in component

25
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -144,6 +144,20 @@ void cmLocalUnixMakefileGenerator3::Generate()
this->WriteDirectoryInformationFile();
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::AddLocalObjectFile(
cmTarget* target, cmSourceFile* sf, std::string objNoTargetDir,
bool hasSourceExtension)
{
if(cmSystemTools::FileIsFullPath(objNoTargetDir.c_str()))
{
objNoTargetDir = cmSystemTools::GetFilenameName(objNoTargetDir);
}
LocalObjectInfo& info = this->LocalObjectFiles[objNoTargetDir];
info.HasSourceExtension = hasSourceExtension;
info.push_back(LocalObjectEntry(target, sf->GetLanguage()));
}
//----------------------------------------------------------------------------
void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets
(std::vector<std::string>& targets)
@ -2267,14 +2281,3 @@ void cmLocalUnixMakefileGenerator3
}
}
}
void cmLocalUnixMakefileGenerator3
::GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>& dirs)
{
std::string dir = this->Makefile->GetCurrentOutputDirectory();
dir += "/";
dir += this->GetTargetDirectory(*target);
dirs.push_back(dir);
}

47
Source/cmLocalUnixMakefileGenerator3.h
View File

@ -225,24 +225,9 @@ public:
// write the target rules for the local Makefile into the stream
void WriteLocalAllRules(std::ostream& ruleFileStream);
struct LocalObjectEntry
{
cmTarget* Target;
std::string Language;
LocalObjectEntry(): Target(0), Language() {}
LocalObjectEntry(cmTarget* t, const char* lang):
Target(t), Language(lang) {}
};
struct LocalObjectInfo: public std::vector<LocalObjectEntry>
{
bool HasSourceExtension;
bool HasPreprocessRule;
bool HasAssembleRule;
LocalObjectInfo():HasSourceExtension(false), HasPreprocessRule(false),
HasAssembleRule(false) {}
};
std::map<cmStdString, LocalObjectInfo> const& GetLocalObjectFiles()
{ return this->LocalObjectFiles;}
void AddLocalObjectFile(cmTarget* target, cmSourceFile* sf,
std::string objNoTargetDir,
bool hasSourceExtension);
std::vector<cmStdString> const& GetLocalHelp() { return this->LocalHelp; }
@ -257,9 +242,6 @@ public:
{
return !this->SkipAssemblySourceRules;
}
// Get the directories into which the .o files will go for this target
void GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>& dirs);
// Fill the vector with the target names for the object files,
// preprocessed files and assembly files. Currently only used by the
@ -301,9 +283,6 @@ protected:
void WriteTargetRequiresRule(std::ostream& ruleFileStream,
cmTarget& target,
const std::vector<std::string>& objects);
void WriteObjectConvenienceRule(std::ostream& ruleFileStream,
const char* comment, const char* output,
LocalObjectInfo const& info);
std::string GetObjectFileName(cmTarget& target,
const cmSourceFile& source,
@ -378,7 +357,27 @@ private:
bool SkipPreprocessedSourceRules;
bool SkipAssemblySourceRules;
struct LocalObjectEntry
{
cmTarget* Target;
std::string Language;
LocalObjectEntry(): Target(0), Language() {}
LocalObjectEntry(cmTarget* t, const char* lang):
Target(t), Language(lang) {}
};
struct LocalObjectInfo: public std::vector<LocalObjectEntry>
{
bool HasSourceExtension;
bool HasPreprocessRule;
bool HasAssembleRule;
LocalObjectInfo():HasSourceExtension(false), HasPreprocessRule(false),
HasAssembleRule(false) {}
};
std::map<cmStdString, LocalObjectInfo> LocalObjectFiles;
void WriteObjectConvenienceRule(std::ostream& ruleFileStream,
const char* comment, const char* output,
LocalObjectInfo const& info);
std::vector<cmStdString> LocalHelp;
/* does the work for each target */

13
Source/cmLocalVisualStudio6Generator.cxx
View File

@ -337,7 +337,7 @@ void cmLocalVisualStudio6Generator::WriteDSPFile(std::ostream& fout,
}
// Compute which sources need unique object computation.
this->ComputeObjectNameRequirements(sourceGroups);
this->ComputeObjectNameRequirements(classes);
// Write the DSP file's header.
this->WriteDSPHeader(fout, libName, target, sourceGroups);
@ -1795,17 +1795,6 @@ cmLocalVisualStudio6Generator
return "";
}
void cmLocalVisualStudio6Generator
::GetTargetObjectFileDirectories(cmTarget* ,
std::vector<std::string>&
dirs)
{
std::string dir = this->Makefile->GetCurrentOutputDirectory();
dir += "/";
dir += this->GetGlobalGenerator()->GetCMakeCFGInitDirectory();
dirs.push_back(dir);
}
std::string
cmLocalVisualStudio6Generator
::GetConfigName(std::string const& configuration) const

3
Source/cmLocalVisualStudio6Generator.h
View File

@ -50,9 +50,6 @@ public:
void SetBuildType(BuildType, const char* libName, cmTarget&);
virtual std::string GetTargetDirectory(cmTarget const& target) const;
void GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>&
dirs);
private:
std::string DSPHeaderTemplate;
std::string DSPFooterTemplate;

15
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -1311,7 +1311,7 @@ void cmLocalVisualStudio7Generator::WriteVCProjFile(std::ostream& fout,
}
// Compute which sources need unique object computation.
this->ComputeObjectNameRequirements(sourceGroups);
this->ComputeObjectNameRequirements(classes);
// open the project
this->WriteProjectStart(fout, libName, target, sourceGroups);
@ -2118,19 +2118,6 @@ std::string cmLocalVisualStudio7Generator
return dir;
}
void cmLocalVisualStudio7Generator::
GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>&
dirs)
{
std::string dir = this->Makefile->GetCurrentOutputDirectory();
dir += "/";
dir += this->GetTargetDirectory(*target);
dir += "/";
dir += this->GetGlobalGenerator()->GetCMakeCFGInitDirectory();
dirs.push_back(dir);
}
//----------------------------------------------------------------------------
#include <windows.h>
static bool cmLVS6G_IsFAT(const char* dir)

3
Source/cmLocalVisualStudio7Generator.h
View File

@ -54,9 +54,6 @@ public:
void SetBuildType(BuildType,const char *name);
void SetPlatformName(const char* n) { this->PlatformName = n;}
void GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>&
dirs);
void SetExtraFlagTable(cmVS7FlagTable const* table)
{ this->ExtraFlagTable = table; }

93
Source/cmLocalVisualStudioGenerator.cxx
View File

@ -83,75 +83,48 @@ bool cmLocalVisualStudioGenerator::SourceFileCompiles(const cmSourceFile* sf)
}
//----------------------------------------------------------------------------
void cmLocalVisualStudioGenerator::CountObjectNames(
const std::vector<cmSourceGroup>& groups,
std::map<cmStdString, int>& counts)
{
for(unsigned int i = 0; i < groups.size(); ++i)
{
cmSourceGroup sg = groups[i];
std::vector<const cmSourceFile*> const& srcs = sg.GetSourceFiles();
for(std::vector<const cmSourceFile*>::const_iterator s = srcs.begin();
s != srcs.end(); ++s)
{
const cmSourceFile* sf = *s;
if(this->SourceFileCompiles(sf))
{
std::string objectName = cmSystemTools::LowerCase(
cmSystemTools::GetFilenameWithoutLastExtension(
sf->GetFullPath()));
objectName += ".obj";
counts[objectName] += 1;
}
}
this->CountObjectNames(sg.GetGroupChildren(), counts);
}
}
//----------------------------------------------------------------------------
void cmLocalVisualStudioGenerator::InsertNeedObjectNames(
const std::vector<cmSourceGroup>& groups,
std::map<cmStdString, int>& count)
{
for(unsigned int i = 0; i < groups.size(); ++i)
{
cmSourceGroup sg = groups[i];
std::vector<const cmSourceFile*> const& srcs = sg.GetSourceFiles();
for(std::vector<const cmSourceFile*>::const_iterator s = srcs.begin();
s != srcs.end(); ++s)
{
const cmSourceFile* sf = *s;
if(this->SourceFileCompiles(sf))
{
std::string objectName = cmSystemTools::LowerCase(
cmSystemTools::GetFilenameWithoutLastExtension(sf->GetFullPath()));
objectName += ".obj";
if(count[objectName] > 1)
{
this->NeedObjectName.insert(sf);
}
}
}
this->InsertNeedObjectNames(sg.GetGroupChildren(), count);
}
}
//----------------------------------------------------------------------------
void cmLocalVisualStudioGenerator::ComputeObjectNameRequirements
(std::vector<cmSourceGroup> const& sourceGroups)
void
cmLocalVisualStudioGenerator::ComputeObjectNameRequirements(
std::vector<cmSourceFile*> const& sources
)
{
// Clear the current set of requirements.
this->NeedObjectName.clear();
// Count the number of object files with each name. Note that
// windows file names are not case sensitive.
std::map<cmStdString, int> objectNameCounts;
this->CountObjectNames(sourceGroups, objectNameCounts);
std::map<cmStdString, int> counts;
for(std::vector<cmSourceFile*>::const_iterator s = sources.begin();
s != sources.end(); ++s)
{
const cmSourceFile* sf = *s;
if(this->SourceFileCompiles(sf))
{
std::string objectName = cmSystemTools::LowerCase(
cmSystemTools::GetFilenameWithoutLastExtension(
sf->GetFullPath()));
objectName += ".obj";
counts[objectName] += 1;
}
}
// For all source files producing duplicate names we need unique
// object name computation.
this->InsertNeedObjectNames(sourceGroups, objectNameCounts);
for(std::vector<cmSourceFile*>::const_iterator s = sources.begin();
s != sources.end(); ++s)
{
const cmSourceFile* sf = *s;
if(this->SourceFileCompiles(sf))
{
std::string objectName = cmSystemTools::LowerCase(
cmSystemTools::GetFilenameWithoutLastExtension(sf->GetFullPath()));
objectName += ".obj";
if(counts[objectName] > 1)
{
this->NeedObjectName.insert(sf);
}
}
}
}
//----------------------------------------------------------------------------

6
Source/cmLocalVisualStudioGenerator.h
View File

@ -65,12 +65,8 @@ protected:
MaybeCreateImplibDir(cmTarget& target, const char* config, bool isFortran);
// Safe object file name generation.
void ComputeObjectNameRequirements(std::vector<cmSourceGroup> const&);
void ComputeObjectNameRequirements(std::vector<cmSourceFile*> const&);
bool SourceFileCompiles(const cmSourceFile* sf);
void CountObjectNames(const std::vector<cmSourceGroup>& groups,
std::map<cmStdString, int>& count);
void InsertNeedObjectNames(const std::vector<cmSourceGroup>& groups,
std::map<cmStdString, int>& count);
std::set<const cmSourceFile*> NeedObjectName;
friend class cmVisualStudio10TargetGenerator;

13
Source/cmLocalXCodeGenerator.cxx
View File

@ -33,16 +33,3 @@ cmLocalXCodeGenerator::GetTargetDirectory(cmTarget const&) const
// No per-target directory for this generator (yet).
return "";
}
//----------------------------------------------------------------------------
void cmLocalXCodeGenerator::
GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>&
dirs)
{
cmGlobalXCodeGenerator* g =
(cmGlobalXCodeGenerator*)this->GetGlobalGenerator();
g->SetCurrentLocalGenerator(this);
g->GetTargetObjectFileDirectories(target,
dirs);
}

3
Source/cmLocalXCodeGenerator.h
View File

@ -27,9 +27,6 @@ public:
cmLocalXCodeGenerator();
virtual ~cmLocalXCodeGenerator();
void GetTargetObjectFileDirectories(cmTarget* target,
std::vector<std::string>&
dirs);
virtual std::string GetTargetDirectory(cmTarget const& target) const;
private:

12
Source/cmMakefileTargetGenerator.cxx
View File

@ -489,16 +489,8 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(cmSourceFile& source)
srcFullPath.c_str());
// add this to the list of objects for this local generator
if(cmSystemTools::FileIsFullPath(objNoTargetDir.c_str()))
{
objNoTargetDir = cmSystemTools::GetFilenameName(objNoTargetDir);
}
cmLocalUnixMakefileGenerator3::LocalObjectInfo& info =
this->LocalGenerator->LocalObjectFiles[objNoTargetDir];
info.HasSourceExtension = hasSourceExtension;
info.push_back(
cmLocalUnixMakefileGenerator3::LocalObjectEntry(this->Target, lang)
);
this->LocalGenerator->AddLocalObjectFile(
this->Target, &source, objNoTargetDir, hasSourceExtension);
}
//----------------------------------------------------------------------------

59
Source/cmTarget.cxx
View File

@ -1101,17 +1101,6 @@ void cmTarget::DefineProperties(cmake *cm)
"better if VS_GLOBAL_QtVersion is set to the version "
"FindQt4.cmake found. For example, \"4.7.3\"");
#if 0
cm->DefineProperty
("OBJECT_FILES", cmProperty::TARGET,
"Used to get the resulting list of object files that make up a "
"target.",
"This can be used to put object files from one library "
"into another library. It is a read only property. It "
"converts the source list for the target into a list of full "
"paths to object names that will be produced by the target.");
#endif
#define CM_TARGET_FILE_TYPES_DOC \
"There are three kinds of target files that may be built: " \
"archive, library, and runtime. " \
@ -2612,54 +2601,6 @@ const char *cmTarget::GetProperty(const char* prop)
return this->GetProperty(prop, cmProperty::TARGET);
}
//----------------------------------------------------------------------------
void cmTarget::ComputeObjectFiles()
{
if (this->IsImported())
{
return;
}
#if 0
std::vector<std::string> dirs;
this->Makefile->GetLocalGenerator()->
GetTargetObjectFileDirectories(this,
dirs);
std::string objectFiles;
std::string objExtensionLookup1 = "CMAKE_";
std::string objExtensionLookup2 = "_OUTPUT_EXTENSION";
for(std::vector<std::string>::iterator d = dirs.begin();
d != dirs.end(); ++d)
{
for(std::vector<cmSourceFile*>::iterator s = this->SourceFiles.begin();
s != this->SourceFiles.end(); ++s)
{
cmSourceFile* sf = *s;
if(const char* lang = sf->GetLanguage())
{
std::string lookupObj = objExtensionLookup1 + lang;
lookupObj += objExtensionLookup2;
const char* obj = this->Makefile->GetDefinition(lookupObj.c_str());
if(obj)
{
if(objectFiles.size())
{
objectFiles += ";";
}
std::string objFile = *d;
objFile += "/";
objFile += this->Makefile->GetLocalGenerator()->
GetSourceObjectName(*sf);
objFile += obj;
objectFiles += objFile;
}
}
}
}
this->SetProperty("OBJECT_FILES", objectFiles.c_str());
#endif
}
//----------------------------------------------------------------------------
const char *cmTarget::GetProperty(const char* prop,
cmProperty::ScopeType scope)

3
Source/cmTarget.h
View File

@ -403,9 +403,6 @@ public:
// Define the properties
static void DefineProperties(cmake *cm);
// Compute the OBJECT_FILES property only when requested
void ComputeObjectFiles();
/** Get the macro to define when building sources in this target.
If no macro should be defined null is returned. */
const char* GetExportMacro();

8
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -877,9 +877,6 @@ void cmVisualStudio10TargetGenerator::WriteCLSources()
void cmVisualStudio10TargetGenerator::ComputeObjectNames()
{
// We may be modifying the source groups temporarily, so make a copy.
std::vector<cmSourceGroup> sourceGroups = this->Makefile->GetSourceGroups();
// get the classes from the source lists then add them to the groups
std::vector<cmSourceFile*>const & classes = this->Target->GetSourceFiles();
for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
@ -891,13 +888,10 @@ void cmVisualStudio10TargetGenerator::ComputeObjectNames()
{
this->ModuleDefinitionFile = (*i)->GetFullPath();
}
cmSourceGroup& sourceGroup =
this->Makefile->FindSourceGroup(source.c_str(), sourceGroups);
sourceGroup.AssignSource(*i);
}
// Compute which sources need unique object computation.
this->LocalGenerator->ComputeObjectNameRequirements(sourceGroups);
this->LocalGenerator->ComputeObjectNameRequirements(classes);
}
bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags(