Browse Source
ENH: Started new makefile generator implementation. It will temporarily be called cmLocalUnixMakefileGenerator2 until it is ready to replace the original completely.
pull/1/head
ENH: Started new makefile generator implementation. It will temporarily be called cmLocalUnixMakefileGenerator2 until it is ready to replace the original completely.
pull/1/head
Brad King
21 years ago
2 changed files with 534 additions and 0 deletions
@ -0,0 +1,471 @@ |
|||
/*=========================================================================
|
|||
|
|||
Program: CMake - Cross-Platform Makefile Generator |
|||
Module: $RCSfile$ |
|||
Language: C++ |
|||
Date: $Date$ |
|||
Version: $Revision$ |
|||
|
|||
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. |
|||
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
|
|||
|
|||
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. |
|||
|
|||
=========================================================================*/ |
|||
#include "cmLocalUnixMakefileGenerator2.h"
|
|||
|
|||
#include "cmGeneratedFileStream.h"
|
|||
#include "cmGlobalGenerator.h"
|
|||
#include "cmMakefile.h"
|
|||
#include "cmSourceFile.h"
|
|||
|
|||
//----------------------------------------------------------------------------
|
|||
cmLocalUnixMakefileGenerator2::cmLocalUnixMakefileGenerator2() |
|||
{ |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------
|
|||
cmLocalUnixMakefileGenerator2::~cmLocalUnixMakefileGenerator2() |
|||
{ |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------
|
|||
void cmLocalUnixMakefileGenerator2::Generate(bool fromTheTop) |
|||
{ |
|||
// TODO: Account for control-c during Makefile generation.
|
|||
|
|||
// Generate old style for now.
|
|||
this->cmLocalUnixMakefileGenerator::Generate(fromTheTop); |
|||
|
|||
// Generate the rule files for each target.
|
|||
const cmTargets& targets = m_Makefile->GetTargets(); |
|||
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t) |
|||
{ |
|||
this->GenerateTargetRuleFile(t->second); |
|||
} |
|||
|
|||
// Generate the main makefile.
|
|||
this->GenerateMakefile(); |
|||
|
|||
// Generate the cmake file that keeps the makefile up to date.
|
|||
this->GenerateCMakefile(); |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------
|
|||
void cmLocalUnixMakefileGenerator2::GenerateMakefile() |
|||
{ |
|||
std::string makefileName = m_Makefile->GetStartOutputDirectory(); |
|||
makefileName += "/Makefile2"; |
|||
std::string cmakefileName = makefileName; |
|||
cmakefileName += ".cmake"; |
|||
|
|||
// Open the output files.
|
|||
std::ofstream makefileStream(makefileName.c_str()); |
|||
if(!makefileStream) |
|||
{ |
|||
cmSystemTools::Error("Error can not open for write: ", |
|||
makefileName.c_str()); |
|||
cmSystemTools::ReportLastSystemError(""); |
|||
return; |
|||
} |
|||
|
|||
// Write the do not edit header.
|
|||
this->WriteDisclaimer(makefileStream); |
|||
|
|||
// Write some rules to make things look nice.
|
|||
makefileStream |
|||
<< "# Disable some common implicit rules to speed things up.\n" |
|||
<< ".SUFFIXES:\n" |
|||
<< ".SUFFIXES:.hpuxmakemusthaverule\n\n"; |
|||
|
|||
// Write standard variables to the makefile.
|
|||
this->OutputMakeVariables(makefileStream); |
|||
|
|||
// Build command to run CMake to check if anything needs regenerating.
|
|||
std::string runRule = |
|||
"@$(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)"; |
|||
runRule += " --check-rerun "; |
|||
runRule += this->ConvertToRelativeOutputPath(cmakefileName.c_str()); |
|||
|
|||
// Most unix makes will pass the command line flags to make down to
|
|||
// sub-invoked makes via an environment variable. However, some
|
|||
// makes do not support that, so you have to pass the flags
|
|||
// explicitly.
|
|||
const char* depRule = "$(MAKE) -f Makefile2 $(MAKESILENT) all.depends"; |
|||
const char* allRule = "$(MAKE) -f Makefile2 $(MAKESILENT) all"; |
|||
if(m_PassMakeflags) |
|||
{ |
|||
depRule = "$(MAKE) -f Makefile2 $(MAKESILENT) -$(MAKEFLAGS) all.depends"; |
|||
allRule = "$(MAKE) -f Makefile2 $(MAKESILENT) -$(MAKEFLAGS) all"; |
|||
} |
|||
|
|||
// Write the main entry point target. This must be the VERY first
|
|||
// target so that make with no arguments will run it.
|
|||
{ |
|||
std::vector<std::string> depends; |
|||
std::vector<std::string> commands; |
|||
//commands.push_back(runRule);
|
|||
commands.push_back(depRule); |
|||
commands.push_back(allRule); |
|||
this->OutputMakeRule( |
|||
makefileStream, |
|||
"Default target executed when no arguments are given to make.", |
|||
"default_target", |
|||
depends, |
|||
commands); |
|||
} |
|||
|
|||
// Write special target to silence make output. This must be after
|
|||
// the default target in case VERBOSE is set (which changes the name).
|
|||
if(!m_Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE")) |
|||
{ |
|||
makefileStream |
|||
<< "# Suppress display of executed commands.\n" |
|||
<< "$(VERBOSE).SILENT:\n\n"; |
|||
} |
|||
|
|||
// Get the set of targets.
|
|||
const cmTargets& targets = m_Makefile->GetTargets(); |
|||
|
|||
// Output top level dependency rule.
|
|||
{ |
|||
std::vector<std::string> depends; |
|||
std::vector<std::string> commands; |
|||
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t) |
|||
{ |
|||
if(t->second.IsInAll()) |
|||
{ |
|||
std::string dep = this->GetTargetDirectory(t->second); |
|||
dep += "/"; |
|||
dep += t->first; |
|||
dep += ".depends"; |
|||
depends.push_back(dep); |
|||
} |
|||
} |
|||
this->OutputMakeRule(makefileStream, "all dependencies", "all.depends", |
|||
depends, commands); |
|||
} |
|||
|
|||
// Output top level build rule.
|
|||
{ |
|||
std::vector<std::string> depends; |
|||
std::vector<std::string> commands; |
|||
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t) |
|||
{ |
|||
if(t->second.IsInAll()) |
|||
{ |
|||
depends.push_back(t->first+".requires"); |
|||
} |
|||
} |
|||
this->OutputMakeRule(makefileStream, "all", "all", |
|||
depends, commands); |
|||
} |
|||
|
|||
// Write include statements to get rules for each target.
|
|||
makefileStream |
|||
<< "# Include target rule files.\n"; |
|||
for(cmTargets::const_iterator t = targets.begin(); t != targets.end(); ++t) |
|||
{ |
|||
std::string ruleFileName = this->GetTargetDirectory(t->second); |
|||
ruleFileName += "/"; |
|||
ruleFileName += t->first; |
|||
ruleFileName += ".make"; |
|||
makefileStream |
|||
<< m_IncludeDirective << " " |
|||
<< this->ConvertToOutputForExisting(ruleFileName.c_str()).c_str() |
|||
<< "\n"; |
|||
} |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------
|
|||
void cmLocalUnixMakefileGenerator2::GenerateCMakefile() |
|||
{ |
|||
std::string makefileName = m_Makefile->GetStartOutputDirectory(); |
|||
makefileName += "/Makefile2"; |
|||
std::string cmakefileName = makefileName; |
|||
cmakefileName += ".cmake"; |
|||
|
|||
// Open the output file.
|
|||
std::ofstream cmakefileStream(cmakefileName.c_str()); |
|||
if(!cmakefileStream) |
|||
{ |
|||
cmSystemTools::Error("Error can not open for write: ", |
|||
cmakefileName.c_str()); |
|||
cmSystemTools::ReportLastSystemError(""); |
|||
return; |
|||
} |
|||
|
|||
// Write the do not edit header.
|
|||
this->WriteDisclaimer(cmakefileStream); |
|||
|
|||
// Get the list of files contributing to this generation step.
|
|||
// Sort the list and remove duplicates.
|
|||
std::vector<std::string> lfiles = m_Makefile->GetListFiles(); |
|||
std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>()); |
|||
std::vector<std::string>::iterator new_end = std::unique(lfiles.begin(), |
|||
lfiles.end()); |
|||
lfiles.erase(new_end, lfiles.end()); |
|||
|
|||
// Save the list to the cmake file.
|
|||
cmakefileStream |
|||
<< "# The corresponding makefile\n" |
|||
<< "# \"" << makefileName << "\"\n" |
|||
<< "# was generated from the following files:\n" |
|||
<< "SET(CMAKE_MAKEFILE_DEPENDS\n" |
|||
<< " \"" << m_Makefile->GetHomeOutputDirectory() << "/CMakeCache.txt\"\n"; |
|||
for(std::vector<std::string>::const_iterator i = lfiles.begin(); |
|||
i != lfiles.end(); ++i) |
|||
{ |
|||
cmakefileStream |
|||
<< " \"" << i->c_str() << "\"\n"; |
|||
} |
|||
cmakefileStream |
|||
<< " )\n\n"; |
|||
|
|||
// Set the corresponding makefile in the cmake file.
|
|||
cmakefileStream |
|||
<< "# The corresponding makefile is:\n" |
|||
<< "SET(CMAKE_MAKEFILE_OUTPUTS\n" |
|||
<< " \"" << makefileName.c_str() << "\"\n" |
|||
<< " )\n"; |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------
|
|||
void |
|||
cmLocalUnixMakefileGenerator2 |
|||
::GenerateTargetRuleFile(const cmTarget& target) |
|||
{ |
|||
// Create a directory for this target.
|
|||
std::string dir = this->GetTargetDirectory(target); |
|||
cmSystemTools::MakeDirectory(dir.c_str()); |
|||
|
|||
// First generate the object rule files. Save a list of all object
|
|||
// files for this target.
|
|||
std::vector<std::string> objects; |
|||
const std::vector<cmSourceFile*>& sources = target.GetSourceFiles(); |
|||
for(std::vector<cmSourceFile*>::const_iterator source = sources.begin(); |
|||
source != sources.end(); ++source) |
|||
{ |
|||
if(!(*source)->GetPropertyAsBool("HEADER_FILE_ONLY") && |
|||
!(*source)->GetCustomCommand()) |
|||
{ |
|||
// Generate this object file's rule file.
|
|||
this->GenerateObjectRuleFile(target, *(*source)); |
|||
|
|||
// Save the object file full path.
|
|||
std::string obj = dir; |
|||
obj += "/"; |
|||
obj += this->GetObjectFileName(*(*source)); |
|||
objects.push_back(obj); |
|||
} |
|||
} |
|||
|
|||
// If there is no dependencies file, create an empty one.
|
|||
std::string depFileName = dir; |
|||
depFileName += "/"; |
|||
depFileName += target.GetName(); |
|||
depFileName += ".depends.make"; |
|||
if(!cmSystemTools::FileExists(depFileName.c_str())) |
|||
{ |
|||
std::ofstream depFileStream(depFileName.c_str()); |
|||
this->WriteDisclaimer(depFileStream); |
|||
depFileStream |
|||
<< "# Empty dependencies file for target " << target.GetName() << ".\n" |
|||
<< "# This may be replaced when dependencies are built.\n"; |
|||
} |
|||
|
|||
// Open the rule file. This should be copy-if-different because the
|
|||
// rules may depend on this file itself.
|
|||
std::string ruleFileName = dir; |
|||
ruleFileName += "/"; |
|||
ruleFileName += target.GetName(); |
|||
ruleFileName += ".make"; |
|||
cmGeneratedFileStream ruleFile(ruleFileName.c_str()); |
|||
std::ostream& ruleFileStream = ruleFile.GetStream(); |
|||
if(!ruleFileStream) |
|||
{ |
|||
// TODO: Produce error message that accounts for generated stream
|
|||
// .tmp.
|
|||
return; |
|||
} |
|||
this->WriteDisclaimer(ruleFileStream); |
|||
ruleFileStream |
|||
<< "# Rule file for target " << target.GetName() << ".\n\n"; |
|||
|
|||
// Include the dependencies for the target.
|
|||
ruleFileStream |
|||
<< "# Include any dependencies generated for this rule.\n" |
|||
<< m_IncludeDirective << " " |
|||
<< this->ConvertToOutputForExisting(depFileName.c_str()).c_str() |
|||
<< "\n\n"; |
|||
|
|||
// Include the rule file for each object.
|
|||
if(!objects.empty()) |
|||
{ |
|||
ruleFileStream |
|||
<< "# Include rules for object files.\n"; |
|||
for(std::vector<std::string>::const_iterator obj = objects.begin(); |
|||
obj != objects.end(); ++obj) |
|||
{ |
|||
std::string objRuleFileName = *obj; |
|||
objRuleFileName += ".make"; |
|||
ruleFileStream |
|||
<< m_IncludeDirective << " " |
|||
<< this->ConvertToOutputForExisting(objRuleFileName.c_str()).c_str() |
|||
<< "\n"; |
|||
} |
|||
ruleFileStream |
|||
<< "\n"; |
|||
} |
|||
|
|||
// Write the dependency generation rule.
|
|||
{ |
|||
std::vector<std::string> depends; |
|||
std::vector<std::string> commands; |
|||
std::string depComment = "dependencies for "; |
|||
depComment += target.GetName(); |
|||
std::string depTarget = dir; |
|||
depTarget += "/"; |
|||
depTarget += target.GetName(); |
|||
depTarget += ".depends"; |
|||
for(std::vector<std::string>::const_iterator obj = objects.begin(); |
|||
obj != objects.end(); ++obj) |
|||
{ |
|||
depends.push_back((*obj)+".depends"); |
|||
} |
|||
depends.push_back(ruleFileName); |
|||
std::string touchCmd = "@touch "; |
|||
touchCmd += this->ConvertToRelativeOutputPath(depTarget.c_str()); |
|||
// TODO: Construct dependency generation rule and append command.
|
|||
commands.push_back(touchCmd); |
|||
this->OutputMakeRule(ruleFileStream, depComment.c_str(), depTarget.c_str(), |
|||
depends, commands); |
|||
} |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------
|
|||
void |
|||
cmLocalUnixMakefileGenerator2 |
|||
::GenerateObjectRuleFile(const cmTarget& target, const cmSourceFile& source) |
|||
{ |
|||
// Get the full path name of the object file.
|
|||
std::string objName = this->GetObjectFileName(source); |
|||
std::string obj = this->GetTargetDirectory(target); |
|||
obj += "/"; |
|||
obj += objName; |
|||
|
|||
// Create the directory containing the object file. This may be a
|
|||
// subdirectory under the target's directory.
|
|||
std::string dir = cmSystemTools::GetFilenamePath(obj.c_str()); |
|||
cmSystemTools::MakeDirectory(dir.c_str()); |
|||
|
|||
// If there is no dependencies file, create an empty one.
|
|||
std::string depFileName = obj; |
|||
depFileName += ".depends.make"; |
|||
if(!cmSystemTools::FileExists(depFileName.c_str())) |
|||
{ |
|||
std::ofstream depFileStream(depFileName.c_str()); |
|||
this->WriteDisclaimer(depFileStream); |
|||
depFileStream |
|||
<< "# Empty dependencies file for object file " |
|||
<< objName.c_str() << ".\n" |
|||
<< "# This may be replaced when dependencies are built.\n"; |
|||
} |
|||
|
|||
// Open the rule file. This should be copy-if-different because the
|
|||
// rules may depend on this file itself.
|
|||
std::string ruleFileName = obj; |
|||
ruleFileName += ".make"; |
|||
cmGeneratedFileStream ruleFile(ruleFileName.c_str()); |
|||
std::ostream& ruleFileStream = ruleFile.GetStream(); |
|||
if(!ruleFileStream) |
|||
{ |
|||
// TODO: Produce error message that accounts for generated stream
|
|||
// .tmp.
|
|||
return; |
|||
} |
|||
this->WriteDisclaimer(ruleFileStream); |
|||
ruleFileStream |
|||
<< "# Rule file for object file " << objName.c_str() << ".\n\n"; |
|||
|
|||
// Include the dependencies for the target.
|
|||
ruleFileStream |
|||
<< "# Include any dependencies generated for this rule.\n" |
|||
<< m_IncludeDirective << " " |
|||
<< this->ConvertToOutputForExisting(depFileName.c_str()).c_str() |
|||
<< "\n\n"; |
|||
|
|||
// Write the dependency generation rule.
|
|||
{ |
|||
std::vector<std::string> depends; |
|||
std::vector<std::string> commands; |
|||
std::string depComment = "dependencies for "; |
|||
depComment += objName; |
|||
std::string depTarget = obj; |
|||
depTarget += ".depends"; |
|||
depends.push_back(source.GetFullPath()); |
|||
depends.push_back(ruleFileName); |
|||
std::string touchCmd = "@touch "; |
|||
touchCmd += this->ConvertToRelativeOutputPath(depTarget.c_str()); |
|||
// TODO: Construct dependency generation rule and append command.
|
|||
commands.push_back(touchCmd); |
|||
this->OutputMakeRule(ruleFileStream, depComment.c_str(), depTarget.c_str(), |
|||
depends, commands); |
|||
} |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------
|
|||
void cmLocalUnixMakefileGenerator2::WriteDisclaimer(std::ostream& os) |
|||
{ |
|||
os |
|||
<< "# CMAKE generated file: DO NOT EDIT!\n" |
|||
<< "# Generated by \"" << m_GlobalGenerator->GetName() << "\"" |
|||
<< " Generator, CMake Version " |
|||
<< cmMakefile::GetMajorVersion() << "." |
|||
<< cmMakefile::GetMinorVersion() << "\n\n"; |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------
|
|||
std::string |
|||
cmLocalUnixMakefileGenerator2 |
|||
::GetTargetDirectory(const cmTarget& target) |
|||
{ |
|||
std::string dir = m_Makefile->GetStartOutputDirectory(); |
|||
dir += "/"; |
|||
dir += target.GetName(); |
|||
dir += ".dir"; |
|||
return dir; |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------
|
|||
std::string |
|||
cmLocalUnixMakefileGenerator2 |
|||
::GetObjectFileName(const cmSourceFile& source) |
|||
{ |
|||
// If the full path to the source file includes this directory,
|
|||
// we want to use the relative path for the filename of the
|
|||
// object file. Otherwise, we will use just the filename
|
|||
// portion.
|
|||
std::string objectName; |
|||
if((cmSystemTools::GetFilenamePath( |
|||
source.GetFullPath()).find( |
|||
m_Makefile->GetCurrentDirectory()) == 0) |
|||
|| (cmSystemTools::GetFilenamePath( |
|||
source.GetFullPath()).find( |
|||
m_Makefile->GetCurrentOutputDirectory()) == 0)) |
|||
{ |
|||
objectName = source.GetSourceName(); |
|||
} |
|||
else |
|||
{ |
|||
objectName = cmSystemTools::GetFilenameName(source.GetSourceName()); |
|||
} |
|||
|
|||
// Append the object file extension.
|
|||
objectName += |
|||
m_GlobalGenerator->GetLanguageOutputExtensionFromExtension( |
|||
source.GetSourceExtension().c_str()); |
|||
return objectName; |
|||
} |
|||
@ -0,0 +1,63 @@ |
|||
/*========================================================================= |
|||
|
|||
Program: CMake - Cross-Platform Makefile Generator |
|||
Module: $RCSfile$ |
|||
Language: C++ |
|||
Date: $Date$ |
|||
Version: $Revision$ |
|||
|
|||
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. |
|||
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. |
|||
|
|||
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. |
|||
|
|||
=========================================================================*/ |
|||
#ifndef cmLocalUnixMakefileGenerator2_h |
|||
#define cmLocalUnixMakefileGenerator2_h |
|||
|
|||
#include "cmLocalUnixMakefileGenerator.h" |
|||
|
|||
class cmDependInformation; |
|||
class cmMakeDepend; |
|||
class cmTarget; |
|||
class cmSourceFile; |
|||
|
|||
/** \class cmLocalUnixMakefileGenerator2 |
|||
* \brief Write a LocalUnix makefiles. |
|||
* |
|||
* cmLocalUnixMakefileGenerator2 produces a LocalUnix makefile from its |
|||
* member m_Makefile. |
|||
*/ |
|||
class cmLocalUnixMakefileGenerator2 : public cmLocalUnixMakefileGenerator |
|||
{ |
|||
public: |
|||
///! Set cache only and recurse to false by default. |
|||
cmLocalUnixMakefileGenerator2(); |
|||
|
|||
virtual ~cmLocalUnixMakefileGenerator2(); |
|||
|
|||
/** |
|||
* Generate the makefile for this directory. fromTheTop indicates if this |
|||
* is being invoked as part of a global Generate or specific to this |
|||
* directory. The difference is that when done from the Top we might skip |
|||
* some steps to save time, such as dependency generation for the |
|||
* makefiles. This is done by a direct invocation from make. |
|||
*/ |
|||
virtual void Generate(bool fromTheTop); |
|||
protected: |
|||
|
|||
void GenerateMakefile(); |
|||
void GenerateCMakefile(); |
|||
void GenerateTargetRuleFile(const cmTarget& target); |
|||
void GenerateObjectRuleFile(const cmTarget& target, |
|||
const cmSourceFile& source); |
|||
void WriteDisclaimer(std::ostream& os); |
|||
|
|||
std::string GetTargetDirectory(const cmTarget& target); |
|||
std::string GetObjectFileName(const cmSourceFile& source); |
|||
private: |
|||
}; |
|||
|
|||
#endif |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue