You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
563 lines
19 KiB
563 lines
19 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#include "cmGlobalVisualStudio8Generator.h"
|
|
|
|
#include <algorithm>
|
|
#include <functional>
|
|
#include <ostream>
|
|
#include <utility>
|
|
|
|
#include <cm/memory>
|
|
#include <cmext/algorithm>
|
|
#include <cmext/memory>
|
|
|
|
#include "cmCustomCommand.h"
|
|
#include "cmCustomCommandLines.h"
|
|
#include "cmCustomCommandTypes.h"
|
|
#include "cmGeneratedFileStream.h"
|
|
#include "cmGeneratorExpression.h"
|
|
#include "cmGeneratorTarget.h"
|
|
#include "cmGlobalGenerator.h"
|
|
#include "cmGlobalVisualStudio7Generator.h"
|
|
#include "cmGlobalVisualStudioGenerator.h"
|
|
#include "cmList.h"
|
|
#include "cmListFileCache.h"
|
|
#include "cmLocalGenerator.h"
|
|
#include "cmLocalVisualStudio7Generator.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmPolicies.h"
|
|
#include "cmSourceFile.h"
|
|
#include "cmStateTypes.h"
|
|
#include "cmStringAlgorithms.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmTarget.h"
|
|
#include "cmTargetDepend.h"
|
|
#include "cmValue.h"
|
|
#include "cmVisualStudioGeneratorOptions.h"
|
|
#include "cmake.h"
|
|
|
|
struct cmIDEFlagTable;
|
|
|
|
cmGlobalVisualStudio8Generator::cmGlobalVisualStudio8Generator(
|
|
cmake* cm, const std::string& name,
|
|
std::string const& platformInGeneratorName)
|
|
: cmGlobalVisualStudio71Generator(cm, platformInGeneratorName)
|
|
{
|
|
this->ProjectConfigurationSectionName = "ProjectConfigurationPlatforms";
|
|
this->Name = name;
|
|
this->ExtraFlagTable =
|
|
cmGlobalVisualStudio8Generator::GetExtraFlagTableVS8();
|
|
}
|
|
|
|
std::string cmGlobalVisualStudio8Generator::FindDevEnvCommand()
|
|
{
|
|
// First look for VCExpress.
|
|
std::string vsxcmd;
|
|
std::string vsxkey =
|
|
cmStrCat(R"(HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VCExpress\)",
|
|
this->GetIDEVersion(), ";InstallDir");
|
|
if (cmSystemTools::ReadRegistryValue(vsxkey, vsxcmd,
|
|
cmSystemTools::KeyWOW64_32)) {
|
|
cmSystemTools::ConvertToUnixSlashes(vsxcmd);
|
|
vsxcmd += "/VCExpress.exe";
|
|
return vsxcmd;
|
|
}
|
|
// Now look for devenv.
|
|
return this->cmGlobalVisualStudio71Generator::FindDevEnvCommand();
|
|
}
|
|
|
|
void cmGlobalVisualStudio8Generator::EnableLanguage(
|
|
std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
|
|
{
|
|
for (std::string const& it : lang) {
|
|
if (it == "ASM_MASM") {
|
|
this->MasmEnabled = true;
|
|
}
|
|
}
|
|
this->AddPlatformDefinitions(mf);
|
|
cmGlobalVisualStudio7Generator::EnableLanguage(lang, mf, optional);
|
|
}
|
|
|
|
void cmGlobalVisualStudio8Generator::AddPlatformDefinitions(cmMakefile* mf)
|
|
{
|
|
if (this->TargetsWindowsCE()) {
|
|
mf->AddDefinition("CMAKE_VS_WINCE_VERSION", this->WindowsCEVersion);
|
|
}
|
|
}
|
|
|
|
bool cmGlobalVisualStudio8Generator::SetGeneratorPlatform(std::string const& p,
|
|
cmMakefile* mf)
|
|
{
|
|
if (this->PlatformInGeneratorName) {
|
|
// This is an old-style generator name that contains the platform name.
|
|
// No explicit platform specification is supported, so pass it through
|
|
// to our base class implementation, which errors on non-empty platforms.
|
|
return this->cmGlobalVisualStudio7Generator::SetGeneratorPlatform(p, mf);
|
|
}
|
|
|
|
if (!this->ParseGeneratorPlatform(p, mf)) {
|
|
return false;
|
|
}
|
|
|
|
// FIXME: Add CMAKE_GENERATOR_PLATFORM field to set the framework.
|
|
// For now, just report the generator's default, if any.
|
|
if (cm::optional<std::string> const& targetFrameworkVersion =
|
|
this->GetTargetFrameworkVersion()) {
|
|
mf->AddDefinition("CMAKE_VS_TARGET_FRAMEWORK_VERSION",
|
|
*targetFrameworkVersion);
|
|
}
|
|
if (cm::optional<std::string> const& targetFrameworkIdentifier =
|
|
this->GetTargetFrameworkIdentifier()) {
|
|
mf->AddDefinition("CMAKE_VS_TARGET_FRAMEWORK_IDENTIFIER",
|
|
*targetFrameworkIdentifier);
|
|
}
|
|
if (cm::optional<std::string> const& targetFrameworkTargetsVersion =
|
|
this->GetTargetFrameworkTargetsVersion()) {
|
|
mf->AddDefinition("CMAKE_VS_TARGET_FRAMEWORK_TARGETS_VERSION",
|
|
*targetFrameworkTargetsVersion);
|
|
}
|
|
|
|
// The generator name does not contain the platform name, and so supports
|
|
// explicit platform specification. We handled that above, so pass an
|
|
// empty platform name to our base class implementation so it does not error.
|
|
return this->cmGlobalVisualStudio7Generator::SetGeneratorPlatform("", mf);
|
|
}
|
|
|
|
bool cmGlobalVisualStudio8Generator::ParseGeneratorPlatform(
|
|
std::string const& p, cmMakefile* mf)
|
|
{
|
|
this->GeneratorPlatform.clear();
|
|
|
|
std::vector<std::string> const fields = cmTokenize(p, ",");
|
|
auto fi = fields.begin();
|
|
if (fi == fields.end()) {
|
|
return true;
|
|
}
|
|
|
|
// The first field may be the VS platform.
|
|
if (fi->find('=') == fi->npos) {
|
|
this->GeneratorPlatform = *fi;
|
|
++fi;
|
|
}
|
|
|
|
std::set<std::string> handled;
|
|
|
|
// The rest of the fields must be key=value pairs.
|
|
for (; fi != fields.end(); ++fi) {
|
|
std::string::size_type pos = fi->find('=');
|
|
if (pos == fi->npos) {
|
|
std::ostringstream e;
|
|
/* clang-format off */
|
|
e <<
|
|
"Generator\n"
|
|
" " << this->GetName() << "\n"
|
|
"given platform specification\n"
|
|
" " << p << "\n"
|
|
"that contains a field after the first ',' with no '='."
|
|
;
|
|
/* clang-format on */
|
|
mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
|
|
return false;
|
|
}
|
|
std::string const key = fi->substr(0, pos);
|
|
std::string const value = fi->substr(pos + 1);
|
|
if (!handled.insert(key).second) {
|
|
std::ostringstream e;
|
|
/* clang-format off */
|
|
e <<
|
|
"Generator\n"
|
|
" " << this->GetName() << "\n"
|
|
"given platform specification\n"
|
|
" " << p << "\n"
|
|
"that contains duplicate field key '" << key << "'."
|
|
;
|
|
/* clang-format on */
|
|
mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
|
|
return false;
|
|
}
|
|
if (!this->ProcessGeneratorPlatformField(key, value)) {
|
|
std::ostringstream e;
|
|
/* clang-format off */
|
|
e <<
|
|
"Generator\n"
|
|
" " << this->GetName() << "\n"
|
|
"given platform specification\n"
|
|
" " << p << "\n"
|
|
"that contains invalid field '" << *fi << "'."
|
|
;
|
|
/* clang-format on */
|
|
mf->IssueMessage(MessageType::FATAL_ERROR, e.str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmGlobalVisualStudio8Generator::ProcessGeneratorPlatformField(
|
|
std::string const& key, std::string const& value)
|
|
{
|
|
static_cast<void>(key);
|
|
static_cast<void>(value);
|
|
return false;
|
|
}
|
|
|
|
cm::optional<std::string> const&
|
|
cmGlobalVisualStudio8Generator::GetTargetFrameworkVersion() const
|
|
{
|
|
return this->DefaultTargetFrameworkVersion;
|
|
}
|
|
|
|
cm::optional<std::string> const&
|
|
cmGlobalVisualStudio8Generator::GetTargetFrameworkIdentifier() const
|
|
{
|
|
return this->DefaultTargetFrameworkIdentifier;
|
|
}
|
|
|
|
cm::optional<std::string> const&
|
|
cmGlobalVisualStudio8Generator::GetTargetFrameworkTargetsVersion() const
|
|
{
|
|
return this->DefaultTargetFrameworkTargetsVersion;
|
|
}
|
|
|
|
std::string cmGlobalVisualStudio8Generator::GetGenerateStampList()
|
|
{
|
|
return "generate.stamp.list";
|
|
}
|
|
|
|
void cmGlobalVisualStudio8Generator::Configure()
|
|
{
|
|
this->cmGlobalVisualStudio7Generator::Configure();
|
|
}
|
|
|
|
bool cmGlobalVisualStudio8Generator::UseFolderProperty() const
|
|
{
|
|
// NOLINTNEXTLINE(bugprone-parent-virtual-call)
|
|
return IsExpressEdition() ? false : cmGlobalGenerator::UseFolderProperty();
|
|
}
|
|
|
|
bool cmGlobalVisualStudio8Generator::AddCheckTarget()
|
|
{
|
|
// Add a special target on which all other targets depend that
|
|
// checks the build system and optionally re-runs CMake.
|
|
// Skip the target if no regeneration is to be done.
|
|
if (this->GlobalSettingIsOn("CMAKE_SUPPRESS_REGENERATION")) {
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::unique_ptr<cmLocalGenerator>> const& generators =
|
|
this->LocalGenerators;
|
|
auto& lg =
|
|
cm::static_reference_cast<cmLocalVisualStudio7Generator>(generators[0]);
|
|
|
|
auto cc = cm::make_unique<cmCustomCommand>();
|
|
cmTarget* tgt = lg.AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, false,
|
|
std::move(cc));
|
|
|
|
// Collect the input files used to generate all targets in this
|
|
// project.
|
|
std::vector<std::string> listFiles;
|
|
for (const auto& gen : generators) {
|
|
cm::append(listFiles, gen->GetMakefile()->GetListFiles());
|
|
}
|
|
// Sort the list of input files and remove duplicates.
|
|
std::sort(listFiles.begin(), listFiles.end(), std::less<std::string>());
|
|
auto new_end = std::unique(listFiles.begin(), listFiles.end());
|
|
listFiles.erase(new_end, listFiles.end());
|
|
|
|
// Add all cmake input files which are used by the project
|
|
// so Visual Studio does not close them when reloading it.
|
|
for (const std::string& listFile : listFiles) {
|
|
if (listFile.find("/CMakeFiles/") != std::string::npos) {
|
|
continue;
|
|
}
|
|
if (!cmSystemTools::IsSubDirectory(listFile,
|
|
lg.GetMakefile()->GetHomeDirectory()) &&
|
|
!cmSystemTools::IsSubDirectory(
|
|
listFile, lg.GetMakefile()->GetHomeOutputDirectory())) {
|
|
continue;
|
|
}
|
|
|
|
tgt->AddSource(listFile);
|
|
}
|
|
|
|
auto ptr = cm::make_unique<cmGeneratorTarget>(tgt, &lg);
|
|
auto* gt = ptr.get();
|
|
lg.AddGeneratorTarget(std::move(ptr));
|
|
|
|
// Organize in the "predefined targets" folder:
|
|
//
|
|
if (this->UseFolderProperty()) {
|
|
tgt->SetProperty("FOLDER", this->GetPredefinedTargetsFolder());
|
|
}
|
|
|
|
// Create a list of all stamp files for this project.
|
|
std::vector<std::string> stamps;
|
|
std::string stampList = cmStrCat(
|
|
"CMakeFiles/", cmGlobalVisualStudio8Generator::GetGenerateStampList());
|
|
{
|
|
std::string stampListFile =
|
|
cmStrCat(generators[0]->GetMakefile()->GetCurrentBinaryDirectory(), '/',
|
|
stampList);
|
|
std::string stampFile;
|
|
cmGeneratedFileStream fout(stampListFile);
|
|
for (const auto& gi : generators) {
|
|
stampFile = cmStrCat(gi->GetMakefile()->GetCurrentBinaryDirectory(),
|
|
"/CMakeFiles/generate.stamp");
|
|
fout << stampFile << "\n";
|
|
stamps.push_back(stampFile);
|
|
}
|
|
}
|
|
|
|
// Add a custom rule to re-run CMake if any input files changed.
|
|
{
|
|
// The custom rule runs cmake so set UTF-8 pipes.
|
|
bool stdPipesUTF8 = true;
|
|
|
|
// Add a custom prebuild target to run the VerifyGlobs script.
|
|
cmake* cm = this->GetCMakeInstance();
|
|
if (cm->DoWriteGlobVerifyTarget()) {
|
|
cmCustomCommandLines verifyCommandLines = cmMakeSingleCommandLine(
|
|
{ cmSystemTools::GetCMakeCommand(), "-P", cm->GetGlobVerifyScript() });
|
|
std::vector<std::string> byproducts;
|
|
byproducts.push_back(cm->GetGlobVerifyStamp());
|
|
|
|
cc = cm::make_unique<cmCustomCommand>();
|
|
cc->SetByproducts(byproducts);
|
|
cc->SetCommandLines(verifyCommandLines);
|
|
cc->SetComment("Checking File Globs");
|
|
cc->SetStdPipesUTF8(stdPipesUTF8);
|
|
lg.AddCustomCommandToTarget(CMAKE_CHECK_BUILD_SYSTEM_TARGET,
|
|
cmCustomCommandType::PRE_BUILD,
|
|
std::move(cc));
|
|
|
|
// Ensure ZERO_CHECK always runs in Visual Studio using MSBuild,
|
|
// otherwise the prebuild command will not be run.
|
|
tgt->SetProperty("VS_GLOBAL_DisableFastUpToDateCheck", "true");
|
|
listFiles.push_back(cm->GetGlobVerifyStamp());
|
|
}
|
|
|
|
// Create a rule to re-run CMake.
|
|
std::string argS = cmStrCat("-S", lg.GetSourceDirectory());
|
|
std::string argB = cmStrCat("-B", lg.GetBinaryDirectory());
|
|
std::string const sln =
|
|
lg.GetBinaryDirectory() + "/" + lg.GetProjectName() + ".sln";
|
|
cmCustomCommandLines commandLines = cmMakeSingleCommandLine(
|
|
{ cmSystemTools::GetCMakeCommand(), argS, argB, "--check-stamp-list",
|
|
stampList, "--vs-solution-file", sln });
|
|
if (cm->GetIgnoreWarningAsError()) {
|
|
commandLines[0].emplace_back("--compile-no-warning-as-error");
|
|
}
|
|
|
|
// 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)
|
|
cc = cm::make_unique<cmCustomCommand>();
|
|
cc->SetOutputs(stamps);
|
|
cc->SetDepends(listFiles);
|
|
cc->SetCommandLines(commandLines);
|
|
cc->SetComment("Checking Build System");
|
|
cc->SetEscapeOldStyle(false);
|
|
cc->SetStdPipesUTF8(stdPipesUTF8);
|
|
if (cmSourceFile* file =
|
|
lg.AddCustomCommandToOutput(std::move(cc), true)) {
|
|
gt->AddSource(file->ResolveFullPath());
|
|
} else {
|
|
cmSystemTools::Error("Error adding rule for " + stamps[0]);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void cmGlobalVisualStudio8Generator::AddExtraIDETargets()
|
|
{
|
|
cmGlobalVisualStudio7Generator::AddExtraIDETargets();
|
|
if (this->AddCheckTarget()) {
|
|
for (auto& LocalGenerator : this->LocalGenerators) {
|
|
const auto& tgts = LocalGenerator->GetGeneratorTargets();
|
|
// All targets depend on the build-system check target.
|
|
for (const auto& ti : tgts) {
|
|
if (ti->GetName() != CMAKE_CHECK_BUILD_SYSTEM_TARGET) {
|
|
ti->Target->AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmGlobalVisualStudio8Generator::WriteSolutionConfigurations(
|
|
std::ostream& fout, std::vector<std::string> const& configs)
|
|
{
|
|
fout << "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\n";
|
|
for (std::string const& i : configs) {
|
|
fout << "\t\t" << i << "|" << this->GetPlatformName() << " = " << i << "|"
|
|
<< this->GetPlatformName() << "\n";
|
|
}
|
|
fout << "\tEndGlobalSection\n";
|
|
}
|
|
|
|
void cmGlobalVisualStudio8Generator::WriteProjectConfigurations(
|
|
std::ostream& fout, const std::string& name, cmGeneratorTarget const& target,
|
|
std::vector<std::string> const& configs,
|
|
const std::set<std::string>& configsPartOfDefaultBuild,
|
|
std::string const& platformMapping)
|
|
{
|
|
std::string guid = this->GetGUID(name);
|
|
for (std::string const& i : configs) {
|
|
cmList mapConfig;
|
|
const char* dstConfig = i.c_str();
|
|
if (target.GetProperty("EXTERNAL_MSPROJECT")) {
|
|
if (cmValue m = target.GetProperty("MAP_IMPORTED_CONFIG_" +
|
|
cmSystemTools::UpperCase(i))) {
|
|
mapConfig.assign(*m);
|
|
if (!mapConfig.empty()) {
|
|
dstConfig = mapConfig[0].c_str();
|
|
}
|
|
}
|
|
}
|
|
fout << "\t\t{" << guid << "}." << i << "|" << this->GetPlatformName()
|
|
<< ".ActiveCfg = " << dstConfig << "|"
|
|
<< (!platformMapping.empty() ? platformMapping
|
|
: this->GetPlatformName())
|
|
<< "\n";
|
|
auto ci = configsPartOfDefaultBuild.find(i);
|
|
if (!(ci == configsPartOfDefaultBuild.end())) {
|
|
fout << "\t\t{" << guid << "}." << i << "|" << this->GetPlatformName()
|
|
<< ".Build.0 = " << dstConfig << "|"
|
|
<< (!platformMapping.empty() ? platformMapping
|
|
: this->GetPlatformName())
|
|
<< "\n";
|
|
}
|
|
if (this->NeedsDeploy(target, dstConfig)) {
|
|
fout << "\t\t{" << guid << "}." << i << "|" << this->GetPlatformName()
|
|
<< ".Deploy.0 = " << dstConfig << "|"
|
|
<< (!platformMapping.empty() ? platformMapping
|
|
: this->GetPlatformName())
|
|
<< "\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
bool cmGlobalVisualStudio8Generator::NeedsDeploy(
|
|
cmGeneratorTarget const& target, const char* config) const
|
|
{
|
|
cmStateEnums::TargetType const type = target.GetType();
|
|
if (type != cmStateEnums::EXECUTABLE &&
|
|
type != cmStateEnums::SHARED_LIBRARY) {
|
|
// deployment only valid on executables and shared libraries.
|
|
return false;
|
|
}
|
|
|
|
if (cmValue prop = target.GetProperty("VS_SOLUTION_DEPLOY")) {
|
|
// If set, it dictates behavior
|
|
return cmIsOn(
|
|
cmGeneratorExpression::Evaluate(*prop, target.LocalGenerator, config));
|
|
}
|
|
|
|
// To be deprecated, disable deployment even if target supports it.
|
|
if (cmValue prop = target.GetProperty("VS_NO_SOLUTION_DEPLOY")) {
|
|
if (cmIsOn(cmGeneratorExpression::Evaluate(*prop, target.LocalGenerator,
|
|
config))) {
|
|
// If true, always disable deployment
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Legacy behavior, enabled deployment based on 'hard-coded' target
|
|
// platforms.
|
|
return this->TargetSystemSupportsDeployment();
|
|
}
|
|
|
|
bool cmGlobalVisualStudio8Generator::TargetSystemSupportsDeployment() const
|
|
{
|
|
return this->TargetsWindowsCE();
|
|
}
|
|
|
|
bool cmGlobalVisualStudio8Generator::ComputeTargetDepends()
|
|
{
|
|
// Skip over the cmGlobalVisualStudioGenerator implementation!
|
|
// We do not need the support that VS <= 7.1 needs.
|
|
// NOLINTNEXTLINE(bugprone-parent-virtual-call)
|
|
return this->cmGlobalGenerator::ComputeTargetDepends();
|
|
}
|
|
|
|
void cmGlobalVisualStudio8Generator::WriteProjectDepends(
|
|
std::ostream& fout, const std::string&, const std::string&,
|
|
cmGeneratorTarget const* gt)
|
|
{
|
|
TargetDependSet const& unordered = this->GetTargetDirectDepends(gt);
|
|
OrderedTargetDependSet depends(unordered, std::string());
|
|
for (cmTargetDepend const& i : depends) {
|
|
if (!this->IsInSolution(i)) {
|
|
continue;
|
|
}
|
|
std::string guid = this->GetGUID(i->GetName());
|
|
fout << "\t\t{" << guid << "} = {" << guid << "}\n";
|
|
}
|
|
}
|
|
|
|
bool cmGlobalVisualStudio8Generator::NeedLinkLibraryDependencies(
|
|
cmGeneratorTarget* target)
|
|
{
|
|
// Look for utility dependencies that magically link.
|
|
auto const& utilities = target->GetUtilities();
|
|
return std::any_of(
|
|
utilities.begin(), utilities.end(),
|
|
[target](BT<std::pair<std::string, bool>> const& ui) {
|
|
if (cmGeneratorTarget* depTarget =
|
|
target->GetLocalGenerator()->FindGeneratorTargetToUse(
|
|
ui.Value.first)) {
|
|
if (depTarget->IsInBuildSystem() &&
|
|
depTarget->GetProperty("EXTERNAL_MSPROJECT")) {
|
|
// This utility dependency names an external .vcproj target.
|
|
// We use LinkLibraryDependencies="true" to link to it without
|
|
// predicting the .lib file location or name.
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
static cmVS7FlagTable cmVS8ExtraFlagTable[] = {
|
|
{ "CallingConvention", "Gd", "cdecl", "0", 0 },
|
|
{ "CallingConvention", "Gr", "fastcall", "1", 0 },
|
|
{ "CallingConvention", "Gz", "stdcall", "2", 0 },
|
|
|
|
{ "Detect64BitPortabilityProblems", "Wp64",
|
|
"Detect 64Bit Portability Problems", "true", 0 },
|
|
{ "ErrorReporting", "errorReport:prompt", "Report immediately", "1", 0 },
|
|
{ "ErrorReporting", "errorReport:queue", "Queue for next login", "2", 0 },
|
|
// 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 },
|
|
{ "UsePrecompiledHeader", "Y-", "Don't use precompiled header", "0", 0 },
|
|
// 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 },
|
|
|
|
{ "EnablePREfast", "analyze", "", "true", 0 },
|
|
{ "EnablePREfast", "analyze-", "", "false", 0 },
|
|
|
|
// Language options
|
|
{ "TreatWChar_tAsBuiltInType", "Zc:wchar_t", "wchar_t is a built-in type",
|
|
"true", 0 },
|
|
{ "TreatWChar_tAsBuiltInType", "Zc:wchar_t-",
|
|
"wchar_t is not a built-in type", "false", 0 },
|
|
|
|
{ "", "", "", "", 0 }
|
|
};
|
|
cmIDEFlagTable const* cmGlobalVisualStudio8Generator::GetExtraFlagTableVS8()
|
|
{
|
|
return cmVS8ExtraFlagTable;
|
|
}
|