0d83faf3e3
The previous change to make ALL_BUILD come first among targets did not account for comparing the target name against itself. This led to an invalid ordering of the target set. This change fixes it.
784 lines
24 KiB
C++
784 lines
24 KiB
C++
/*=========================================================================
|
|
|
|
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 "windows.h" // this must be first to define GetCurrentDirectory
|
|
#include "cmGlobalVisualStudio7Generator.h"
|
|
#include "cmGeneratedFileStream.h"
|
|
#include "cmLocalVisualStudio7Generator.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmake.h"
|
|
|
|
cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator()
|
|
{
|
|
this->FindMakeProgramFile = "CMakeVS7FindMake.cmake";
|
|
}
|
|
|
|
|
|
void cmGlobalVisualStudio7Generator
|
|
::EnableLanguage(std::vector<std::string>const & lang,
|
|
cmMakefile *mf, bool optional)
|
|
{
|
|
mf->AddDefinition("CMAKE_GENERATOR_CC", "cl");
|
|
mf->AddDefinition("CMAKE_GENERATOR_CXX", "cl");
|
|
mf->AddDefinition("CMAKE_GENERATOR_RC", "rc");
|
|
mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
|
|
mf->AddDefinition("CMAKE_GENERATOR_FC", "ifort");
|
|
|
|
this->AddPlatformDefinitions(mf);
|
|
|
|
// Create list of configurations requested by user's cache, if any.
|
|
this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
|
|
this->GenerateConfigurations(mf);
|
|
|
|
// if this environment variable is set, then copy it to
|
|
// a static cache entry. It will be used by
|
|
// cmLocalGenerator::ConstructScript, to add an extra PATH
|
|
// to all custom commands. This is because the VS IDE
|
|
// does not use the environment it is run in, and this allows
|
|
// for running commands and using dll's that the IDE environment
|
|
// does not know about.
|
|
const char* extraPath = cmSystemTools::GetEnv("CMAKE_MSVCIDE_RUN_PATH");
|
|
if(extraPath)
|
|
{
|
|
mf->AddCacheDefinition
|
|
("CMAKE_MSVCIDE_RUN_PATH", extraPath,
|
|
"Saved environment variable CMAKE_MSVCIDE_RUN_PATH",
|
|
cmCacheManager::STATIC);
|
|
}
|
|
|
|
}
|
|
|
|
void cmGlobalVisualStudio7Generator::AddPlatformDefinitions(cmMakefile* mf)
|
|
{
|
|
mf->AddDefinition("MSVC70", "1");
|
|
}
|
|
|
|
std::string cmGlobalVisualStudio7Generator
|
|
::GenerateBuildCommand(const char* makeProgram,
|
|
const char *projectName,
|
|
const char* additionalOptions, const char *targetName,
|
|
const char* config, bool ignoreErrors, bool)
|
|
{
|
|
// Ingoring errors is not implemented in visual studio 6
|
|
(void) ignoreErrors;
|
|
|
|
// now build the test
|
|
std::string makeCommand =
|
|
cmSystemTools::ConvertToOutputPath(makeProgram);
|
|
std::string lowerCaseCommand = makeCommand;
|
|
cmSystemTools::LowerCase(lowerCaseCommand);
|
|
|
|
// if there are spaces in the makeCommand, assume a full path
|
|
// and convert it to a path with no spaces in it as the
|
|
// RunSingleCommand does not like spaces
|
|
#if defined(_WIN32) && !defined(__CYGWIN__)
|
|
if(makeCommand.find(' ') != std::string::npos)
|
|
{
|
|
cmSystemTools::GetShortPath(makeCommand.c_str(), makeCommand);
|
|
}
|
|
#endif
|
|
makeCommand += " ";
|
|
makeCommand += projectName;
|
|
makeCommand += ".sln ";
|
|
bool clean = false;
|
|
if ( targetName && strcmp(targetName, "clean") == 0 )
|
|
{
|
|
clean = true;
|
|
targetName = "ALL_BUILD";
|
|
}
|
|
if(clean)
|
|
{
|
|
makeCommand += "/clean ";
|
|
}
|
|
else
|
|
{
|
|
makeCommand += "/build ";
|
|
}
|
|
|
|
if(config && strlen(config))
|
|
{
|
|
makeCommand += config;
|
|
}
|
|
else
|
|
{
|
|
makeCommand += "Debug";
|
|
}
|
|
makeCommand += " /project ";
|
|
|
|
if (targetName && strlen(targetName))
|
|
{
|
|
makeCommand += targetName;
|
|
}
|
|
else
|
|
{
|
|
makeCommand += "ALL_BUILD";
|
|
}
|
|
if ( additionalOptions )
|
|
{
|
|
makeCommand += " ";
|
|
makeCommand += additionalOptions;
|
|
}
|
|
return makeCommand;
|
|
}
|
|
|
|
///! Create a local generator appropriate to this Global Generator
|
|
cmLocalGenerator *cmGlobalVisualStudio7Generator::CreateLocalGenerator()
|
|
{
|
|
cmLocalVisualStudio7Generator *lg = new cmLocalVisualStudio7Generator;
|
|
lg->SetExtraFlagTable(this->GetExtraFlagTableVS7());
|
|
lg->SetGlobalGenerator(this);
|
|
return lg;
|
|
}
|
|
|
|
void cmGlobalVisualStudio7Generator::GenerateConfigurations(cmMakefile* mf)
|
|
{
|
|
// process the configurations
|
|
const char* ct
|
|
= this->CMakeInstance->GetCacheDefinition("CMAKE_CONFIGURATION_TYPES");
|
|
if ( ct )
|
|
{
|
|
std::vector<std::string> argsOut;
|
|
cmSystemTools::ExpandListArgument(ct, argsOut);
|
|
for(std::vector<std::string>::iterator i = argsOut.begin();
|
|
i != argsOut.end(); ++i)
|
|
{
|
|
if(std::find(this->Configurations.begin(),
|
|
this->Configurations.end(),
|
|
*i) == this->Configurations.end())
|
|
{
|
|
this->Configurations.push_back(*i);
|
|
}
|
|
}
|
|
}
|
|
// default to at least Debug and Release
|
|
if(this->Configurations.size() == 0)
|
|
{
|
|
this->Configurations.push_back("Debug");
|
|
this->Configurations.push_back("Release");
|
|
}
|
|
|
|
// Reset the entry to have a semi-colon separated list.
|
|
std::string configs = this->Configurations[0];
|
|
for(unsigned int i=1; i < this->Configurations.size(); ++i)
|
|
{
|
|
configs += ";";
|
|
configs += this->Configurations[i];
|
|
}
|
|
|
|
mf->AddCacheDefinition(
|
|
"CMAKE_CONFIGURATION_TYPES",
|
|
configs.c_str(),
|
|
"Semicolon separated list of supported configuration types, "
|
|
"only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
|
|
"anything else will be ignored.",
|
|
cmCacheManager::STRING);
|
|
}
|
|
|
|
void cmGlobalVisualStudio7Generator::Generate()
|
|
{
|
|
// first do the superclass method
|
|
this->cmGlobalVisualStudioGenerator::Generate();
|
|
|
|
// Now write out the DSW
|
|
this->OutputSLNFile();
|
|
|
|
// If any solution or project files changed during the generation,
|
|
// tell Visual Studio to reload them...
|
|
if(!cmSystemTools::GetErrorOccuredFlag())
|
|
{
|
|
this->CallVisualStudioMacro(MacroReload);
|
|
}
|
|
}
|
|
|
|
void cmGlobalVisualStudio7Generator
|
|
::OutputSLNFile(cmLocalGenerator* root,
|
|
std::vector<cmLocalGenerator*>& generators)
|
|
{
|
|
if(generators.size() == 0)
|
|
{
|
|
return;
|
|
}
|
|
this->CurrentProject = root->GetMakefile()->GetProjectName();
|
|
std::string fname = root->GetMakefile()->GetStartOutputDirectory();
|
|
fname += "/";
|
|
fname += root->GetMakefile()->GetProjectName();
|
|
fname += ".sln";
|
|
cmGeneratedFileStream fout(fname.c_str());
|
|
fout.SetCopyIfDifferent(true);
|
|
if(!fout)
|
|
{
|
|
return;
|
|
}
|
|
this->WriteSLNFile(fout, root, generators);
|
|
if (fout.Close())
|
|
{
|
|
this->FileReplacedDuringGenerate(fname);
|
|
}
|
|
}
|
|
|
|
// output the SLN file
|
|
void cmGlobalVisualStudio7Generator::OutputSLNFile()
|
|
{
|
|
std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
|
|
for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
|
|
{
|
|
this->OutputSLNFile(it->second[0], it->second);
|
|
}
|
|
}
|
|
|
|
|
|
void cmGlobalVisualStudio7Generator::AddAllBuildDepends(
|
|
cmLocalGenerator* root,
|
|
cmTarget* target,
|
|
cmGlobalGenerator::TargetDependSet& originalTargets)
|
|
{
|
|
// if this is the special ALL_BUILD utility, then
|
|
// make it depend on every other non UTILITY project.
|
|
for(cmGlobalGenerator::TargetDependSet::iterator ot =
|
|
originalTargets.begin(); ot != originalTargets.end(); ++ot)
|
|
{
|
|
cmTarget* t = const_cast<cmTarget*>(*ot);
|
|
if(!this->IsExcluded(root, *t))
|
|
{
|
|
target->AddUtility(t->GetName());
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmGlobalVisualStudio7Generator::WriteTargetConfigurations(
|
|
std::ostream& fout,
|
|
cmLocalGenerator* root,
|
|
OrderedTargetDependSet const& projectTargets)
|
|
{
|
|
// loop over again and write out configurations for each target
|
|
// in the solution
|
|
for(OrderedTargetDependSet::const_iterator tt =
|
|
projectTargets.begin(); tt != projectTargets.end(); ++tt)
|
|
{
|
|
cmTarget* target = *tt;
|
|
if (strncmp(target->GetName(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0)
|
|
{
|
|
cmCustomCommand cc = target->GetPostBuildCommands()[0];
|
|
const cmCustomCommandLines& cmds = cc.GetCommandLines();
|
|
std::string project = cmds[0][0];
|
|
this->WriteProjectConfigurations(fout, project.c_str(),
|
|
true);
|
|
}
|
|
else
|
|
{
|
|
bool partOfDefaultBuild = this->IsPartOfDefaultBuild(
|
|
root->GetMakefile()->GetProjectName(), target);
|
|
const char *vcprojName =
|
|
target->GetProperty("GENERATOR_FILE_NAME");
|
|
if (vcprojName)
|
|
{
|
|
this->WriteProjectConfigurations(fout, vcprojName,
|
|
partOfDefaultBuild);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
|
|
std::ostream& fout,
|
|
cmLocalGenerator* root,
|
|
OrderedTargetDependSet const& projectTargets,
|
|
cmGlobalGenerator::TargetDependSet& originalTargets
|
|
)
|
|
{
|
|
std::string rootdir = root->GetMakefile()->GetStartOutputDirectory();
|
|
rootdir += "/";
|
|
for(OrderedTargetDependSet::const_iterator tt =
|
|
projectTargets.begin(); tt != projectTargets.end(); ++tt)
|
|
{
|
|
cmTarget* target = *tt;
|
|
cmMakefile* mf = target->GetMakefile();
|
|
// look for the all_build rule and add depends to all
|
|
// of the original targets (none that were "pulled" into this project)
|
|
if(mf == root->GetMakefile() &&
|
|
strcmp(target->GetName(), "ALL_BUILD") == 0)
|
|
{
|
|
this->AddAllBuildDepends(root, target, originalTargets);
|
|
}
|
|
// handle external vc project files
|
|
if (strncmp(target->GetName(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0)
|
|
{
|
|
cmCustomCommand cc = target->GetPostBuildCommands()[0];
|
|
const cmCustomCommandLines& cmds = cc.GetCommandLines();
|
|
std::string project = cmds[0][0];
|
|
std::string location = cmds[0][1];
|
|
this->WriteExternalProject(fout, project.c_str(),
|
|
location.c_str(), cc.GetDepends());
|
|
}
|
|
else
|
|
{
|
|
bool skip = false;
|
|
// if it is a global target or the check build system target
|
|
// or the all_build target
|
|
// then only use the one that is for the root
|
|
if(target->GetType() == cmTarget::GLOBAL_TARGET
|
|
|| !strcmp(target->GetName(), CMAKE_CHECK_BUILD_SYSTEM_TARGET)
|
|
|| !strcmp(target->GetName(), this->GetAllTargetName()))
|
|
{
|
|
if(target->GetMakefile() != root->GetMakefile())
|
|
{
|
|
skip = true;
|
|
}
|
|
}
|
|
// if not skipping the project then write it into the
|
|
// solution
|
|
if(!skip)
|
|
{
|
|
const char *vcprojName =
|
|
target->GetProperty("GENERATOR_FILE_NAME");
|
|
if(vcprojName)
|
|
{
|
|
cmMakefile* tmf = target->GetMakefile();
|
|
std::string dir = tmf->GetStartOutputDirectory();
|
|
dir = root->Convert(dir.c_str(),
|
|
cmLocalGenerator::START_OUTPUT);
|
|
this->WriteProject(fout, vcprojName, dir.c_str(),
|
|
*target);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void cmGlobalVisualStudio7Generator::WriteTargetDepends(
|
|
std::ostream& fout,
|
|
OrderedTargetDependSet const& projectTargets
|
|
)
|
|
{
|
|
for(OrderedTargetDependSet::const_iterator tt =
|
|
projectTargets.begin(); tt != projectTargets.end(); ++tt)
|
|
{
|
|
cmTarget* target = *tt;
|
|
cmMakefile* mf = target->GetMakefile();
|
|
if (strncmp(target->GetName(), "INCLUDE_EXTERNAL_MSPROJECT", 26) == 0)
|
|
{
|
|
cmCustomCommand cc = target->GetPostBuildCommands()[0];
|
|
const cmCustomCommandLines& cmds = cc.GetCommandLines();
|
|
std::string name = cmds[0][0];
|
|
std::vector<std::string> depends = cc.GetDepends();
|
|
std::vector<std::string>::iterator iter;
|
|
int depcount = 0;
|
|
for(iter = depends.begin(); iter != depends.end(); ++iter)
|
|
{
|
|
std::string guid = this->GetGUID(iter->c_str());
|
|
if(guid.size() == 0)
|
|
{
|
|
std::string m = "Target: ";
|
|
m += target->GetName();
|
|
m += " depends on unknown target: ";
|
|
m += iter->c_str();
|
|
cmSystemTools::Error(m.c_str());
|
|
}
|
|
|
|
fout << "\t\t{" << this->GetGUID(name.c_str())
|
|
<< "}." << depcount << " = {" << guid.c_str() << "}\n";
|
|
depcount++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const char *vcprojName =
|
|
target->GetProperty("GENERATOR_FILE_NAME");
|
|
if (vcprojName)
|
|
{
|
|
std::string dir = mf->GetStartDirectory();
|
|
this->WriteProjectDepends(fout, vcprojName,
|
|
dir.c_str(), *target);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Write a SLN file to the stream
|
|
void cmGlobalVisualStudio7Generator
|
|
::WriteSLNFile(std::ostream& fout,
|
|
cmLocalGenerator* root,
|
|
std::vector<cmLocalGenerator*>& generators)
|
|
{
|
|
// Write out the header for a SLN file
|
|
this->WriteSLNHeader(fout);
|
|
|
|
// collect the set of targets for this project by
|
|
// tracing depends of all targets.
|
|
// also collect the set of targets that are explicitly
|
|
// in this project.
|
|
cmGlobalGenerator::TargetDependSet projectTargets;
|
|
cmGlobalGenerator::TargetDependSet originalTargets;
|
|
this->GetTargetSets(projectTargets,
|
|
originalTargets,
|
|
root, generators);
|
|
OrderedTargetDependSet orderedProjectTargets(projectTargets);
|
|
this->WriteTargetsToSolution(fout, root, orderedProjectTargets,
|
|
originalTargets);
|
|
// Write out the configurations information for the solution
|
|
fout << "Global\n"
|
|
<< "\tGlobalSection(SolutionConfiguration) = preSolution\n";
|
|
|
|
int c = 0;
|
|
for(std::vector<std::string>::iterator i = this->Configurations.begin();
|
|
i != this->Configurations.end(); ++i)
|
|
{
|
|
fout << "\t\tConfigName." << c << " = " << *i << "\n";
|
|
c++;
|
|
}
|
|
fout << "\tEndGlobalSection\n";
|
|
// Write out project(target) depends
|
|
fout << "\tGlobalSection(ProjectDependencies) = postSolution\n";
|
|
this->WriteTargetDepends(fout, orderedProjectTargets);
|
|
fout << "\tEndGlobalSection\n";
|
|
|
|
// Write out the configurations for all the targets in the project
|
|
fout << "\tGlobalSection(ProjectConfiguration) = postSolution\n";
|
|
this->WriteTargetConfigurations(fout, root, orderedProjectTargets);
|
|
fout << "\tEndGlobalSection\n";
|
|
|
|
// Write the footer for the SLN file
|
|
this->WriteSLNFooter(fout);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
std::string
|
|
cmGlobalVisualStudio7Generator::ConvertToSolutionPath(const char* path)
|
|
{
|
|
// Convert to backslashes. Do not use ConvertToOutputPath because
|
|
// we will add quoting ourselves, and we know these projects always
|
|
// use windows slashes.
|
|
std::string d = path;
|
|
std::string::size_type pos = 0;
|
|
while((pos = d.find('/', pos)) != d.npos)
|
|
{
|
|
d[pos++] = '\\';
|
|
}
|
|
return d;
|
|
}
|
|
|
|
// Write a dsp file into the SLN file,
|
|
// Note, that dependencies from executables to
|
|
// the libraries it uses are also done here
|
|
void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout,
|
|
const char* dspname,
|
|
const char* dir, cmTarget& target)
|
|
{
|
|
// check to see if this is a fortran build
|
|
const char* ext = ".vcproj";
|
|
const char* project =
|
|
"Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"";
|
|
if(this->TargetIsFortranOnly(target))
|
|
{
|
|
ext = ".vfproj";
|
|
project = "Project(\"{6989167D-11E4-40FE-8C1A-2192A86A7E90}\") = \"";
|
|
}
|
|
|
|
fout << project
|
|
<< dspname << "\", \""
|
|
<< this->ConvertToSolutionPath(dir)
|
|
<< "\\" << dspname << ext << "\", \"{"
|
|
<< this->GetGUID(dspname) << "}\"\nEndProject\n";
|
|
}
|
|
|
|
|
|
|
|
// Write a dsp file into the SLN file,
|
|
// Note, that dependencies from executables to
|
|
// the libraries it uses are also done here
|
|
void
|
|
cmGlobalVisualStudio7Generator
|
|
::WriteProjectDepends(std::ostream& fout,
|
|
const char* dspname,
|
|
const char*, cmTarget& target)
|
|
{
|
|
int depcount = 0;
|
|
// insert Begin Project Dependency Project_Dep_Name project stuff here
|
|
if (target.GetType() != cmTarget::STATIC_LIBRARY)
|
|
{
|
|
cmTarget::LinkLibraryVectorType::const_iterator j, jend;
|
|
j = target.GetLinkLibraries().begin();
|
|
jend = target.GetLinkLibraries().end();
|
|
for(;j!= jend; ++j)
|
|
{
|
|
if(j->first != dspname)
|
|
{
|
|
// is the library part of this SLN ? If so add dependency
|
|
if(this->FindTarget(0, j->first.c_str()))
|
|
{
|
|
std::string guid = this->GetGUID(j->first.c_str());
|
|
if(guid.size() == 0)
|
|
{
|
|
std::string m = "Target: ";
|
|
m += dspname;
|
|
m += " depends on unknown target: ";
|
|
m += j->first.c_str();
|
|
cmSystemTools::Error(m.c_str());
|
|
}
|
|
fout << "\t\t{" << this->GetGUID(dspname) << "}."
|
|
<< depcount << " = {" << guid << "}\n";
|
|
depcount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::set<cmStdString>::const_iterator i, end;
|
|
// write utility dependencies.
|
|
i = target.GetUtilities().begin();
|
|
end = target.GetUtilities().end();
|
|
for(;i!= end; ++i)
|
|
{
|
|
if(*i != dspname)
|
|
{
|
|
std::string name = this->GetUtilityForTarget(target, i->c_str());
|
|
std::string guid = this->GetGUID(name.c_str());
|
|
if(guid.size() == 0)
|
|
{
|
|
std::string m = "Target: ";
|
|
m += dspname;
|
|
m += " depends on unknown target: ";
|
|
m += name.c_str();
|
|
cmSystemTools::Error(m.c_str());
|
|
}
|
|
|
|
fout << "\t\t{" << this->GetGUID(dspname) << "}." << depcount << " = {"
|
|
<< guid << "}\n";
|
|
depcount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Write a dsp file into the SLN file, Note, that dependencies from
|
|
// executables to the libraries it uses are also done here
|
|
void cmGlobalVisualStudio7Generator
|
|
::WriteProjectConfigurations(std::ostream& fout, const char* name,
|
|
bool partOfDefaultBuild)
|
|
{
|
|
std::string guid = this->GetGUID(name);
|
|
for(std::vector<std::string>::iterator i = this->Configurations.begin();
|
|
i != this->Configurations.end(); ++i)
|
|
{
|
|
fout << "\t\t{" << guid << "}." << *i
|
|
<< ".ActiveCfg = " << *i << "|Win32\n";
|
|
if(partOfDefaultBuild)
|
|
{
|
|
fout << "\t\t{" << guid << "}." << *i
|
|
<< ".Build.0 = " << *i << "|Win32\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Write a dsp file into the SLN file,
|
|
// Note, that dependencies from executables to
|
|
// the libraries it uses are also done here
|
|
void cmGlobalVisualStudio7Generator::WriteExternalProject(std::ostream& fout,
|
|
const char* name,
|
|
const char* location,
|
|
const std::vector<std::string>&)
|
|
{
|
|
std::cout << "WriteExternalProject vs7\n";
|
|
std::string d = cmSystemTools::ConvertToOutputPath(location);
|
|
fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \""
|
|
<< name << "\", \""
|
|
<< this->ConvertToSolutionPath(location) << "\", \"{"
|
|
<< this->GetGUID(name)
|
|
<< "}\"\n";
|
|
fout << "EndProject\n";
|
|
}
|
|
|
|
|
|
|
|
// Standard end of dsw file
|
|
void cmGlobalVisualStudio7Generator::WriteSLNFooter(std::ostream& fout)
|
|
{
|
|
fout << "\tGlobalSection(ExtensibilityGlobals) = postSolution\n"
|
|
<< "\tEndGlobalSection\n"
|
|
<< "\tGlobalSection(ExtensibilityAddIns) = postSolution\n"
|
|
<< "\tEndGlobalSection\n"
|
|
<< "EndGlobal\n";
|
|
}
|
|
|
|
|
|
// ouput standard header for dsw file
|
|
void cmGlobalVisualStudio7Generator::WriteSLNHeader(std::ostream& fout)
|
|
{
|
|
fout << "Microsoft Visual Studio Solution File, Format Version 7.00\n";
|
|
}
|
|
|
|
std::string cmGlobalVisualStudio7Generator::GetGUID(const char* name)
|
|
{
|
|
std::string guidStoreName = name;
|
|
guidStoreName += "_GUID_CMAKE";
|
|
const char* storedGUID =
|
|
this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str());
|
|
if(storedGUID)
|
|
{
|
|
return std::string(storedGUID);
|
|
}
|
|
cmSystemTools::Error("Unknown Target referenced : ",
|
|
name);
|
|
return "";
|
|
}
|
|
|
|
|
|
void cmGlobalVisualStudio7Generator::CreateGUID(const char* name)
|
|
{
|
|
std::string guidStoreName = name;
|
|
guidStoreName += "_GUID_CMAKE";
|
|
if(this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str()))
|
|
{
|
|
return;
|
|
}
|
|
std::string ret;
|
|
UUID uid;
|
|
unsigned char *uidstr;
|
|
UuidCreate(&uid);
|
|
UuidToString(&uid,&uidstr);
|
|
ret = reinterpret_cast<char*>(uidstr);
|
|
RpcStringFree(&uidstr);
|
|
ret = cmSystemTools::UpperCase(ret);
|
|
this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(),
|
|
ret.c_str(), "Stored GUID",
|
|
cmCacheManager::INTERNAL);
|
|
}
|
|
|
|
std::vector<std::string> *cmGlobalVisualStudio7Generator::GetConfigurations()
|
|
{
|
|
return &this->Configurations;
|
|
};
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmGlobalVisualStudio7Generator
|
|
::GetDocumentation(cmDocumentationEntry& entry) const
|
|
{
|
|
entry.Name = this->GetName();
|
|
entry.Brief = "Generates Visual Studio .NET 2002 project files.";
|
|
entry.Full = "";
|
|
}
|
|
|
|
// make sure "special" targets have GUID's
|
|
void cmGlobalVisualStudio7Generator::Configure()
|
|
{
|
|
cmGlobalGenerator::Configure();
|
|
this->CreateGUID("ALL_BUILD");
|
|
this->CreateGUID("INSTALL");
|
|
this->CreateGUID("RUN_TESTS");
|
|
this->CreateGUID("EDIT_CACHE");
|
|
this->CreateGUID("REBUILD_CACHE");
|
|
this->CreateGUID("PACKAGE");
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
cmGlobalVisualStudio7Generator
|
|
::AppendDirectoryForConfig(const char* prefix,
|
|
const char* config,
|
|
const char* suffix,
|
|
std::string& dir)
|
|
{
|
|
if(config)
|
|
{
|
|
dir += prefix;
|
|
dir += config;
|
|
dir += suffix;
|
|
}
|
|
}
|
|
|
|
bool cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(const char* project,
|
|
cmTarget* target)
|
|
{
|
|
if(target->GetPropertyAsBool("EXCLUDE_FROM_DEFAULT_BUILD"))
|
|
{
|
|
return false;
|
|
}
|
|
// if it is a utilitiy target then only make it part of the
|
|
// default build if another target depends on it
|
|
int type = target->GetType();
|
|
if (type == cmTarget::GLOBAL_TARGET)
|
|
{
|
|
return false;
|
|
}
|
|
if(type == cmTarget::UTILITY)
|
|
{
|
|
return this->IsDependedOn(project, target);
|
|
}
|
|
// default is to be part of the build
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
cmGlobalVisualStudio7Generator::TargetCompare
|
|
::operator()(cmTarget const* l, cmTarget const* r)
|
|
{
|
|
// Make sure ALL_BUILD is first so it is the default active project.
|
|
if(strcmp(r->GetName(), "ALL_BUILD") == 0)
|
|
{
|
|
return false;
|
|
}
|
|
if(strcmp(l->GetName(), "ALL_BUILD") == 0)
|
|
{
|
|
return true;
|
|
}
|
|
return strcmp(l->GetName(), r->GetName()) < 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
cmGlobalVisualStudio7Generator::OrderedTargetDependSet
|
|
::OrderedTargetDependSet(cmGlobalGenerator::TargetDependSet const& targets)
|
|
{
|
|
for(cmGlobalGenerator::TargetDependSet::const_iterator ti =
|
|
targets.begin(); ti != targets.end(); ++ti)
|
|
{
|
|
this->insert(*ti);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
static cmVS7FlagTable cmVS7ExtraFlagTable[] =
|
|
{
|
|
// Precompiled header and related options. Note that the
|
|
// UsePrecompiledHeader entries are marked as "Continue" so that the
|
|
// corresponding PrecompiledHeaderThrough entry can be found.
|
|
{"UsePrecompiledHeader", "YX", "Automatically Generate", "2",
|
|
cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
|
|
{"PrecompiledHeaderThrough", "YX", "Precompiled Header Name", "",
|
|
cmVS7FlagTable::UserValueRequired},
|
|
{"UsePrecompiledHeader", "Yu", "Use Precompiled Header", "3",
|
|
cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
|
|
{"PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
|
|
cmVS7FlagTable::UserValueRequired},
|
|
{"WholeProgramOptimization", "LTCG", "WholeProgramOptimization", "TRUE", 0},
|
|
|
|
// Exception handling mode. If no entries match, it will be FALSE.
|
|
{"ExceptionHandling", "GX", "enable c++ exceptions", "TRUE", 0},
|
|
{"ExceptionHandling", "EHsc", "enable c++ exceptions", "TRUE", 0},
|
|
// The EHa option does not have an IDE setting. Let it go to false,
|
|
// and have EHa passed on the command line by leaving out the table
|
|
// entry.
|
|
|
|
{0,0,0,0,0}
|
|
};
|
|
cmVS7FlagTable const* cmGlobalVisualStudio7Generator::GetExtraFlagTableVS7()
|
|
{
|
|
return cmVS7ExtraFlagTable;
|
|
}
|