CMake/Source/cmGlobalVisualStudio8Genera...

304 lines
11 KiB
C++
Raw Normal View History

2004-07-05 20:16:33 +04:00
/*=========================================================================
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 "cmGlobalVisualStudio8Generator.h"
#include "cmLocalVisualStudio7Generator.h"
#include "cmMakefile.h"
#include "cmake.h"
cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator()
{
2006-03-15 19:02:08 +03:00
this->FindMakeProgramFile = "CMakeVS8FindMake.cmake";
this->ProjectConfigurationSectionName = "ProjectConfigurationPlatforms";
this->PlatformName = "Win32";
2004-07-05 20:16:33 +04:00
}
///! Create a local generator appropriate to this Global Generator
cmLocalGenerator *cmGlobalVisualStudio8Generator::CreateLocalGenerator()
{
cmLocalVisualStudio7Generator *lg = new cmLocalVisualStudio7Generator;
lg->SetVersion8();
lg->SetExtraFlagTable(this->GetExtraFlagTableVS8());
2004-07-05 20:16:33 +04:00
lg->SetGlobalGenerator(this);
return lg;
}
// ouput standard header for dsw file
void cmGlobalVisualStudio8Generator::WriteSLNHeader(std::ostream& fout)
{
fout << "Microsoft Visual Studio Solution File, Format Version 9.00\n";
fout << "# Visual Studio 2005\n";
2004-07-05 20:16:33 +04:00
}
//----------------------------------------------------------------------------
2006-05-11 19:47:03 +04:00
void cmGlobalVisualStudio8Generator
::GetDocumentation(cmDocumentationEntry& entry) const
2004-07-05 20:16:33 +04:00
{
entry.Name = this->GetName();
entry.Brief = "Generates Visual Studio .NET 2005 project files.";
entry.Full = "";
2004-07-05 20:16:33 +04:00
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudio8Generator::AddPlatformDefinitions(cmMakefile* mf)
{
mf->AddDefinition("MSVC80", "1");
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudio8Generator::Configure()
{
this->cmGlobalVisualStudio7Generator::Configure();
this->CreateGUID(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
}
//----------------------------------------------------------------------------
std::string cmGlobalVisualStudio8Generator::GetUserMacrosDirectory()
{
std::string base;
std::string path;
// base begins with the VisualStudioProjectsLocation reg value...
if (cmSystemTools::ReadRegistryValue(
"HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\8.0;"
"VisualStudioProjectsLocation",
base))
{
cmSystemTools::ConvertToUnixSlashes(base);
// 7.0 macros folder:
//path = base + "/VSMacros";
// 7.1 macros folder:
//path = base + "/VSMacros71";
// 8.0 macros folder:
path = base + "/VSMacros80";
}
// path is (correctly) still empty if we did not read the base value from
// the Registry value
return path;
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudio8Generator::Generate()
{
// Add a special target on which all other targets depend that
// checks the build system and optionally re-runs CMake.
2006-02-08 18:58:36 +03:00
const char* no_working_directory = 0;
std::vector<std::string> no_depends;
std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
2006-03-15 19:02:08 +03:00
for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
{
std::vector<cmLocalGenerator*>& generators = it->second;
if(!generators.empty())
{
// Add the build-system check target to the first local
// generator of this project.
cmLocalVisualStudio7Generator* lg =
static_cast<cmLocalVisualStudio7Generator*>(generators[0]);
cmMakefile* mf = lg->GetMakefile();
std::string cmake_command = mf->GetRequiredDefinition("CMAKE_COMMAND");
cmCustomCommandLines noCommandLines;
2007-03-13 22:18:27 +03:00
mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, false,
no_working_directory, no_depends,
noCommandLines);
cmTarget* tgt = mf->FindTarget(CMAKE_CHECK_BUILD_SYSTEM_TARGET, false);
if(!tgt)
{
2006-05-11 19:47:03 +04:00
cmSystemTools::Error("Error adding target "
CMAKE_CHECK_BUILD_SYSTEM_TARGET);
continue;
}
// Add a custom rule to re-run CMake if any input files changed.
const char* suppRegenRule =
mf->GetDefinition("CMAKE_SUPPRESS_REGENERATION");
if(!cmSystemTools::IsOn(suppRegenRule))
{
// Collect the input files used to generate all targets in this
// project.
std::vector<std::string> listFiles;
for(unsigned int j = 0; j < generators.size(); ++j)
{
cmMakefile* lmf = generators[j]->GetMakefile();
listFiles.insert(listFiles.end(), lmf->GetListFiles().begin(),
lmf->GetListFiles().end());
}
// Sort the list of input files and remove duplicates.
2006-05-11 19:47:03 +04:00
std::sort(listFiles.begin(), listFiles.end(),
std::less<std::string>());
std::vector<std::string>::iterator new_end =
std::unique(listFiles.begin(), listFiles.end());
listFiles.erase(new_end, listFiles.end());
// Create a rule to re-run CMake.
std::string stampName = cmake::GetCMakeFilesDirectoryPostSlash();
stampName += "generate.stamp";
const char* dsprule = mf->GetRequiredDefinition("CMAKE_COMMAND");
cmCustomCommandLine commandLine;
commandLine.push_back(dsprule);
std::string argH = "-H";
argH += lg->Convert(mf->GetHomeDirectory(),
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::UNCHANGED, true);
commandLine.push_back(argH);
std::string argB = "-B";
argB += lg->Convert(mf->GetHomeOutputDirectory(),
cmLocalGenerator::START_OUTPUT,
cmLocalGenerator::UNCHANGED, true);
commandLine.push_back(argB);
commandLine.push_back("--check-stamp-file");
commandLine.push_back(stampName.c_str());
commandLine.push_back("--vs-solution-file");
commandLine.push_back("\"$(SolutionPath)\"");
cmCustomCommandLines commandLines;
commandLines.push_back(commandLine);
// Add the rule. Note that we cannot use the CMakeLists.txt
// file as the main dependency because it would get
// overwritten by the CreateVCProjBuildRule.
// (this could be avoided with per-target source files)
const char* no_main_dependency = 0;
2006-02-08 18:58:36 +03:00
const char* no_working_directory = 0;
mf->AddCustomCommandToOutput(
stampName.c_str(), listFiles,
no_main_dependency, commandLines, "Checking Build System",
no_working_directory, true);
std::string ruleName = stampName;
ruleName += ".rule";
if(cmSourceFile* file = mf->GetSource(ruleName.c_str()))
{
tgt->AddSourceFile(file);
}
else
{
cmSystemTools::Error("Error adding rule for ", stampName.c_str());
}
}
}
}
// Now perform the main generation.
this->cmGlobalVisualStudio7Generator::Generate();
}
//----------------------------------------------------------------------------
void cmGlobalVisualStudio8Generator::WriteSLNFile(
std::ostream& fout, cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators)
{
// Make all targets depend on their respective project's build
// system check target.
unsigned int i;
for(i = 0; i < generators.size(); ++i)
{
if(this->IsExcluded(root, generators[i]))
{
continue;
}
cmMakefile* mf = generators[i]->GetMakefile();
2005-12-14 02:23:37 +03:00
cmTargets& tgts = mf->GetTargets();
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l)
{
if(l->first == CMAKE_CHECK_BUILD_SYSTEM_TARGET)
{
for(unsigned int j = 0; j < generators.size(); ++j)
{
// Every target in all generators should depend on this target.
cmMakefile* lmf = generators[j]->GetMakefile();
cmTargets &atgts = lmf->GetTargets();
for(cmTargets::iterator al = atgts.begin(); al != atgts.end(); ++al)
{
al->second.AddUtility(l->first.c_str());
}
}
}
}
}
// Now write the solution file.
this->cmGlobalVisualStudio71Generator::WriteSLNFile(fout, root, generators);
}
//----------------------------------------------------------------------------
void
cmGlobalVisualStudio8Generator
::WriteSolutionConfigurations(std::ostream& fout)
{
fout << "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n";
2006-03-15 19:02:08 +03:00
for(std::vector<std::string>::iterator i = this->Configurations.begin();
i != this->Configurations.end(); ++i)
{
fout << "\t\t" << *i << "|" << this->PlatformName << " = " << *i << "|"
<< this->PlatformName << "\n";
}
fout << "\tEndGlobalSection\n";
}
//----------------------------------------------------------------------------
void
cmGlobalVisualStudio8Generator
::WriteProjectConfigurations(std::ostream& fout, const char* name,
bool partOfDefaultBuild)
{
std::string guid = this->GetGUID(name);
2006-03-15 19:02:08 +03:00
for(std::vector<std::string>::iterator i = this->Configurations.begin();
i != this->Configurations.end(); ++i)
{
fout << "\t\t{" << guid << "}." << *i
<< "|" << this->PlatformName << ".ActiveCfg = "
2006-05-11 19:47:03 +04:00
<< *i << "|" << this->PlatformName << "\n";
if(partOfDefaultBuild)
{
fout << "\t\t{" << guid << "}." << *i
<< "|" << this->PlatformName << ".Build.0 = "
2006-05-11 19:47:03 +04:00
<< *i << "|" << this->PlatformName << "\n";
}
}
}
//----------------------------------------------------------------------------
static cmVS7FlagTable cmVS8ExtraFlagTable[] =
{
// Precompiled header and related options. Note that the
// UsePrecompiledHeader entries are marked as "Continue" so that the
// corresponding PrecompiledHeaderThrough entry can be found.
{"UsePrecompiledHeader", "Yu", "Use Precompiled Header", "2",
cmVS7FlagTable::UserValueIgnored | cmVS7FlagTable::Continue},
{"PrecompiledHeaderThrough", "Yu", "Precompiled Header Name", "",
cmVS7FlagTable::UserValueRequired},
// There is no YX option in the VS8 IDE.
// Exception handling mode. If no entries match, it will be FALSE.
{"ExceptionHandling", "GX", "enable c++ exceptions", "1", 0},
{"ExceptionHandling", "EHsc", "enable c++ exceptions", "1", 0},
{"ExceptionHandling", "EHa", "enable SEH exceptions", "2", 0},
{0,0,0,0,0}
};
cmVS7FlagTable const* cmGlobalVisualStudio8Generator::GetExtraFlagTableVS8()
{
return cmVS8ExtraFlagTable;
}