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

Remove trailing whitespace 

Alex
This commit is contained in:
Alex Neundorf 2010-11-11 22:02:07 +01:00
parent 3c245ab2ba
commit 7b1421b885
8 changed files with 208 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
Source/cmExtraCodeBlocksGenerator.cxx
View File

@ -23,7 +23,7 @@
#include <cmsys/SystemTools.hxx>
/* Some useful URLs:
Homepage:
Homepage:
http://www.codeblocks.org
File format docs:
@ -107,7 +107,7 @@ void cmExtraCodeBlocksGenerator::CreateProjectFile(
/* Tree is used to create a "Virtual Folder" in CodeBlocks, in which all
CMake files this project depends on will be put. This means additionally
to the "Sources" and "Headers" virtual folders of CodeBlocks, there will
now also be a "CMake Files" virtual folder.
now also be a "CMake Files" virtual folder.
Patch by Daniel Teske <daniel.teske AT nokia.com> (which use C::B project
files in QtCreator).*/
struct Tree
@ -115,24 +115,24 @@ struct Tree
std::string path; //only one component of the path
std::vector<Tree> folders;
std::vector<std::string> files;
void InsertPath(const std::vector<std::string>& splitted,
std::vector<std::string>::size_type start,
void InsertPath(const std::vector<std::string>& splitted,
std::vector<std::string>::size_type start,
const std::string& fileName);
void BuildVirtualFolder(std::string& virtualFolders) const;
void BuildVirtualFolderImpl(std::string& virtualFolders,
void BuildVirtualFolderImpl(std::string& virtualFolders,
const std::string& prefix) const;
void BuildUnit(std::string& unitString, const std::string& fsPath) const;
void BuildUnitImpl(std::string& unitString,
const std::string& virtualFolderPath,
void BuildUnitImpl(std::string& unitString,
const std::string& virtualFolderPath,
const std::string& fsPath) const;
};
void Tree::InsertPath(const std::vector<std::string>& splitted,
std::vector<std::string>::size_type start,
void Tree::InsertPath(const std::vector<std::string>& splitted,
std::vector<std::string>::size_type start,
const std::string& fileName)
{
if (start == splitted.size())
if (start == splitted.size())
{
files.push_back(fileName);
return;
@ -301,7 +301,7 @@ void cmExtraCodeBlocksGenerator
}
// Now build a virtual tree string
std::string virtualFolders;
std::string virtualFolders;
tree.BuildVirtualFolder(virtualFolders);
// And one for <Unit>
std::string unitFiles;
@ -323,7 +323,7 @@ void cmExtraCodeBlocksGenerator
this->AppendTarget(fout, "all", 0, make.c_str(), mf, compiler.c_str());
// add all executable and library targets and some of the GLOBAL
// add all executable and library targets and some of the GLOBAL
// and UTILITY targets
for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
lg!=lgs.end(); lg++)
@ -338,9 +338,9 @@ void cmExtraCodeBlocksGenerator
case cmTarget::GLOBAL_TARGET:
{
bool insertTarget = false;
// Only add the global targets from CMAKE_BINARY_DIR,
// Only add the global targets from CMAKE_BINARY_DIR,
// not from the subdirs
if (strcmp(makefile->GetStartOutputDirectory(),
if (strcmp(makefile->GetStartOutputDirectory(),
makefile->GetHomeOutputDirectory())==0)
{
insertTarget = true;
@ -362,7 +362,7 @@ void cmExtraCodeBlocksGenerator
}
if (insertTarget)
{
this->AppendTarget(fout, ti->first.c_str(), 0,
this->AppendTarget(fout, ti->first.c_str(), 0,
make.c_str(), makefile, compiler.c_str());
}
}
@ -372,13 +372,13 @@ void cmExtraCodeBlocksGenerator
// Experimental-"sub"targets as e.g. NightlyStart
if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly"))
|| ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous"))
|| ((ti->first.find("Experimental")==0)
|| ((ti->first.find("Experimental")==0)
&& (ti->first!="Experimental")))
{
break;
}
this->AppendTarget(fout, ti->first.c_str(), 0,
this->AppendTarget(fout, ti->first.c_str(), 0,
make.c_str(), makefile, compiler.c_str());
break;
case cmTarget::EXECUTABLE:
@ -386,11 +386,11 @@ void cmExtraCodeBlocksGenerator
case cmTarget::SHARED_LIBRARY:
case cmTarget::MODULE_LIBRARY:
{
this->AppendTarget(fout, ti->first.c_str(), &ti->second,
this->AppendTarget(fout, ti->first.c_str(), &ti->second,
make.c_str(), makefile, compiler.c_str());
std::string fastTarget = ti->first;
fastTarget += "/fast";
this->AppendTarget(fout, fastTarget.c_str(), &ti->second,
this->AppendTarget(fout, fastTarget.c_str(), &ti->second,
make.c_str(), makefile, compiler.c_str());
}
break;
@ -437,7 +437,7 @@ void cmExtraCodeBlocksGenerator
{
for(std::vector<std::string>::const_iterator
ext = mf->GetSourceExtensions().begin();
ext != mf->GetSourceExtensions().end();
ext != mf->GetSourceExtensions().end();
++ext)
{
if ((*si)->GetExtension() == *ext)
@ -467,11 +467,11 @@ void cmExtraCodeBlocksGenerator
// The following loop tries to add header files matching to implementation
// files to the project. It does that by iterating over all source files,
// replacing the file name extension with ".h" and checks whether such a
// replacing the file name extension with ".h" and checks whether such a
// file exists. If it does, it is inserted into the map of files.
// A very similar version of that code exists also in the kdevelop
// project generator.
for (std::map<std::string, cmSourceFile*>::const_iterator
for (std::map<std::string, cmSourceFile*>::const_iterator
sit=cFiles.begin();
sit!=cFiles.end();
++sit)
@ -483,7 +483,7 @@ void cmExtraCodeBlocksGenerator
// check if there's a matching header around
for(std::vector<std::string>::const_iterator
ext = mf->GetHeaderExtensions().begin();
ext != mf->GetHeaderExtensions().end();
ext != mf->GetHeaderExtensions().end();
++ext)
{
std::string hname=headerBasename;
@ -506,7 +506,7 @@ void cmExtraCodeBlocksGenerator
// insert all source files in the CodeBlocks project
// first the C/C++ implementation files, then all others
for (std::map<std::string, cmSourceFile*>::const_iterator
for (std::map<std::string, cmSourceFile*>::const_iterator
sit=cFiles.begin();
sit!=cFiles.end();
++sit)
@ -514,7 +514,7 @@ void cmExtraCodeBlocksGenerator
fout<<" <Unit filename=\""<< sit->first <<"\">\n"
" </Unit>\n";
}
for (std::set<std::string>::const_iterator
for (std::set<std::string>::const_iterator
sit=otherFiles.begin();
sit!=otherFiles.end();
++sit)
@ -577,7 +577,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
" <Option compiler=\"" << compiler << "\" />\n"
" <Compiler>\n";
// the include directories for this target
const std::vector<std::string>& incDirs =
const std::vector<std::string>& incDirs =
target->GetMakefile()->GetIncludeDirectories();
for(std::vector<std::string>::const_iterator dirIt=incDirs.begin();
dirIt != incDirs.end();
@ -589,27 +589,27 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
}
else // e.g. all and the GLOBAL and UTILITY targets
{
fout<<" <Option working_dir=\""
fout<<" <Option working_dir=\""
<< makefile->GetStartOutputDirectory() << "\" />\n"
<<" <Option type=\"" << 4 << "\" />\n";
}
fout<<" <MakeCommands>\n"
" <Build command=\""
" <Build command=\""
<< this->BuildMakeCommand(make, makefileName.c_str(), targetName)
<< "\" />\n"
" <CompileFile command=\""
" <CompileFile command=\""
<< this->BuildMakeCommand(make, makefileName.c_str(),"&quot;$file&quot;")
<< "\" />\n"
" <Clean command=\""
<< this->BuildMakeCommand(make, makefileName.c_str(), "clean")
" <Clean command=\""
<< this->BuildMakeCommand(make, makefileName.c_str(), "clean")
<< "\" />\n"
" <DistClean command=\""
<< this->BuildMakeCommand(make, makefileName.c_str(), "clean")
" <DistClean command=\""
<< this->BuildMakeCommand(make, makefileName.c_str(), "clean")
<< "\" />\n"
" </MakeCommands>\n"
" </Target>\n";
}
@ -675,7 +675,7 @@ int cmExtraCodeBlocksGenerator::GetCBTargetType(cmTarget* target)
{
return 2;
}
else if ((target->GetType()==cmTarget::SHARED_LIBRARY)
else if ((target->GetType()==cmTarget::SHARED_LIBRARY)
|| (target->GetType()==cmTarget::MODULE_LIBRARY))
{
return 3;
@ -699,9 +699,9 @@ std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
}
else if (strcmp(this->GlobalGenerator->GetName(), "MinGW Makefiles")==0)
{
// no escaping of spaces in this case, see
// no escaping of spaces in this case, see
// http://public.kitware.com/Bug/view.php?id=10014
std::string makefileName = makefile;
std::string makefileName = makefile;
command += " -f &quot;";
command += makefileName;
command += "&quot; ";

6
Source/cmExtraCodeBlocksGenerator.h
View File

@ -34,10 +34,10 @@ public:
virtual const char* GetName() const
{ return cmExtraCodeBlocksGenerator::GetActualName();}
static const char* GetActualName() { return "CodeBlocks";}
static cmExternalMakefileProjectGenerator* New()
static cmExternalMakefileProjectGenerator* New()
{ return new cmExtraCodeBlocksGenerator; }
/** Get the documentation entry for this generator. */
virtual void GetDocumentation(cmDocumentationEntry& entry,
virtual void GetDocumentation(cmDocumentationEntry& entry,
const char* fullName) const;
virtual void Generate();
@ -49,7 +49,7 @@ private:
const std::string& filename);
std::string GetCBCompilerId(const cmMakefile* mf);
int GetCBTargetType(cmTarget* target);
std::string BuildMakeCommand(const std::string& make, const char* makefile,
std::string BuildMakeCommand(const std::string& make, const char* makefile,
const char* target);
void AppendTarget(cmGeneratedFileStream& fout,
const char* targetName,

66
Source/cmExtraEclipseCDT4Generator.cxx
View File

@ -73,7 +73,7 @@ void cmExtraEclipseCDT4Generator::Generate()
this->IsOutOfSourceBuild = (this->HomeDirectory!=this->HomeOutputDirectory);
this->GenerateSourceProject = (this->IsOutOfSourceBuild &&
this->GenerateSourceProject = (this->IsOutOfSourceBuild &&
mf->IsOn("ECLIPSE_CDT4_GENERATE_SOURCE_PROJECT"));
// NOTE: This is not good, since it pollutes the source tree. However,
@ -109,7 +109,7 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile() const
return;
}
fout <<
fout <<
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<projectDescription>\n"
"\t<name>" << name << "</name>\n"
@ -129,7 +129,7 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile() const
void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
const char* envVar, cmMakefile* mf)
{
// get the variables from the environment and from the cache and then
// get the variables from the environment and from the cache and then
// figure out which one to use:
const char* envVarValue = getenv(envVar);
@ -148,7 +148,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
}
else if (envVarValue!=0 && cacheValue==0)
{
// The variable is in the env, but not in the cache. Use it and put it
// The variable is in the env, but not in the cache. Use it and put it
// in the cache
valueToUse = envVarValue;
mf->AddCacheDefinition(cacheEntryName.c_str(), valueToUse.c_str(),
@ -206,7 +206,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
compilerId = mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID");
}
fout <<
fout <<
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<projectDescription>\n"
"\t<name>" <<
@ -225,7 +225,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
;
// use clean target
fout <<
fout <<
"\t\t\t\t<dictionary>\n"
"\t\t\t\t\t<key>org.eclipse.cdt.make.core.cleanBuildTarget</key>\n"
"\t\t\t\t\t<value>clean</value>\n"
@ -246,7 +246,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
// set the make command
std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
fout <<
fout <<
"\t\t\t\t<dictionary>\n"
"\t\t\t\t\t<key>org.eclipse.cdt.make.core.enabledIncrementalBuild</key>\n"
"\t\t\t\t\t<value>true</value>\n"
@ -296,7 +296,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
else if (compilerId == "Intel")
{
// if the env.var is set, use this one and put it in the cache
// if the env.var is not set, but the value is in the cache,
// if the env.var is not set, but the value is in the cache,
// use it from the cache:
AddEnvVar(fout, "INTEL_LICENSE_FILE", mf);
}
@ -392,9 +392,9 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
{
fout << "\t<linkedResources>\n";
// create a linked resource to CMAKE_SOURCE_DIR
// (this is not done anymore for each project because of
// http://public.kitware.com/Bug/view.php?id=9978 and because I found it
// actually quite confusing in bigger projects with many directories and
// (this is not done anymore for each project because of
// http://public.kitware.com/Bug/view.php?id=9978 and because I found it
// actually quite confusing in bigger projects with many directories and
// projects, Alex
std::string sourceLinkedResourceName = "[Source directory]";
@ -440,7 +440,7 @@ void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
if(emittedDirs.find(dir) == emittedDirs.end())
{
emittedDirs.insert(dir);
fout << "<pathentry include=\""
fout << "<pathentry include=\""
<< cmExtraEclipseCDT4Generator::GetEclipsePath(dir)
<< "\" kind=\"inc\" path=\"\" system=\"true\"/>\n";
}
@ -452,7 +452,7 @@ void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
{
std::set<std::string> emmited;
const cmMakefile* mf
= this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile();
@ -465,7 +465,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
}
// add header
fout <<
fout <<
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
"<?fileVersion 4.0.0?>\n\n"
"<cproject>\n"
@ -475,7 +475,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
fout << "<cconfiguration id=\"org.eclipse.cdt.core.default.config.1\">\n";
// Configuration settings...
fout <<
fout <<
"<storageModule"
" buildSystemId=\"org.eclipse.cdt.core.defaultConfigDataProvider\""
" id=\"org.eclipse.cdt.core.default.config.1\""
@ -536,9 +536,9 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
fout << "</extensions>\n"
"</storageModule>\n"
;
// ???
fout <<
fout <<
"<storageModule moduleId=\"org.eclipse.cdt.core.language.mapping\">\n"
"<project-mappings/>\n"
"</storageModule>\n"
@ -619,13 +619,13 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
// we have -DFOO
def = *di;
}
// insert the definition if not already added.
if(emmited.find(def) == emmited.end())
{
emmited.insert(def);
fout << "<pathentry kind=\"mac\" name=\"" << def
<< "\" path=\"\" value=\"" << this->EscapeForXML(val)
<< "\" path=\"\" value=\"" << this->EscapeForXML(val)
<< "\"/>\n";
}
}
@ -712,8 +712,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
= (*it)->GetMakefile()->GetIncludeDirectories();
this->AppendIncludeDirectories(fout, includeDirs, emmited);
}
// now also the system include directories, in case we found them in
// CMakeSystemSpecificInformation.cmake. This makes Eclipse find the
// now also the system include directories, in case we found them in
// CMakeSystemSpecificInformation.cmake. This makes Eclipse find the
// standard headers.
mf->GetDefinition("CMAKE_ECLIPSE_C_SYSTEM_INCLUDE_DIRS");
std::string compiler = mf->GetSafeDefinition("CMAKE_C_COMPILER");
@ -738,7 +738,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
fout << "</storageModule>\n";
// add build targets
fout <<
fout <<
"<storageModule moduleId=\"org.eclipse.cdt.make.core.buildtargets\">\n"
"<buildTargets>\n"
;
@ -746,7 +746,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
const std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
cmGlobalGenerator* generator
= const_cast<cmGlobalGenerator*>(this->GlobalGenerator);
std::string allTarget;
std::string cleanTarget;
if (generator->GetAllTargetName())
@ -758,7 +758,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
cleanTarget = generator->GetCleanTargetName();
}
// add all executable and library targets and some of the GLOBAL
// add all executable and library targets and some of the GLOBAL
// and UTILITY targets
for (std::vector<cmLocalGenerator*>::const_iterator
it = this->GlobalGenerator->GetLocalGenerators().begin();
@ -781,7 +781,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
case cmTarget::GLOBAL_TARGET:
{
bool insertTarget = false;
// Only add the global targets from CMAKE_BINARY_DIR,
// Only add the global targets from CMAKE_BINARY_DIR,
// not from the subdirs
if (subdir.empty())
{
@ -813,7 +813,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
// Experimental-"sub"targets as e.g. NightlyStart
if (((ti->first.find("Nightly")==0) &&(ti->first!="Nightly"))
|| ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous"))
|| ((ti->first.find("Experimental")==0)
|| ((ti->first.find("Experimental")==0)
&& (ti->first!="Experimental")))
{
break;
@ -842,7 +842,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
break;
}
}
// insert the all and clean targets in every subdir
if (!allTarget.empty())
{
@ -955,7 +955,7 @@ std::string cmExtraEclipseCDT4Generator::EscapeForXML(const std::string& value)
// Helper functions
//----------------------------------------------------------------------------
void cmExtraEclipseCDT4Generator
::AppendStorageScanners(cmGeneratedFileStream& fout,
::AppendStorageScanners(cmGeneratedFileStream& fout,
const cmMakefile& makefile)
{
// we need the "make" and the C (or C++) compiler which are used, Alex
@ -972,7 +972,7 @@ void cmExtraEclipseCDT4Generator
// the following right now hardcodes gcc behaviour :-/
fout <<
fout <<
"<storageModule moduleId=\"scannerConfiguration\">\n"
"<autodiscovery enabled=\"true\" problemReportingEnabled=\"true\""
" selectedProfileId="
@ -996,8 +996,8 @@ void cmExtraEclipseCDT4Generator
// of that is to sort the targets in the view of Eclipse, so that at first
// the global/utility/all/clean targets appear ": ", then the executable
// targets "[exe] ", then the libraries "[lib]", then the rules for the
// object files "[obj]", then for preprocessing only "[pre] " and
// finally the assembly files "[to asm] ". Note the "to" in "to asm",
// object files "[obj]", then for preprocessing only "[pre] " and
// finally the assembly files "[to asm] ". Note the "to" in "to asm",
// without it, "asm" would be the first targets in the list, with the "to"
// they are the last targets, which makes more sense.
void cmExtraEclipseCDT4Generator::AppendTarget(cmGeneratedFileStream& fout,
@ -1006,7 +1006,7 @@ void cmExtraEclipseCDT4Generator::AppendTarget(cmGeneratedFileStream& fout,
const std::string& path,
const char* prefix)
{
fout <<
fout <<
"<target name=\"" << prefix << target << "\""
" path=\"" << path.c_str() << "\""
" targetID=\"org.eclipse.cdt.make.MakeTargetBuilder\">\n"
@ -1033,7 +1033,7 @@ void cmExtraEclipseCDT4Generator
bool runActionUseDefault,
bool sipParserEnabled)
{
fout <<
fout <<
"<profile id=\"" << profileID << "\">\n"
"<buildOutputProvider>\n"
"<openAction enabled=\"" << (openActionEnabled ? "true" : "false")

4
Source/cmExtraEclipseCDT4Generator.h
View File

@ -70,7 +70,7 @@ private:
static std::string EscapeForXML(const std::string& value);
// Helper functions
static void AppendStorageScanners(cmGeneratedFileStream& fout,
static void AppendStorageScanners(cmGeneratedFileStream& fout,
const cmMakefile& makefile);
static void AppendTarget (cmGeneratedFileStream& fout,
const std::string& target,
@ -100,7 +100,7 @@ private:
const std::vector<std::string>& includeDirs,
std::set<std::string>& emittedDirs);
static void AddEnvVar(cmGeneratedFileStream& fout, const char* envVar,
static void AddEnvVar(cmGeneratedFileStream& fout, const char* envVar,
cmMakefile* mf);
std::vector<std::string> SrcLinkedResources;

44
Source/cmGlobalGenerator.h
View File

@ -38,31 +38,31 @@ public:
///! Free any memory allocated with the GlobalGenerator
cmGlobalGenerator();
virtual ~cmGlobalGenerator();
///! Create a local generator appropriate to this Global Generator
virtual cmLocalGenerator *CreateLocalGenerator();
///! Get the name for this generator
virtual const char *GetName() const { return "Generic"; };
/** Get the documentation entry for this generator. */
virtual void GetDocumentation(cmDocumentationEntry& entry) const;
/**
* Create LocalGenerators and process the CMakeLists files. This does not
* actually produce any makefiles, DSPs, etc.
* actually produce any makefiles, DSPs, etc.
*/
virtual void Configure();
/**
* Generate the all required files for building this project/tree. This
* basically creates a series of LocalGenerators for each directory and
* requests that they Generate.
* requests that they Generate.
*/
virtual void Generate();
/**
* Set/Get and Clear the enabled languages.
* Set/Get and Clear the enabled languages.
*/
void SetLanguageEnabled(const char*, cmMakefile* mf);
bool GetLanguageEnabled(const char*) const;
@ -70,7 +70,7 @@ public:
void GetEnabledLanguages(std::vector<std::string>& lang);
/**
* Try to determine system infomation such as shared library
* extension, pthreads, byte order etc.
* extension, pthreads, byte order etc.
*/
virtual void EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *, bool optional);
@ -88,7 +88,7 @@ public:
const char *projectName, const char *targetName,
bool fast, std::string *output, cmMakefile* mf);
/**
* Build a file given the following information. This is a more direct call
* that is used by both CTest and TryCompile. If target name is NULL or
@ -104,28 +104,28 @@ public:
const char* extraOptions = 0,
std::vector<std::string> const& nativeOptions =
std::vector<std::string>());
virtual std::string GenerateBuildCommand(
const char* makeProgram,
const char *projectName, const char* additionalOptions,
const char *projectName, const char* additionalOptions,
const char *targetName,
const char* config, bool ignoreErrors, bool fast);
///! Set the CMake instance
void SetCMakeInstance(cmake *cm);
///! Get the CMake instance
cmake *GetCMakeInstance() { return this->CMakeInstance; };
void SetConfiguredFilesPath(cmGlobalGenerator* gen);
const std::vector<cmLocalGenerator *>& GetLocalGenerators() const {
const std::vector<cmLocalGenerator *>& GetLocalGenerators() const {
return this->LocalGenerators;}
cmLocalGenerator* GetCurrentLocalGenerator()
cmLocalGenerator* GetCurrentLocalGenerator()
{return this->CurrentLocalGenerator;}
void SetCurrentLocalGenerator(cmLocalGenerator* lg)
void SetCurrentLocalGenerator(cmLocalGenerator* lg)
{this->CurrentLocalGenerator = lg;}
void AddLocalGenerator(cmLocalGenerator *lg);
@ -138,11 +138,11 @@ public:
void AddInstallComponent(const char* component);
const std::set<cmStdString>* GetInstallComponents() const
const std::set<cmStdString>* GetInstallComponents() const
{ return &InstallComponents; }
///! Add one installed target to the sets of the exports
void AddTargetToExports(const char* exportSet, cmTarget* target,
void AddTargetToExports(const char* exportSet, cmTarget* target,
cmInstallTargetGenerator* archive,
cmInstallTargetGenerator* runTime,
cmInstallTargetGenerator* library,
@ -158,7 +158,7 @@ public:
void EnableInstallTarget();
int TryCompileTimeout;
bool GetForceUnixPaths() {return this->ForceUnixPaths;}
bool GetToolSupportsColor() { return this->ToolSupportsColor; }
void SetToolSupportsColor(bool enable) { this->ToolSupportsColor = enable; }
@ -254,7 +254,7 @@ public:
bool BinaryDirectoryIsNew(const char* dir)
{
return this->BinaryDirectories.insert(dir).second;
}
}
/** Supported systems creates a GUID for the given name */
virtual void CreateGUID(const char*) {}
@ -281,7 +281,7 @@ protected:
bool CheckTargets();
// Fill the ProjectMap, this must be called after LocalGenerators
// Fill the ProjectMap, this must be called after LocalGenerators
// has been populated.
void FillProjectMap();
void CheckLocalGenerators();
@ -328,13 +328,13 @@ protected:
private:
float FirstTimeProgress;
// If you add a new map here, make sure it is copied
// in EnableLanguagesFromGenerator
// in EnableLanguagesFromGenerator
std::map<cmStdString, bool> IgnoreExtensions;
std::map<cmStdString, bool> LanguageEnabled;
std::map<cmStdString, cmStdString> OutputExtensions;
std::map<cmStdString, cmStdString> LanguageToOutputExtension;
std::map<cmStdString, cmStdString> ExtensionToLanguage;
std::map<cmStdString, int> LanguageToLinkerPreference;
std::map<cmStdString, int> LanguageToLinkerPreference;
// Record hashes for rules and outputs.
struct RuleHash { char Data[32]; };

122
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@ -35,8 +35,8 @@ cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3()
}
void cmGlobalUnixMakefileGenerator3
::EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *mf,
::EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *mf,
bool optional)
{
this->cmGlobalGenerator::EnableLanguage(languages, mf, optional);
@ -52,17 +52,17 @@ void cmGlobalUnixMakefileGenerator3
std::string langComp = "CMAKE_";
langComp += lang;
langComp += "_COMPILER";
if(!mf->GetDefinition(langComp.c_str()))
{
if(!optional)
{
cmSystemTools::Error(langComp.c_str(),
cmSystemTools::Error(langComp.c_str(),
" not set, after EnableLanguage");
}
continue;
}
const char* name = mf->GetRequiredDefinition(langComp.c_str());
const char* name = mf->GetRequiredDefinition(langComp.c_str());
if(!cmSystemTools::FileIsFullPath(name))
{
path = cmSystemTools::FindProgram(name);
@ -71,7 +71,7 @@ void cmGlobalUnixMakefileGenerator3
{
path = name;
}
if((path.size() == 0 || !cmSystemTools::FileExists(path.c_str()))
if((path.size() == 0 || !cmSystemTools::FileExists(path.c_str()))
&& (optional==false))
{
std::string message = "your ";
@ -97,8 +97,8 @@ void cmGlobalUnixMakefileGenerator3
cmSystemTools::ConvertToUnixSlashes(cnameString);
cmSystemTools::ConvertToUnixSlashes(pathString);
if (cnameString != pathString)
{
const char* cvars =
{
const char* cvars =
this->GetCMakeInstance()->GetProperty(
"__CMAKE_DELETE_CACHE_CHANGE_VARS_");
if(cvars)
@ -140,7 +140,7 @@ void cmGlobalUnixMakefileGenerator3
}
//----------------------------------------------------------------------------
void cmGlobalUnixMakefileGenerator3::Generate()
void cmGlobalUnixMakefileGenerator3::Generate()
{
// first do superclass method
this->cmGlobalGenerator::Generate();
@ -197,7 +197,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
// Open the output file. This should not be copy-if-different
// because the check-build-system step compares the makefile time to
// see if the build system must be regenerated.
std::string makefileName =
std::string makefileName =
this->GetCMakeInstance()->GetHomeOutputDirectory();
makefileName += cmake::GetCMakeFilesDirectory();
makefileName += "/Makefile2";
@ -206,11 +206,11 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
{
return;
}
// get a local generator for some useful methods
cmLocalUnixMakefileGenerator3 *lg =
cmLocalUnixMakefileGenerator3 *lg =
static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
// Write the do not edit header.
lg->WriteDisclaimer(makefileStream);
@ -239,8 +239,8 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
}
// Write and empty all:
lg->WriteMakeRule(makefileStream,
"The main recursive all target", "all",
lg->WriteMakeRule(makefileStream,
"The main recursive all target", "all",
depends, no_commands, true);
// Write an empty preinstall:
@ -250,12 +250,12 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
// Write out the "special" stuff
lg->WriteSpecialTargetsTop(makefileStream);
// write the target convenience rules
unsigned int i;
for (i = 0; i < this->LocalGenerators.size(); ++i)
{
lg =
lg =
static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
this->WriteConvenienceRules2(makefileStream,lg);
}
@ -271,7 +271,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
// Open the output file. This should not be copy-if-different
// because the check-build-system step compares the makefile time to
// see if the build system must be regenerated.
std::string cmakefileName =
std::string cmakefileName =
this->GetCMakeInstance()->GetHomeOutputDirectory();
cmakefileName += cmake::GetCMakeFilesDirectory();
cmakefileName += "/Makefile.cmake";
@ -281,14 +281,14 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
return;
}
std::string makefileName =
std::string makefileName =
this->GetCMakeInstance()->GetHomeOutputDirectory();
makefileName += "/Makefile";
// get a local generator for some useful methods
cmLocalUnixMakefileGenerator3 *lg =
cmLocalUnixMakefileGenerator3 *lg =
static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
// Write the do not edit header.
lg->WriteDisclaimer(cmakefileStream);
@ -301,9 +301,9 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
std::vector<std::string> lfiles;
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
lg =
lg =
static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
// Get the list of files contributing to this generation step.
lfiles.insert(lfiles.end(),lg->GetMakefile()->GetListFiles().begin(),
lg->GetMakefile()->GetListFiles().end());
@ -311,7 +311,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
// Sort the list and remove duplicates.
std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>());
#if !defined(__VMS) // The Compaq STL on VMS crashes, so accept duplicates.
std::vector<std::string>::iterator new_end =
std::vector<std::string>::iterator new_end =
std::unique(lfiles.begin(),lfiles.end());
lfiles.erase(new_end, lfiles.end());
#endif
@ -327,14 +327,14 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
cmakefileStream
<< "# The top level Makefile was generated from the following files:\n"
<< "SET(CMAKE_MAKEFILE_DEPENDS\n"
<< " \""
<< " \""
<< lg->Convert(cache.c_str(),
cmLocalGenerator::START_OUTPUT).c_str() << "\"\n";
for(std::vector<std::string>::const_iterator i = lfiles.begin();
i != lfiles.end(); ++i)
{
cmakefileStream
<< " \""
<< " \""
<< lg->Convert(i->c_str(), cmLocalGenerator::START_OUTPUT).c_str()
<< "\"\n";
}
@ -350,10 +350,10 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
cmakefileStream
<< "# The corresponding makefile is:\n"
<< "SET(CMAKE_MAKEFILE_OUTPUTS\n"
<< " \""
<< " \""
<< lg->Convert(makefileName.c_str(),
cmLocalGenerator::START_OUTPUT).c_str() << "\"\n"
<< " \""
<< " \""
<< lg->Convert(check.c_str(),
cmLocalGenerator::START_OUTPUT).c_str() << "\"\n";
cmakefileStream << " )\n\n";
@ -377,19 +377,19 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
std::string tmpStr;
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
lg =
lg =
static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
tmpStr = lg->GetMakefile()->GetStartOutputDirectory();
tmpStr += cmake::GetCMakeFilesDirectory();
tmpStr += "/CMakeDirectoryInformation.cmake";
cmakefileStream << " \"" <<
lg->Convert(tmpStr.c_str(),cmLocalGenerator::HOME_OUTPUT).c_str()
cmakefileStream << " \"" <<
lg->Convert(tmpStr.c_str(),cmLocalGenerator::HOME_OUTPUT).c_str()
<< "\"\n";
}
cmakefileStream << " )\n\n";
}
this->WriteMainCMakefileLanguageRules(cmakefileStream,
this->WriteMainCMakefileLanguageRules(cmakefileStream,
this->LocalGenerators);
}
@ -468,7 +468,7 @@ cmGlobalUnixMakefileGenerator3
// The directory-level rule should depend on the directory-level
// rules of the subdirectories.
for(std::vector<cmLocalGenerator*>::iterator sdi =
for(std::vector<cmLocalGenerator*>::iterator sdi =
lg->GetChildren().begin(); sdi != lg->GetChildren().end(); ++sdi)
{
cmLocalUnixMakefileGenerator3* slg =
@ -528,7 +528,7 @@ cmGlobalUnixMakefileGenerator3
std::string cmGlobalUnixMakefileGenerator3
::GenerateBuildCommand(const char* makeProgram, const char *projectName,
::GenerateBuildCommand(const char* makeProgram, const char *projectName,
const char* additionalOptions, const char *targetName,
const char* config, bool ignoreErrors, bool fast)
{
@ -536,9 +536,9 @@ std::string cmGlobalUnixMakefileGenerator3
(void)projectName;
(void)config;
std::string makeCommand =
std::string makeCommand =
cmSystemTools::ConvertToUnixOutputPath(makeProgram);
// Since we have full control over the invocation of nmake, let us
// make it quiet.
if ( strcmp(this->GetName(), "NMake Makefiles") == 0 )
@ -573,7 +573,7 @@ std::string cmGlobalUnixMakefileGenerator3
(this->CMakeInstance->GetStartOutputDirectory());
lg->GetMakefile()->MakeStartDirectoriesCurrent();
}
makeCommand += " \"";
std::string tname = targetName;
if(fast)
@ -595,14 +595,14 @@ std::string cmGlobalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void
cmGlobalUnixMakefileGenerator3
::WriteConvenienceRules(std::ostream& ruleFileStream,
::WriteConvenienceRules(std::ostream& ruleFileStream,
std::set<cmStdString> &emitted)
{
std::vector<std::string> depends;
std::vector<std::string> depends;
std::vector<std::string> commands;
depends.push_back("cmake_check_build_system");
// write the target convenience rules
unsigned int i;
cmLocalUnixMakefileGenerator3 *lg;
@ -632,7 +632,7 @@ cmGlobalUnixMakefileGenerator3
ruleFileStream
<< "# Target rules for targets named "
<< t->second.GetName() << "\n\n";
// Write the rule.
commands.clear();
std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash();
@ -641,16 +641,16 @@ cmGlobalUnixMakefileGenerator3
(tmp.c_str(),t->second.GetName()));
depends.clear();
depends.push_back("cmake_check_build_system");
lg->WriteMakeRule(ruleFileStream,
lg->WriteMakeRule(ruleFileStream,
"Build rule for target.",
t->second.GetName(), depends, commands,
true);
// Add a fast rule to build the target
std::string localName = lg->GetRelativeTargetDirectory(t->second);
std::string makefileName;
makefileName = localName;
makefileName += "/build.make";
makefileName += "/build.make";
depends.clear();
commands.clear();
std::string makeTargetName = localName;
@ -687,10 +687,10 @@ cmGlobalUnixMakefileGenerator3
//----------------------------------------------------------------------------
void
cmGlobalUnixMakefileGenerator3
::WriteConvenienceRules2(std::ostream& ruleFileStream,
::WriteConvenienceRules2(std::ostream& ruleFileStream,
cmLocalUnixMakefileGenerator3 *lg)
{
std::vector<std::string> depends;
std::vector<std::string> depends;
std::vector<std::string> commands;
std::string localName;
std::string makeTargetName;
@ -698,7 +698,7 @@ cmGlobalUnixMakefileGenerator3
// write the directory level rules for this local gen
this->WriteDirectoryRules2(ruleFileStream,lg);
depends.push_back("cmake_check_build_system");
// for each target Generate the rule files for each target.
@ -718,15 +718,15 @@ cmGlobalUnixMakefileGenerator3
localName = lg->GetRelativeTargetDirectory(t->second);
makefileName = localName;
makefileName += "/build.make";
bool needRequiresStep = this->NeedRequiresStep(t->second);
lg->WriteDivider(ruleFileStream);
ruleFileStream
<< "# Target rules for target "
<< localName << "\n\n";
commands.clear();
commands.clear();
makeTargetName = localName;
makeTargetName += "/depend";
commands.push_back(lg->GetRecursiveMakeCall
@ -744,7 +744,7 @@ cmGlobalUnixMakefileGenerator3
makeTargetName += "/build";
commands.push_back(lg->GetRecursiveMakeCall
(makefileName.c_str(),makeTargetName.c_str()));
// Write the rule.
localName += "/all";
depends.clear();
@ -780,7 +780,7 @@ cmGlobalUnixMakefileGenerator3
this->AppendGlobalTargetDepends(depends,t->second);
lg->WriteMakeRule(ruleFileStream, "All Build rule for target.",
localName.c_str(), depends, commands, true);
// add the all/all dependency
if(!this->IsExcluded(this->LocalGenerators[0], t->second))
{
@ -831,17 +831,17 @@ cmGlobalUnixMakefileGenerator3
depends.push_back("cmake_check_build_system");
localName = lg->GetRelativeTargetDirectory(t->second);
localName += "/rule";
lg->WriteMakeRule(ruleFileStream,
lg->WriteMakeRule(ruleFileStream,
"Build rule for subdir invocation for target.",
localName.c_str(), depends, commands, true);
// Add a target with the canonical name (no prefix, suffix or path).
commands.clear();
depends.clear();
depends.push_back(localName);
lg->WriteMakeRule(ruleFileStream, "Convenience name for target.",
t->second.GetName(), depends, commands, true);
// Add rules to prepare the target for installation.
if(t->second.NeedRelinkBeforeInstall(lg->ConfigurationName.c_str()))
{
@ -851,7 +851,7 @@ cmGlobalUnixMakefileGenerator3
commands.clear();
commands.push_back(lg->GetRecursiveMakeCall
(makefileName.c_str(), localName.c_str()));
lg->WriteMakeRule(ruleFileStream,
lg->WriteMakeRule(ruleFileStream,
"Pre-install relink rule for target.",
localName.c_str(), depends, commands, true);
@ -864,7 +864,7 @@ cmGlobalUnixMakefileGenerator3
"preinstall", depends, commands, true);
}
}
// add the clean rule
localName = lg->GetRelativeTargetDirectory(t->second);
makeTargetName = localName;
@ -1005,7 +1005,7 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
lg->AppendEcho(commands,"... all (the default if no target is provided)");
lg->AppendEcho(commands,"... clean");
lg->AppendEcho(commands,"... depend");
// Keep track of targets already listed.
std::set<cmStdString> emittedTargets;
@ -1014,7 +1014,7 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
cmLocalUnixMakefileGenerator3 *lg2;
for (i = 0; i < this->LocalGenerators.size(); ++i)
{
lg2 =
lg2 =
static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
// for the passed in makefile or if this is the top Makefile wripte out
// the targets

28
Source/cmGlobalUnixMakefileGenerator3.h
View File

@ -22,19 +22,19 @@ class cmLocalUnixMakefileGenerator3;
* \brief Write a Unix makefiles.
*
* cmGlobalUnixMakefileGenerator3 manages UNIX build process for a tree
The basic approach of this generator is to produce Makefiles that will all
be run with the current working directory set to the Home Output
directory. The one exception to this is the subdirectory Makefiles which are
created as a convenience and just cd up to the Home Output directory and
invoke the main Makefiles.
invoke the main Makefiles.
The make process starts with Makefile. Makefile should only contain the
targets the user is likely to invoke directly from a make command line. No
internal targets should be in this file. Makefile2 contains the internal
targets that are required to make the process work.
Makefile2 in turn will recursively make targets in the correct order. Each
target has its own directory <target>.dir and its own makefile build.make in
that directory. Also in that directory is a couple makefiles per source file
@ -47,7 +47,7 @@ class cmLocalUnixMakefileGenerator3;
rescanned.
Rules for custom commands follow the same model as rules for source files.
*/
class cmGlobalUnixMakefileGenerator3 : public cmGlobalGenerator
@ -64,13 +64,13 @@ public:
/** Get the documentation entry for this generator. */
virtual void GetDocumentation(cmDocumentationEntry& entry) const;
///! Create a local generator appropriate to this Global Generator3
virtual cmLocalGenerator *CreateLocalGenerator();
/**
* Try to determine system infomation such as shared library
* extension, pthreads, byte order etc.
* extension, pthreads, byte order etc.
*/
virtual void EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *, bool optional);
@ -78,11 +78,11 @@ public:
/**
* Generate the all required files for building this project/tree. This
* basically creates a series of LocalGenerators for each directory and
* requests that they Generate.
* requests that they Generate.
*/
virtual void Generate();
void WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream,
std::vector<cmLocalGenerator *> &);
@ -91,7 +91,7 @@ public:
cmLocalUnixMakefileGenerator3 *);
// write the top lvel target rules
void WriteConvenienceRules(std::ostream& ruleFileStream,
void WriteConvenienceRules(std::ostream& ruleFileStream,
std::set<cmStdString> &emitted);
/** Get the command to use for a target that has no rule. This is
@ -105,7 +105,7 @@ public:
// change the build command for speed
virtual std::string GenerateBuildCommand
(const char* makeProgram,
const char *projectName, const char* additionalOptions,
const char *projectName, const char* additionalOptions,
const char *targetName,
const char* config, bool ignoreErrors, bool fast);
@ -119,7 +119,7 @@ public:
* IDE/editor.
*/
bool GetForceVerboseMakefiles() { return this->ForceVerboseMakefiles; }
void SetForceVerboseMakefiles(bool enable)
void SetForceVerboseMakefiles(bool enable)
{this->ForceVerboseMakefiles=enable;}
protected:

72
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -140,7 +140,7 @@ void cmLocalUnixMakefileGenerator3::Generate()
// write the local Makefile
this->WriteLocalMakefile();
// Write the cmake file with information for this directory.
this->WriteDirectoryInformationFile();
}
@ -149,7 +149,7 @@ void cmLocalUnixMakefileGenerator3::Generate()
void cmLocalUnixMakefileGenerator3::GetIndividualFileTargets
(std::vector<std::string>& targets)
{
for (std::map<cmStdString, LocalObjectInfo>::iterator lo =
for (std::map<cmStdString, LocalObjectInfo>::iterator lo =
this->LocalObjectFiles.begin();
lo != this->LocalObjectFiles.end(); ++lo)
{
@ -188,10 +188,10 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
{
ruleFileStream.SetCopyIfDifferent(true);
}
// write the all rules
this->WriteLocalAllRules(ruleFileStream);
// only write local targets unless at the top Keep track of targets already
// listed.
std::set<cmStdString> emittedTargets;
@ -203,7 +203,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
}
else
{
cmGlobalUnixMakefileGenerator3 *gg =
cmGlobalUnixMakefileGenerator3 *gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
gg->WriteConvenienceRules(ruleFileStream,emittedTargets);
}
@ -215,7 +215,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
// now write out the object rules
// for each object file name
for (std::map<cmStdString, LocalObjectInfo>::iterator lo =
for (std::map<cmStdString, LocalObjectInfo>::iterator lo =
this->LocalObjectFiles.begin();
lo != this->LocalObjectFiles.end(); ++lo)
{
@ -261,7 +261,7 @@ void cmLocalUnixMakefileGenerator3::WriteLocalMakefile()
// add a help target as long as there isn;t a real target named help
if(emittedTargets.insert("help").second)
{
cmGlobalUnixMakefileGenerator3 *gg =
cmGlobalUnixMakefileGenerator3 *gg =
static_cast<cmGlobalUnixMakefileGenerator3*>(this->GlobalGenerator);
gg->WriteHelpRule(ruleFileStream,this);
}
@ -353,7 +353,7 @@ void cmLocalUnixMakefileGenerator3
localName += "/rule";
commands.clear();
depends.clear();
// Build the target for this pass.
std::string makefile2 = cmake::GetCMakeFilesDirectoryPostSlash();
makefile2 += "Makefile2";
@ -364,7 +364,7 @@ void cmLocalUnixMakefileGenerator3
cmLocalGenerator::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "Convenience name for target.",
localName.c_str(), depends, commands, true);
// Add a target with the canonical name (no prefix, suffix or path).
if(localName != t->second.GetName())
{
@ -378,7 +378,7 @@ void cmLocalUnixMakefileGenerator3
std::string makefileName = this->GetRelativeTargetDirectory(t->second);
makefileName += "/build.make";
// make sure the makefile name is suitable for a makefile
std::string makeTargetName =
std::string makeTargetName =
this->GetRelativeTargetDirectory(t->second);
makeTargetName += "/build";
localName = t->second.GetName();
@ -647,7 +647,7 @@ cmLocalUnixMakefileGenerator3
makefileStream
<< "# The CMake executable.\n"
<< "CMAKE_COMMAND = "
<< this->Convert(cmakecommand.c_str(), FULL, SHELL).c_str()
<< this->Convert(cmakecommand.c_str(), FULL, SHELL).c_str()
<< "\n"
<< "\n";
makefileStream
@ -656,7 +656,7 @@ cmLocalUnixMakefileGenerator3
<< this->Convert(cmakecommand.c_str(),FULL,SHELL).c_str()
<< " -E remove -f\n"
<< "\n";
if(const char* edit_cmd =
this->Makefile->GetDefinition("CMAKE_EDIT_COMMAND"))
{
@ -722,7 +722,7 @@ cmLocalUnixMakefileGenerator3
// "VERBOSE=1" to be added as a make variable which will change the
// name of this special target. This gives a make-time choice to
// the user.
if((this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
if((this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE"))
|| (gg->GetForceVerboseMakefiles()))
{
makefileStream
@ -872,7 +872,7 @@ cmLocalUnixMakefileGenerator3
{
// Add a dependency on the rule file itself unless an option to skip
// it is specifically enabled by the user or project.
const char* nodep =
const char* nodep =
this->Makefile->GetDefinition("CMAKE_SKIP_RULE_DEPENDENCY");
if(!nodep || cmSystemTools::IsOff(nodep))
{
@ -969,7 +969,7 @@ cmLocalUnixMakefileGenerator3
{
// Build the command line in a single string.
const cmCustomCommandLine& commandLine = *cl;
std::string cmd = GetRealLocation(commandLine[0].c_str(),
std::string cmd = GetRealLocation(commandLine[0].c_str(),
this->ConfigurationName.c_str());
if (cmd.size())
{
@ -1283,7 +1283,7 @@ cmLocalUnixMakefileGenerator3
// see if the variable has been defined before and return
// the modified version of the variable
std::map<cmStdString, cmStdString>::iterator i =
std::map<cmStdString, cmStdString>::iterator i =
this->MakeVariableMap.find(unmodified);
if(i != this->MakeVariableMap.end())
{
@ -1404,7 +1404,7 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
dirInfoFile += "/CMakeDirectoryInformation.cmake";
{
int result;
if(!ftc->FileTimeCompare(internalDependFile.c_str(),
if(!ftc->FileTimeCompare(internalDependFile.c_str(),
dirInfoFile.c_str(), &result) || result < 0)
{
if(verbose)
@ -1418,7 +1418,7 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
needRescanDirInfo = true;
}
}
// Check the implicit dependencies to see if they are up to date.
// The build.make file may have explicit dependencies for the object
// files but these will not affect the scanning process so they need
@ -1433,11 +1433,11 @@ bool cmLocalUnixMakefileGenerator3::UpdateDependencies(const char* tgtInfo,
// cmDependsC::Check() fills the vector validDependencies() with the
// dependencies for those files where they are still valid, i.e. neither
// the files themselves nor any files they depend on have changed.
// We don't do that if the CMakeDirectoryInformation.cmake file has
// We don't do that if the CMakeDirectoryInformation.cmake file has
// changed, because then potentially all dependencies have changed.
// This information is given later on to cmDependsC, which then only
// rescans the files where it did not get valid dependencies via this
// dependency vector. This means that in the normal case, when only
// dependency vector. This means that in the normal case, when only
// few or one file have been edited, then also only this one file is
// actually scanned again, instead of all files for this target.
needRescanDependencies = !checker.Check(dependFile.c_str(),
@ -1485,7 +1485,7 @@ cmLocalUnixMakefileGenerator3
{
haveDirectoryInfo = true;
}
// Lookup useful directory information.
if(haveDirectoryInfo)
{
@ -1545,11 +1545,11 @@ cmLocalUnixMakefileGenerator3
this->WriteDisclaimer(ruleFileStream);
this->WriteDisclaimer(internalRuleFileStream);
// for each language we need to scan, scan it
// for each language we need to scan, scan it
const char *langStr = mf->GetSafeDefinition("CMAKE_DEPENDS_LANGUAGES");
std::vector<std::string> langs;
cmSystemTools::ExpandListArgument(langStr, langs);
for (std::vector<std::string>::iterator li =
for (std::vector<std::string>::iterator li =
langs.begin(); li != langs.end(); ++li)
{
// construct the checker
@ -1572,7 +1572,7 @@ cmLocalUnixMakefileGenerator3
scanner = new cmDependsJava();
}
#endif
if (scanner)
{
scanner->SetLocalGenerator(this);
@ -1686,25 +1686,25 @@ void cmLocalUnixMakefileGenerator3
cmLocalUnixMakefileGenerator3::EchoGlobal);
// Global targets store their rules in pre- and post-build commands.
this->AppendCustomDepends(depends,
this->AppendCustomDepends(depends,
glIt->second.GetPreBuildCommands());
this->AppendCustomDepends(depends,
this->AppendCustomDepends(depends,
glIt->second.GetPostBuildCommands());
this->AppendCustomCommands(commands,
this->AppendCustomCommands(commands,
glIt->second.GetPreBuildCommands(),
&glIt->second,
cmLocalGenerator::START_OUTPUT);
this->AppendCustomCommands(commands,
this->AppendCustomCommands(commands,
glIt->second.GetPostBuildCommands(),
&glIt->second,
cmLocalGenerator::START_OUTPUT);
std::string targetName = glIt->second.GetName();
this->WriteMakeRule(ruleFileStream, targetString.c_str(),
this->WriteMakeRule(ruleFileStream, targetString.c_str(),
targetName.c_str(), depends, commands, true);
// Provide a "/fast" version of the target.
depends.clear();
if((targetName == "install")
if((targetName == "install")
|| (targetName == "install_local")
|| (targetName == "install_strip"))
{
@ -1738,7 +1738,7 @@ void cmLocalUnixMakefileGenerator3
progressDir += cmake::GetCMakeFilesDirectory();
{
cmOStringStream progCmd;
progCmd <<
progCmd <<
"$(CMAKE_COMMAND) -E cmake_progress_start ";
progCmd << this->Convert(progressDir.c_str(),
cmLocalGenerator::FULL,
@ -1833,8 +1833,8 @@ void cmLocalUnixMakefileGenerator3
this->CreateCDCommand(commands,
this->Makefile->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT);
this->WriteMakeRule(ruleFileStream, "clear depends",
"depend",
this->WriteMakeRule(ruleFileStream, "clear depends",
"depend",
depends, commands, true);
}
@ -2048,7 +2048,7 @@ cmLocalUnixMakefileGenerator3
cmd += "$(MAKE) -f ";
cmd += this->Convert(makefile,NONE,SHELL);
cmd += " ";
// Pass down verbosity level.
if(this->GetMakeSilentFlag().size())
{
@ -2125,7 +2125,7 @@ cmLocalUnixMakefileGenerator3
std::string
cmLocalUnixMakefileGenerator3::ConvertToQuotedOutputPath(const char* p)
{
// Split the path into its components.
std::vector<std::string> components;
cmSystemTools::SplitPath(p, components);
@ -2224,7 +2224,7 @@ void cmLocalUnixMakefileGenerator3
{
return;
}
if(!this->UnixCD)
{
// On Windows we must perform each step separately and then change