From 7491f52992450bc6853c44c28db646c6176cbfd0 Mon Sep 17 00:00:00 2001 From: Bill Hoffman Date: Thu, 25 Jun 2009 16:41:57 -0400 Subject: [PATCH] ENH: first pass at VS 10, can bootstrap CMake, but many tests still fail --- CompileFlags.cmake | 7 +- Modules/CMakeVS10FindMake.cmake | 31 + Source/CMakeLists.txt | 8 + Source/cmGlobalGenerator.cxx | 7 +- Source/cmGlobalVisualStudio10Generator.cxx | 98 +++ Source/cmGlobalVisualStudio10Generator.h | 70 ++ Source/cmGlobalVisualStudio71Generator.cxx | 7 +- Source/cmListFileLexer.c | 2 +- Source/cmLocalGenerator.h | 2 +- Source/cmLocalVisualStudio10Generator.cxx | 64 ++ Source/cmLocalVisualStudio10Generator.h | 45 + Source/cmLocalVisualStudio7Generator.h | 34 +- Source/cmLocalVisualStudioGenerator.h | 12 +- Source/cmMakefile.cxx | 4 +- Source/cmVS10CLFlagTable.h | 152 ++++ Source/cmVS10LibFlagTable.h | 50 ++ Source/cmVS10LinkFlagTable.h | 150 ++++ Source/cmVisualStudio10TargetGenerator.cxx | 965 +++++++++++++++++++++ Source/cmVisualStudio10TargetGenerator.h | 81 ++ Source/cmVisualStudioGeneratorOptions.cxx | 420 +++++++++ Source/cmVisualStudioGeneratorOptions.h | 122 +++ Source/cmake.cxx | 3 + Source/cmparseMSBuildXML.py | 294 +++++++ Source/kwsys/ProcessWin32.c | 10 +- 24 files changed, 2591 insertions(+), 47 deletions(-) create mode 100644 Modules/CMakeVS10FindMake.cmake create mode 100644 Source/cmGlobalVisualStudio10Generator.cxx create mode 100644 Source/cmGlobalVisualStudio10Generator.h create mode 100644 Source/cmLocalVisualStudio10Generator.cxx create mode 100644 Source/cmLocalVisualStudio10Generator.h create mode 100644 Source/cmVS10CLFlagTable.h create mode 100644 Source/cmVS10LibFlagTable.h create mode 100644 Source/cmVS10LinkFlagTable.h create mode 100644 Source/cmVisualStudio10TargetGenerator.cxx create mode 100644 Source/cmVisualStudio10TargetGenerator.h create mode 100644 Source/cmVisualStudioGeneratorOptions.cxx create mode 100644 Source/cmVisualStudioGeneratorOptions.h create mode 100755 Source/cmparseMSBuildXML.py diff --git a/CompileFlags.cmake b/CompileFlags.cmake index 59f335d87..236dfb267 100644 --- a/CompileFlags.cmake +++ b/CompileFlags.cmake @@ -10,9 +10,12 @@ ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 6") INCLUDE (${CMAKE_ROOT}/Modules/CMakeBackwardCompatibilityCXX.cmake) # Disable deprecation warnings for standard C functions. -IF(MSVC80 OR MSVC90) +# really only needed for newer versions of VS, but should +# not hurt other versions, and this will work into the +# future +IF(MSVC) ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE) -ENDIF(MSVC80 OR MSVC90) +ENDIF(MSVC) #silence duplicate symbol warnings on AIX IF(CMAKE_SYSTEM MATCHES "AIX.*") diff --git a/Modules/CMakeVS10FindMake.cmake b/Modules/CMakeVS10FindMake.cmake new file mode 100644 index 000000000..04d5e8116 --- /dev/null +++ b/Modules/CMakeVS10FindMake.cmake @@ -0,0 +1,31 @@ + +# VCExpress does not support cross compiling, which is necessary for Win CE +SET( _CMAKE_MAKE_PROGRAM_NAMES devenv) +IF(NOT CMAKE_CROSSCOMPILING) + SET( _CMAKE_MAKE_PROGRAM_NAMES ${_CMAKE_MAKE_PROGRAM_NAMES} VCExpress) +ENDIF(NOT CMAKE_CROSSCOMPILING) + +FIND_PROGRAM(CMAKE_MAKE_PROGRAM + NAMES ${_CMAKE_MAKE_PROGRAM_NAMES} + HINTS + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0\\Setup\\VS;EnvironmentDirectory] + [HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0\\Setup;Dbghelp_path] + "$ENV{ProgramFiles}/Microsoft Visual Studio 10.0/Common7/IDE" + "$ENV{ProgramFiles}/Microsoft Visual Studio10.0/Common7/IDE" + "$ENV{ProgramFiles}/Microsoft Visual Studio 10/Common7/IDE" + "$ENV{ProgramFiles}/Microsoft Visual Studio10/Common7/IDE" + "$ENV{ProgramFiles} (x86)/Microsoft Visual Studio 10.0/Common7/IDE" + "$ENV{ProgramFiles} (x86)/Microsoft Visual Studio10.0/Common7/IDE" + "$ENV{ProgramFiles} (x86)/Microsoft Visual Studio 10/Common7/IDE" + "$ENV{ProgramFiles} (x86)/Microsoft Visual Studio10/Common7/IDE" + "/Program Files/Microsoft Visual Studio 10.0/Common7/IDE/" + "/Program Files/Microsoft Visual Studio 10/Common7/IDE/" + PATHS + "$ENV{ProgramFiles} (x86)/Microsoft Visual Studio .NET/Common7/IDE" + "$ENV{ProgramFiles}/Microsoft Visual Studio .NET/Common7/IDE" + + ) +MARK_AS_ADVANCED(CMAKE_MAKE_PROGRAM) +SET(MSVC10 1) +SET(MSVC_VERSION 1600) + diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index ab5b64cad..33c0dc4ef 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -282,6 +282,14 @@ IF (WIN32) cmGlobalVisualStudio8Win64Generator.h cmGlobalVisualStudio9Win64Generator.cxx cmGlobalVisualStudio9Win64Generator.h + cmVisualStudioGeneratorOptions.h + cmVisualStudioGeneratorOptions.cxx + cmVisualStudio10TargetGenerator.h + cmVisualStudio10TargetGenerator.cxx + cmLocalVisualStudio10Generator.cxx + cmLocalVisualStudio10Generator.h + cmGlobalVisualStudio10Generator.h + cmGlobalVisualStudio10Generator.cxx cmGlobalVisualStudioGenerator.cxx cmGlobalVisualStudioGenerator.h cmGlobalWatcomWMakeGenerator.cxx diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 8a184e06a..a8455db7c 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -2068,9 +2068,14 @@ void cmGlobalGenerator::CheckRuleHashes() #else std::ifstream fin(pfile.c_str(), std::ios::in); #endif + bool goodStream = true; + if(!fin) + { + goodStream = false; + } std::string line; std::string fname; - while(cmSystemTools::GetLineFromStream(fin, line)) + while(goodStream && cmSystemTools::GetLineFromStream(fin, line)) { // Line format is a 32-byte hex string followed by a space // followed by a file name (with no escaping). diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx new file mode 100644 index 000000000..a0af05cd1 --- /dev/null +++ b/Source/cmGlobalVisualStudio10Generator.cxx @@ -0,0 +1,98 @@ +/*========================================================================= + + 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 "cmGlobalVisualStudio10Generator.h" +#include "cmLocalVisualStudio10Generator.h" +#include "cmMakefile.h" +#include "cmake.h" + + +cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator() +{ + this->FindMakeProgramFile = "CMakeVS10FindMake.cmake"; +} + +//---------------------------------------------------------------------------- +void cmGlobalVisualStudio10Generator::AddPlatformDefinitions(cmMakefile* mf) +{ + mf->AddDefinition("MSVC10", "1"); +} + +//---------------------------------------------------------------------------- +void cmGlobalVisualStudio10Generator::WriteSLNHeader(std::ostream& fout) +{ + fout << "Microsoft Visual Studio Solution File, Format Version 11.00\n"; + fout << "# Visual Studio 10\n"; +} + +///! Create a local generator appropriate to this Global Generator +cmLocalGenerator *cmGlobalVisualStudio10Generator::CreateLocalGenerator() +{ + cmLocalGenerator*lg = new cmLocalVisualStudio10Generator; + lg->SetGlobalGenerator(this); + return lg; +} + +//---------------------------------------------------------------------------- +void cmGlobalVisualStudio10Generator +::GetDocumentation(cmDocumentationEntry& entry) const +{ + entry.Name = this->GetName(); + entry.Brief = "Generates Visual Studio 10 project files."; + entry.Full = ""; +} + +//---------------------------------------------------------------------------- +void cmGlobalVisualStudio10Generator +::EnableLanguage(std::vectorconst & lang, + cmMakefile *mf, bool optional) +{ + cmGlobalVisualStudio8Generator::EnableLanguage(lang, mf, optional); +} + +//---------------------------------------------------------------------------- +std::string cmGlobalVisualStudio10Generator::GetUserMacrosDirectory() +{ + std::string base; + std::string path; + + // base begins with the VisualStudioProjectsLocation reg value... + if (cmSystemTools::ReadRegistryValue( + "HKEY_CURRENT_USER\\Software\\Microsoft\\VisualStudio\\10.0;" + "VisualStudioProjectsLocation", + base)) + { + cmSystemTools::ConvertToUnixSlashes(base); + + // 9.0 macros folder: + path = base + "/VSMacros80"; + // *NOT* a typo; right now in Visual Studio 2008 beta the macros + // folder is VSMacros80... They may change it to 90 before final + // release of 2008 or they may not... we'll have to keep our eyes + // on it + } + + // path is (correctly) still empty if we did not read the base value from + // the Registry value + return path; +} + +//---------------------------------------------------------------------------- +std::string cmGlobalVisualStudio10Generator::GetUserMacrosRegKeyBase() +{ + return "Software\\Microsoft\\VisualStudio\\10.0\\vsmacros"; +} diff --git a/Source/cmGlobalVisualStudio10Generator.h b/Source/cmGlobalVisualStudio10Generator.h new file mode 100644 index 000000000..d1da8fafd --- /dev/null +++ b/Source/cmGlobalVisualStudio10Generator.h @@ -0,0 +1,70 @@ +/*========================================================================= + + Program: CMake - Cross-Platform Makefile Generator + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. + See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#ifndef cmGlobalVisualStudio10Generator_h +#define cmGlobalVisualStudio10Generator_h + +#include "cmGlobalVisualStudio8Generator.h" + + +/** \class cmGlobalVisualStudio10Generator + * \brief Write a Unix makefiles. + * + * cmGlobalVisualStudio10Generator manages UNIX build process for a tree + */ +class cmGlobalVisualStudio10Generator : + public cmGlobalVisualStudio8Generator +{ +public: + cmGlobalVisualStudio10Generator(); + static cmGlobalGenerator* New() { + return new cmGlobalVisualStudio10Generator; } + + ///! Get the name for the generator. + virtual const char* GetName() const { + return cmGlobalVisualStudio10Generator::GetActualName();} + static const char* GetActualName() {return "Visual Studio 10";} + virtual void AddPlatformDefinitions(cmMakefile* mf); + + /** Get the documentation entry for this generator. */ + virtual void GetDocumentation(cmDocumentationEntry& entry) const; + + ///! create the correct local generator + virtual cmLocalGenerator *CreateLocalGenerator(); + + /** + * Try to determine system infomation such as shared library + * extension, pthreads, byte order etc. + */ + virtual void EnableLanguage(std::vectorconst& languages, + cmMakefile *, bool optional); + virtual void WriteSLNHeader(std::ostream& fout); + + /** + * Where does this version of Visual Studio look for macros for the + * current user? Returns the empty string if this version of Visual + * Studio does not implement support for VB macros. + */ + virtual std::string GetUserMacrosDirectory(); + + /** + * What is the reg key path to "vsmacros" for this version of Visual + * Studio? + */ + virtual std::string GetUserMacrosRegKeyBase(); + virtual const char* GetCMakeCFGInitDirectory() { return "$(ConfigurationName)";} +}; +#endif diff --git a/Source/cmGlobalVisualStudio71Generator.cxx b/Source/cmGlobalVisualStudio71Generator.cxx index 6974b07cb..157176d24 100644 --- a/Source/cmGlobalVisualStudio71Generator.cxx +++ b/Source/cmGlobalVisualStudio71Generator.cxx @@ -164,7 +164,12 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout, ext = ".vfproj"; project = "Project(\"{6989167D-11E4-40FE-8C1A-2192A86A7E90}\") = \""; } - + const char* targetExt = t.GetProperty("GENERATOR_FILE_NAME_EXT"); + if(targetExt) + { + ext = targetExt; + } + fout << project << dspname << "\", \"" << this->ConvertToSolutionPath(dir) diff --git a/Source/cmListFileLexer.c b/Source/cmListFileLexer.c index 01e099e31..57c450913 100644 --- a/Source/cmListFileLexer.c +++ b/Source/cmListFileLexer.c @@ -2127,7 +2127,7 @@ static void cmListFileLexerAppend(cmListFileLexer* lexer, const char* text, } /* We need to extend the buffer. */ - temp = malloc(newSize); + temp = (char*)malloc(newSize); if(lexer->token.text) { memcpy(temp, lexer->token.text, lexer->token.length); diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index e75ddae83..6ef2c435a 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -299,11 +299,11 @@ public: void GenerateFrameworkInfoPList(cmTarget* target, const char* targetName, const char* fname); -protected: /** Construct a comment for a custom command. */ std::string ConstructComment(const cmCustomCommand& cc, const char* default_comment = ""); +protected: /** Fill out these strings for the given target. Libraries to link, * flags, and linkflags. */ void GetTargetFlags(std::string& linkLibs, diff --git a/Source/cmLocalVisualStudio10Generator.cxx b/Source/cmLocalVisualStudio10Generator.cxx new file mode 100644 index 000000000..cdcf7e10b --- /dev/null +++ b/Source/cmLocalVisualStudio10Generator.cxx @@ -0,0 +1,64 @@ +/*========================================================================= + + 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 "cmLocalVisualStudio10Generator.h" +#include "cmTarget.h" +#include "cmMakefile.h" +#include "cmVisualStudio10TargetGenerator.h" +#include "cmGlobalVisualStudio7Generator.h" + +//---------------------------------------------------------------------------- +cmLocalVisualStudio10Generator::cmLocalVisualStudio10Generator() +{ + +} + +cmLocalVisualStudio10Generator::~cmLocalVisualStudio10Generator() +{ +} + +void cmLocalVisualStudio10Generator::Generate() +{ + + cmTargets &tgts = this->Makefile->GetTargets(); + // Create the regeneration custom rule. + if(!this->Makefile->IsOn("CMAKE_SUPPRESS_REGENERATION")) + { + // Create a rule to regenerate the build system when the target + // specification source changes. + if(cmSourceFile* sf = this->CreateVCProjBuildRule()) + { + // Add the rule to targets that need it. + for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + { + if(l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET) + { + l->second.AddSourceFile(sf); + } + } + } + } + + for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); ++l) + { + cmVisualStudio10TargetGenerator tg(&l->second, + (cmGlobalVisualStudio7Generator*) + this->GetGlobalGenerator()); + tg.Generate(); + } + this->WriteStampFiles(); +} + diff --git a/Source/cmLocalVisualStudio10Generator.h b/Source/cmLocalVisualStudio10Generator.h new file mode 100644 index 000000000..ac2e6ec3a --- /dev/null +++ b/Source/cmLocalVisualStudio10Generator.h @@ -0,0 +1,45 @@ +/*========================================================================= + + Program: CMake - Cross-Platform Makefile Generator + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. + See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#ifndef cmLocalVisualStudio10Generator_h +#define cmLocalVisualStudio10Generator_h + +#include "cmLocalVisualStudio7Generator.h" + + +/** \class cmLocalVisualStudio10Generator + * \brief Write Visual Studio 10 project files. + * + * cmLocalVisualStudio10Generator produces a Visual Studio 10 project + * file for each target in its directory. + */ +class cmLocalVisualStudio10Generator : public cmLocalVisualStudio7Generator +{ +public: + ///! Set cache only and recurse to false by default. + cmLocalVisualStudio10Generator(); + + virtual ~cmLocalVisualStudio10Generator(); + + + /** + * Generate the makefile for this directory. + */ + virtual void Generate(); + +private: +}; +#endif diff --git a/Source/cmLocalVisualStudio7Generator.h b/Source/cmLocalVisualStudio7Generator.h index 8796130a2..70f25e866 100644 --- a/Source/cmLocalVisualStudio7Generator.h +++ b/Source/cmLocalVisualStudio7Generator.h @@ -18,12 +18,13 @@ #define cmLocalVisualStudio7Generator_h #include "cmLocalVisualStudioGenerator.h" +#include "cmVisualStudioGeneratorOptions.h" // to get cmVS7FlagTable class cmTarget; class cmSourceFile; class cmCustomCommand; class cmSourceGroup; -struct cmVS7FlagTable; + class cmLocalVisualStudio7GeneratorOptions; class cmLocalVisualStudio7GeneratorFCInfo; @@ -68,6 +69,10 @@ public: void SetExtraFlagTable(cmVS7FlagTable const* table) { this->ExtraFlagTable = table; } + virtual std::string GetTargetDirectory(cmTarget const&) const; + cmSourceFile* CreateVCProjBuildRule(); + void WriteStampFiles(); + private: typedef cmLocalVisualStudio7GeneratorOptions Options; typedef cmLocalVisualStudio7GeneratorFCInfo FCInfo; @@ -77,14 +82,12 @@ private: const char* configName); void FixGlobalTargets(); void WriteProjectFiles(); - void WriteStampFiles(); void WriteVCProjHeader(std::ostream& fout, const char *libName, cmTarget &tgt, std::vector &sgs); void WriteVCProjFooter(std::ostream& fout); void CreateSingleVCProj(const char *lname, cmTarget &tgt); void WriteVCProjFile(std::ostream& fout, const char *libName, cmTarget &tgt); - cmSourceFile* CreateVCProjBuildRule(); void WriteConfigurations(std::ostream& fout, const char *libName, cmTarget &tgt); void WriteConfiguration(std::ostream& fout, @@ -118,7 +121,6 @@ private: void WriteGroup(const cmSourceGroup *sg, cmTarget& target, std::ostream &fout, const char *libName, std::vector *configs); - virtual std::string GetTargetDirectory(cmTarget const&) const; friend class cmLocalVisualStudio7GeneratorFCInfo; friend class cmLocalVisualStudio7GeneratorInternals; @@ -134,30 +136,6 @@ private: cmLocalVisualStudio7GeneratorInternals* Internal; }; -// This is a table mapping XML tag IDE names to command line options -struct cmVS7FlagTable -{ - const char* IDEName; // name used in the IDE xml file - const char* commandFlag; // command line flag - const char* comment; // comment - const char* value; // string value - unsigned int special; // flags for special handling requests - enum - { - UserValue = (1<<0), // flag contains a user-specified value - UserIgnored = (1<<1), // ignore any user value - UserRequired = (1<<2), // match only when user value is non-empty - Continue = (1<<3), // continue looking for matching entries - SemicolonAppendable = (1<<4), // a flag that if specified multiple times - // should have its value appended to the - // old value with semicolons (e.g. - // /NODEFAULTLIB: => - // IgnoreDefaultLibraryNames) - - UserValueIgnored = UserValue | UserIgnored, - UserValueRequired = UserValue | UserRequired - }; -}; #endif diff --git a/Source/cmLocalVisualStudioGenerator.h b/Source/cmLocalVisualStudioGenerator.h index bddf898b6..0bb630b2b 100644 --- a/Source/cmLocalVisualStudioGenerator.h +++ b/Source/cmLocalVisualStudioGenerator.h @@ -35,12 +35,6 @@ class cmLocalVisualStudioGenerator : public cmLocalGenerator public: cmLocalVisualStudioGenerator(); virtual ~cmLocalVisualStudioGenerator(); -protected: - - /** Construct a custom command to make exe import lib dir. */ - cmsys::auto_ptr - MaybeCreateImplibDir(cmTarget& target, const char* config); - /** Construct a script from the given list of command lines. */ std::string ConstructScript(const cmCustomCommandLines& commandLines, const char* workingDirectory, @@ -49,6 +43,12 @@ protected: bool escapeAllowMakeVars, const char* newline = "\n"); +protected: + + /** Construct a custom command to make exe import lib dir. */ + cmsys::auto_ptr + MaybeCreateImplibDir(cmTarget& target, const char* config); + // Safe object file name generation. void ComputeObjectNameRequirements(std::vector const&); bool SourceFileCompiles(const cmSourceFile* sf); diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index bee1adc86..f2486c5a4 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -897,7 +897,6 @@ cmMakefile::AddCustomCommandToOutput(const std::vector& outputs, // Construct a rule file associated with the first output produced. std::string outName = outputs[0]; outName += ".rule"; - // Check if the rule file already exists. file = this->GetSource(outName.c_str()); if(file && file->GetCustomCommand() && !replace) @@ -2715,7 +2714,8 @@ void cmMakefile::EnableLanguage(std::vector const & lang, bool optional) { this->AddDefinition("CMAKE_CFG_INTDIR", - this->LocalGenerator->GetGlobalGenerator()->GetCMakeCFGInitDirectory()); + this->LocalGenerator->GetGlobalGenerator() + ->GetCMakeCFGInitDirectory()); this->LocalGenerator->GetGlobalGenerator()->EnableLanguage(lang, this, optional); } diff --git a/Source/cmVS10CLFlagTable.h b/Source/cmVS10CLFlagTable.h new file mode 100644 index 000000000..08f7bd2ba --- /dev/null +++ b/Source/cmVS10CLFlagTable.h @@ -0,0 +1,152 @@ +static cmVS7FlagTable cmVS10CLFlagTable[] = +{ + + //Enum Properties + {"DebugInformationFormat", "Z7", "C7 compatible", "OldStyle", 0}, + {"DebugInformationFormat", "Zi", "Program Database", "ProgramDatabase", 0}, + {"DebugInformationFormat", "ZI", "Program Database for Edit And Continue", "EditAndContinue", 0}, + + {"WarningLevel", "W0", "Turn Off All Warnings", "TurnOffAllWarnings", 0}, + {"WarningLevel", "W1", "Level1", "Level1", 0}, + {"WarningLevel", "W2", "Level2", "Level2", 0}, + {"WarningLevel", "W3", "Level3", "Level3", 0}, + {"WarningLevel", "W4", "Level4", "Level4", 0}, + {"WarningLevel", "Wall", "EnableAllWarnings", "EnableAllWarnings", 0}, + + {"Optimization", "Od", "Disabled", "Disabled", 0}, + {"Optimization", "O1", "Minimize Size", "MinSpace", 0}, + {"Optimization", "O2", "Maximize Speed", "MaxSpeed", 0}, + {"Optimization", "Ox", "Full Optimization", "Full", 0}, + + {"InlineFunctionExpansion", "", "Default", "Default", 0}, + {"InlineFunctionExpansion", "Ob0", "Disabled", "Disabled", 0}, + {"InlineFunctionExpansion", "Ob1", "Only __inline", "OnlyExplicitInline", 0}, + {"InlineFunctionExpansion", "Ob2", "Any Suitable", "AnySuitable", 0}, + + {"FavorSizeOrSpeed", "Os", "Favor small code", "Size", 0}, + {"FavorSizeOrSpeed", "Ot", "Favor fast code", "Speed", 0}, + {"FavorSizeOrSpeed", "", "Neither", "Neither", 0}, + + {"ExceptionHandling", "EHa", "Yes with SEH Exceptions", "Async", 0}, + {"ExceptionHandling", "EHsc", "Yes", "Sync", 0}, + {"ExceptionHandling", "EHs", "Yes with Extern C functions", "SyncCThrow", 0}, + {"ExceptionHandling", "", "No", "false", 0}, + + {"BasicRuntimeChecks", "RTCs", "Stack Frames", "StackFrameRuntimeCheck", 0}, + {"BasicRuntimeChecks", "RTCu", "Uninitialized variables", "UninitializedLocalUsageCheck", 0}, + {"BasicRuntimeChecks", "RTC1", "Both (/RTC1, equiv. to /RTCsu)", "EnableFastChecks", 0}, + {"BasicRuntimeChecks", "", "Default", "Default", 0}, + + {"RuntimeLibrary", "MT", "Multi-threaded", "MultiThreaded", 0}, + {"RuntimeLibrary", "MTd", "Multi-threaded Debug", "MultiThreadedDebug", 0}, + {"RuntimeLibrary", "MD", "Multi-threaded DLL", "MultiThreadedDLL", 0}, + {"RuntimeLibrary", "MDd", "Multi-threaded Debug DLL", "MultiThreadedDebugDLL", 0}, + + {"StructMemberAlignment", "Zp1", "1 Byte", "1Byte", 0}, + {"StructMemberAlignment", "Zp2", "2 Bytes", "2Bytes", 0}, + {"StructMemberAlignment", "Zp4", "4 Byte", "4Bytes", 0}, + {"StructMemberAlignment", "Zp8", "8 Bytes", "8Bytes", 0}, + {"StructMemberAlignment", "Zp16", "16 Bytes", "16Bytes", 0}, + {"StructMemberAlignment", "", "Default", "Default", 0}, + + {"EnableEnhancedInstructionSet", "arch:SSE", "Streaming SIMD Extensions (/arch:SSE)", "StreamingSIMDExtensions", 0}, + {"EnableEnhancedInstructionSet", "arch:SSE2", "Streaming SIMD Extensions 2 (/arch:SSE2)", "StreamingSIMDExtensions2", 0}, + {"EnableEnhancedInstructionSet", "", "Not Set", "NotSet", 0}, + + {"FloatingPointModel", "fp:precise", "Precise", "Precise", 0}, + {"FloatingPointModel", "fp:strict", "Strict", "Strict", 0}, + {"FloatingPointModel", "fp:fast", "Fast", "Fast", 0}, + + {"PrecompiledHeader", "Yc", "Create", "Create", 0}, + {"PrecompiledHeader", "Yu", "Use", "Use", 0}, + {"PrecompiledHeader", "", "Not Using Precompiled Headers", "NotUsing", 0}, + + {"AssemblerOutput", "", "No Listing", "NoListing", 0}, + {"AssemblerOutput", "FA", "Assembly-Only Listing", "AssemblyCode", 0}, + {"AssemblerOutput", "FAc", "Assembly With Machine Code", "AssemblyAndMachineCode", 0}, + {"AssemblerOutput", "FAs", "Assembly With Source Code", "AssemblyAndSourceCode", 0}, + {"AssemblerOutput", "FAcs", "Assembly, Machine Code and Source", "All", 0}, + + {"CallingConvention", "Gd", "__cdecl", "Cdecl", 0}, + {"CallingConvention", "Gr", "__fastcall", "FastCall", 0}, + {"CallingConvention", "Gz", "__stdcall", "StdCall", 0}, + + {"CompileAs", "", "Default", "Default", 0}, + {"CompileAs", "TC", "Compile as C Code", "CompileAsC", 0}, + {"CompileAs", "TP", "Compile as C++ Code", "CompileAsCpp", 0}, + + {"ErrorReporting", "errorReport:none", "Do Not Send Report", "None", 0}, + {"ErrorReporting", "errorReport:prompt", "Prompt Immediatelly", "Prompt", 0}, + {"ErrorReporting", "errorReport:queue", "Queue For Next Login", "Queue", 0}, + {"ErrorReporting", "errorReport:send", "Send Automatically", "Send", 0}, + + {"CompileAsManaged", "", "No Common Language RunTime Support", "false", 0}, + {"CompileAsManaged", "clr", "Common Language RunTime Support", "true", 0}, + {"CompileAsManaged", "clr:pure", "Pure MSIL Common Language RunTime Support", "Pure", 0}, + {"CompileAsManaged", "clr:safe", "Safe MSIL Common Language RunTime Support", "Safe", 0}, + {"CompileAsManaged", "clr:oldSyntax", "Common Language RunTime Support, Old Syntax", "OldSyntax", 0}, + + + //Bool Properties + {"SuppressStartupBanner", "nologo-", "", "false", 0}, + {"SuppressStartupBanner", "nologo", "", "true", 0}, + {"TreatWarningAsError", "WX-", "", "false", 0}, + {"TreatWarningAsError", "WX", "", "true", 0}, + {"IntrinsicFunctions", "Oi", "", "true", 0}, + {"OmitFramePointers", "Oy-", "", "false", 0}, + {"OmitFramePointers", "Oy", "", "true", 0}, + {"EnableFiberSafeOptimizations", "GT", "", "true", 0}, + {"WholeProgramOptimization", "GL", "", "true", 0}, + {"UndefineAllPreprocessorDefinitions", "u", "", "true", 0}, + {"IgnoreStandardIncludePath", "X", "", "true", 0}, + {"PreprocessToFile", "P", "", "true", 0}, + {"PreprocessSuppressLineNumbers", "EP", "", "true", 0}, + {"PreprocessKeepComments", "C", "", "true", 0}, + {"StringPooling", "GF-", "", "false", 0}, + {"StringPooling", "GF", "", "true", 0}, + {"MinimalRebuild", "Gm-", "", "false", 0}, + {"MinimalRebuild", "Gm", "", "true", 0}, + {"SmallerTypeCheck", "RTCc", "", "true", 0}, + {"BufferSecurityCheck", "GS-", "", "false", 0}, + {"BufferSecurityCheck", "GS", "", "true", 0}, + {"FunctionLevelLinking", "Gy-", "", "false", 0}, + {"FunctionLevelLinking", "Gy", "", "true", 0}, + {"FloatingPointExceptions", "fp:except-", "", "false", 0}, + {"FloatingPointExceptions", "fp:except", "", "true", 0}, + {"CodeGeneration", "hotpatch", "", "true", 0}, + {"DisableLanguageExtensions", "Za", "", "true", 0}, + {"TreatWChar_tAsBuiltInType", "Zc:wchar_t-", "", "false", 0}, + {"TreatWChar_tAsBuiltInType", "Zc:wchar_t", "", "true", 0}, + {"ForceConformanceInForLoopScope", "Zc:forScope-", "", "false", 0}, + {"ForceConformanceInForLoopScope", "Zc:forScope", "", "true", 0}, + {"RuntimeTypeInfo", "GR-", "", "false", 0}, + {"RuntimeTypeInfo", "GR", "", "true", 0}, + {"OpenMPSupport", "openmp-", "", "false", 0}, + {"OpenMPSupport", "openmp", "", "true", 0}, + {"ExpandAttributedSource", "Fx", "", "true", 0}, + {"ShowIncludes", "showIncludes", "", "true", 0}, + {"EnablePREfast", "analyze-", "", "false", 0}, + {"EnablePREfast", "analyze", "", "true", 0}, + {"UseFullPaths", "FC", "", "true", 0}, + {"OmitDefaultLibName", "Zl", "", "true", 0}, + {"UseUnicodeForAssemblerListing", "FAu", "", "true", 0}, + + //Bool Properties With Argument + {"MultiProcessorCompilation", "MP", "", "true", cmVS7FlagTable::Continue}, + {"ProcessorNumber", "MP", "Multi-processor Compilation", "", cmVS7FlagTable::UserValueRequired}, + {"GenerateXMLDocumentationFiles", "doc", "", "true", cmVS7FlagTable::Continue}, + {"XMLDocumentationFileName", "doc", "Generate XML Documentation Files", "", cmVS7FlagTable::UserValueRequired}, + {"BrowseInformation", "FR", "", "true", cmVS7FlagTable::Continue}, + {"BrowseInformationFile", "FR", "Enable Browse Information", "", cmVS7FlagTable::UserValueRequired}, + + //String List Properties + {"AdditionalIncludeDirectories", "I", "Additional Include Directories", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"AdditionalUsingDirectories", "AI", "Resolve #using References", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"PreprocessorDefinitions", "D ", "Preprocessor Definitions", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"UndefinePreprocessorDefinitions", "U", "Undefine Preprocessor Definitions", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"DisableSpecificWarnings", "wd", "Disable Specific Warnings", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"ForcedIncludeFiles", "FI", "Forced Include File", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"ForcedUsingFiles", "FU", "Forced #using File", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"TreatSpecificWarningsAsErrors", "we", "Treat Specific Warnings As Errors", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {0,0,0,0,0} +}; diff --git a/Source/cmVS10LibFlagTable.h b/Source/cmVS10LibFlagTable.h new file mode 100644 index 000000000..eb40082cf --- /dev/null +++ b/Source/cmVS10LibFlagTable.h @@ -0,0 +1,50 @@ +static cmVS7FlagTable cmVS10LibFlagTable[] = +{ + + //Enum Properties + {"ErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately", "PromptImmediately", 0}, + {"ErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login", "QueueForNextLogin", 0}, + {"ErrorReporting", "ERRORREPORT:SEND", "Send Error Report", "SendErrorReport", 0}, + {"ErrorReporting", "ERRORREPORT:NONE", "No Error Report", "NoErrorReport", 0}, + + {"TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0}, + {"TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0}, + {"TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0}, + {"TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0}, + {"TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0}, + {"TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU", 0}, + {"TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16", "MachineMIPSFPU16", 0}, + {"TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0}, + {"TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0}, + {"TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0}, + {"TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0}, + + {"SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0}, + {"SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0}, + {"SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0}, + {"SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application", "EFI Application", 0}, + {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER", "EFI Boot Service Driver", "EFI Boot Service Driver", 0}, + {"SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0}, + {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime", 0}, + {"SubSystem", "SUBSYSTEM:WINDOWSCE", "WindowsCE", "WindowsCE", 0}, + {"SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0}, + + + //Bool Properties + {"SuppressStartupBanner", "NOLOGO", "", "true", 0}, + {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0}, + {"TreatLibWarningAsErrors", "WX:NO", "", "false", 0}, + {"TreatLibWarningAsErrors", "WX", "", "true", 0}, + {"Verbose", "VERBOSE", "", "true", 0}, + {"LinkTimeCodeGeneration", "LTCG", "", "true", 0}, + + //Bool Properties With Argument + + //String List Properties + {"AdditionalDependencies", "", "Additional Dependencies", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"AdditionalLibraryDirectories", "LIBPATH:", "Additional Library Directories", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:", "Ignore Specific Default Libraries", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"ExportNamedFunctions", "EXPORT:", "Export Named Functions", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"RemoveObjects", "REMOVE:", "Remove Objects", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {0,0,0,0,0} +}; diff --git a/Source/cmVS10LinkFlagTable.h b/Source/cmVS10LinkFlagTable.h new file mode 100644 index 000000000..80b7f70a9 --- /dev/null +++ b/Source/cmVS10LinkFlagTable.h @@ -0,0 +1,150 @@ +static cmVS7FlagTable cmVS10LinkFlagTable[] = +{ + + //Enum Properties + {"ShowProgress", "", "Not Set", "NotSet", 0}, + {"ShowProgress", "VERBOSE", "Display all progress messages", "LinkVerbose", 0}, + {"ShowProgress", "VERBOSE:Lib", "For Libraries Searched", "LinkVerboseLib", 0}, + {"ShowProgress", "VERBOSE:ICF", "About COMDAT folding during optimized linking", "LinkVerboseICF", 0}, + {"ShowProgress", "VERBOSE:REF", "About data removed during optimized linking", "LinkVerboseREF", 0}, + {"ShowProgress", "VERBOSE:SAFESEH", "About Modules incompatible with SEH", "LinkVerboseSAFESEH", 0}, + {"ShowProgress", "VERBOSE:CLR", "About linker activity related to managed code", "LinkVerboseCLR", 0}, + + {"ForceFileOutput", "FORCE", "Enabled", "Enabled", 0}, + {"ForceFileOutput", "FORCE:MULTIPLE", "Multiply Defined Symbol Only", "MultiplyDefinedSymbolOnly", 0}, + {"ForceFileOutput", "FORCE:UNRESOLVED", "Undefined Symbol Only", "UndefinedSymbolOnly", 0}, + + {"CreateHotPatchableImage", "FUNCTIONPADMIN", "Enabled", "Enabled", 0}, + {"CreateHotPatchableImage", "FUNCTIONPADMIN:5", "X86 Image Only", "X86Image", 0}, + {"CreateHotPatchableImage", "FUNCTIONPADMIN:6", "X64 Image Only", "X64Image", 0}, + {"CreateHotPatchableImage", "FUNCTIONPADMIN:16", "Itanium Image Only", "ItaniumImage", 0}, + + {"UACExecutionLevel", "level='asInvoker'", "asInvoker", "AsInvoker", 0}, + {"UACExecutionLevel", "level='highestAvailable'", "highestAvailable", "HighestAvailable", 0}, + {"UACExecutionLevel", "level='requireAdministrator'", "requireAdministrator", "RequireAdministrator", 0}, + + {"SubSystem", "", "Not Set", "NotSet", 0}, + {"SubSystem", "SUBSYSTEM:CONSOLE", "Console", "Console", 0}, + {"SubSystem", "SUBSYSTEM:WINDOWS", "Windows", "Windows", 0}, + {"SubSystem", "SUBSYSTEM:NATIVE", "Native", "Native", 0}, + {"SubSystem", "SUBSYSTEM:EFI_APPLICATION", "EFI Application", "EFI Application", 0}, + {"SubSystem", "SUBSYSTEM:EFI_BOOT_SERVICE_DRIVER", "EFI Boot Service Driver", "EFI Boot Service Driver", 0}, + {"SubSystem", "SUBSYSTEM:EFI_ROM", "EFI ROM", "EFI ROM", 0}, + {"SubSystem", "SUBSYSTEM:EFI_RUNTIME_DRIVER", "EFI Runtime", "EFI Runtime", 0}, + {"SubSystem", "SUBSYSTEM:WINDOWSCE", "WindowsCE", "WindowsCE", 0}, + {"SubSystem", "SUBSYSTEM:POSIX", "POSIX", "POSIX", 0}, + + {"Driver", "", "Not Set", "NotSet", 0}, + {"Driver", "Driver", "Driver", "Driver", 0}, + {"Driver", "DRIVER:UPONLY", "UP Only", "UpOnly", 0}, + {"Driver", "DRIVER:WDM", "WDM", "WDM", 0}, + + {"LinkTimeCodeGeneration", "", "Default", "Default", 0}, + {"LinkTimeCodeGeneration", "LTCG", "Use Link Time Code Generation", "UseLinkTimeCodeGeneration", 0}, + {"LinkTimeCodeGeneration", "LTCG:PGInstrument", "Profile Guided Optimization - Instrument", "PGInstrument", 0}, + {"LinkTimeCodeGeneration", "LTCG:PGOptimize", "Profile Guided Optimization - Optimization", "PGOptimization", 0}, + {"LinkTimeCodeGeneration", "LTCG:PGUpdate", "Profile Guided Optimization - Update", "PGUpdate", 0}, + + {"TargetMachine", "", "Not Set", "NotSet", 0}, + {"TargetMachine", "MACHINE:ARM", "MachineARM", "MachineARM", 0}, + {"TargetMachine", "MACHINE:EBC", "MachineEBC", "MachineEBC", 0}, + {"TargetMachine", "MACHINE:IA64", "MachineIA64", "MachineIA64", 0}, + {"TargetMachine", "MACHINE:MIPS", "MachineMIPS", "MachineMIPS", 0}, + {"TargetMachine", "MACHINE:MIPS16", "MachineMIPS16", "MachineMIPS16", 0}, + {"TargetMachine", "MACHINE:MIPSFPU", "MachineMIPSFPU", "MachineMIPSFPU", 0}, + {"TargetMachine", "MACHINE:MIPSFPU16", "MachineMIPSFPU16", "MachineMIPSFPU16", 0}, + {"TargetMachine", "MACHINE:SH4", "MachineSH4", "MachineSH4", 0}, + {"TargetMachine", "MACHINE:THUMB", "MachineTHUMB", "MachineTHUMB", 0}, + {"TargetMachine", "MACHINE:X64", "MachineX64", "MachineX64", 0}, + {"TargetMachine", "MACHINE:X86", "MachineX86", "MachineX86", 0}, + + {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:MTA", "MTA threading attribute", "MTAThreadingAttribute", 0}, + {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:STA", "STA threading attribute", "STAThreadingAttribute", 0}, + {"CLRThreadAttribute", "CLRTHREADATTRIBUTE:NONE", "Default threading attribute", "DefaultThreadingAttribute", 0}, + + {"CLRImageType", "CLRIMAGETYPE:IJW", "Force IJW image", "ForceIJWImage", 0}, + {"CLRImageType", "CLRIMAGETYPE:PURE", "Force Pure IL Image", "ForcePureILImage", 0}, + {"CLRImageType", "CLRIMAGETYPE:SAFE", "Force Safe IL Image", "ForceSafeILImage", 0}, + {"CLRImageType", "", "Default image type", "Default", 0}, + + {"LinkErrorReporting", "ERRORREPORT:PROMPT", "PromptImmediately", "PromptImmediately", 0}, + {"LinkErrorReporting", "ERRORREPORT:QUEUE", "Queue For Next Login", "QueueForNextLogin", 0}, + {"LinkErrorReporting", "ERRORREPORT:SEND", "Send Error Report", "SendErrorReport", 0}, + {"LinkErrorReporting", "ERRORREPORT:NONE", "No Error Report", "NoErrorReport", 0}, + + {"CLRSupportLastError", "CLRSupportLastError", "Enabled", "Enabled", 0}, + {"CLRSupportLastError", "CLRSupportLastError:NO", "Disabled", "Disabled", 0}, + {"CLRSupportLastError", "CLRSupportLastError:SYSTEMDLL", "System Dlls Only", "SystemDlls", 0}, + + + //Bool Properties + {"LinkIncremental", "INCREMENTAL:NO", "", "false", 0}, + {"LinkIncremental", "INCREMENTAL", "", "true", 0}, + {"SuppressStartupBanner", "NOLOGO", "", "true", 0}, + {"LinkStatus", "LTCG:NOSTATUS", "", "false", 0}, + {"LinkStatus", "LTCG:STATUS", "", "true", 0}, + {"PreventDllBinding", "ALLOWBIND:NO", "", "false", 0}, + {"PreventDllBinding", "ALLOWBIND", "", "true", 0}, + {"TreatLinkerWarningAsErrors", "WX:NO", "", "false", 0}, + {"TreatLinkerWarningAsErrors", "WX", "", "true", 0}, + {"IgnoreAllDefaultLibraries", "NODEFAULTLIB", "", "true", 0}, + {"GenerateManifest", "MANIFEST:NO", "", "false", 0}, + {"GenerateManifest", "MANIFEST", "", "true", 0}, + {"AllowIsolation", "ALLOWISOLATION:NO", "", "false", 0}, + {"UACUIAccess", "uiAccess='false'", "", "false", 0}, + {"UACUIAccess", "uiAccess='true'", "", "true", 0}, + {"GenerateDebugInformation", "DEBUG", "", "true", 0}, + {"MapExports", "MAPINFO:EXPORTS", "", "true", 0}, + {"AssemblyDebug", "ASSEMBLYDEBUG:DISABLE", "", "false", 0}, + {"AssemblyDebug", "ASSEMBLYDEBUG", "", "true", 0}, + {"LargeAddressAware", "LARGEADDRESSAWARE:NO", "", "false", 0}, + {"LargeAddressAware", "LARGEADDRESSAWARE", "", "true", 0}, + {"TerminalServerAware", "TSAWARE:NO", "", "false", 0}, + {"TerminalServerAware", "TSAWARE", "", "true", 0}, + {"SwapRunFromCD", "SWAPRUN:CD", "", "true", 0}, + {"SwapRunFromNET", "SWAPRUN:NET", "", "true", 0}, + {"OptimizeReferences", "OPT:NOREF", "", "false", 0}, + {"OptimizeReferences", "OPT:REF", "", "true", 0}, + {"EnableCOMDATFolding", "OPT:NOICF", "", "false", 0}, + {"EnableCOMDATFolding", "OPT:ICF", "", "true", 0}, + {"IgnoreEmbeddedIDL", "IGNOREIDL", "", "true", 0}, + {"NoEntryPoint", "NOENTRY", "", "true", 0}, + {"SetChecksum", "RELEASE", "", "true", 0}, + {"RandomizedBaseAddress", "DYNAMICBASE:NO", "", "false", 0}, + {"RandomizedBaseAddress", "DYNAMICBASE", "", "true", 0}, + {"FixedBaseAddress", "FIXED:NO", "", "false", 0}, + {"FixedBaseAddress", "FIXED", "", "true", 0}, + {"DataExecutionPrevention", "NXCOMPAT:NO", "", "false", 0}, + {"DataExecutionPrevention", "NXCOMPAT", "", "true", 0}, + {"TurnOffAssemblyGeneration", "NOASSEMBLY", "", "true", 0}, + {"SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0}, + {"SupportNobindOfDelayLoadedDLL", "DELAY:NOBIND", "", "true", 0}, + {"Profile", "PROFILE", "", "true", 0}, + {"DelaySign", "DELAYSIGN:NO", "", "false", 0}, + {"DelaySign", "DELAYSIGN", "", "true", 0}, + {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0}, + {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0}, + {"ImageHasSafeExceptionHandlers", "SAFESEH:NO", "", "false", 0}, + {"ImageHasSafeExceptionHandlers", "SAFESEH", "", "true", 0}, + {"LinkDLL", "DLL", "", "true", 0}, + + //Bool Properties With Argument + {"EnableUAC", "MANIFESTUAC:NO", "", "false", cmVS7FlagTable::Continue}, + {"EnableUAC", "MANIFESTUAC:NO", "Enable User Account Control (UAC)", "", cmVS7FlagTable::UserValueRequired}, + {"EnableUAC", "MANIFESTUAC:", "", "true", cmVS7FlagTable::Continue}, + {"UACUIAccess", "MANIFESTUAC:", "Enable User Account Control (UAC)", "", cmVS7FlagTable::UserValueRequired}, + {"GenerateMapFile", "MAP", "", "true", cmVS7FlagTable::Continue}, + {"MapFileName", "MAP", "Generate Map File", "", cmVS7FlagTable::UserValueRequired}, + + //String List Properties + {"AdditionalLibraryDirectories", "LIBPATH:", "Additional Library Directories", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, +// {"AdditionalDependencies", "", "Additional Dependencies", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"IgnoreSpecificDefaultLibraries", "NODEFAULTLIB:", "Ignore Specific Default Libraries", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"AddModuleNamesToAssembly", "ASSEMBLYMODULE:", "Add Module to Assembly", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"EmbedManagedResourceFile", "ASSEMBLYRESOURCE:", "Embed Managed Resource File", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"ForceSymbolReferences", "INCLUDE:", "Force Symbol References", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"DelayLoadDLLs", "DELAYLOAD:", "Delay Loaded Dlls", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"AssemblyLinkResource", "ASSEMBLYLINKRESOURCE:", "Assembly Link Resource", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {"AdditionalManifestDependencies", "MANIFESTDEPENDENCY:", "Additional Manifest Dependencies", "", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable}, + {0,0,0,0,0} +}; diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx new file mode 100644 index 000000000..d08c676ee --- /dev/null +++ b/Source/cmVisualStudio10TargetGenerator.cxx @@ -0,0 +1,965 @@ +/*========================================================================= + + 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 "cmVisualStudio10TargetGenerator.h" +#include "cmGlobalVisualStudio7Generator.h" +#include "cmTarget.h" +#include "cmComputeLinkInformation.h" +#include "cmGeneratedFileStream.h" +#include "cmMakefile.h" +#include "cmSourceFile.h" +#include "cmVisualStudioGeneratorOptions.h" +#include "cmLocalVisualStudio7Generator.h" + +#include "cmVS10CLFlagTable.h" +#include "cmVS10LinkFlagTable.h" + + + +cmVisualStudio10TargetGenerator:: +cmVisualStudio10TargetGenerator(cmTarget* target, + cmGlobalVisualStudio7Generator* gg) +{ + this->GlobalGenerator = gg; + this->GlobalGenerator->CreateGUID(target->GetName()); + this->GUID = this->GlobalGenerator->GetGUID(target->GetName()); + this->Target = target; + this->Makefile = target->GetMakefile(); + this->LocalGenerator = + (cmLocalVisualStudio7Generator*) + this->Makefile->GetLocalGenerator(); + this->Platform = "|Win32"; +} + +cmVisualStudio10TargetGenerator::~cmVisualStudio10TargetGenerator() +{ + delete this->BuildFileStream; +} + +void cmVisualStudio10TargetGenerator::WritePlatformConfigTag( + const char* tag, + const char* config, + int indentLevel, + const char* attribute, + const char* end, + std::ostream* stream) + +{ + if(!stream) + { + stream = this->BuildFileStream; + } + stream->fill(' '); + stream->width(indentLevel*2 ); + (*stream ) << ""; + (*stream ) << "<" << tag + << " Condition=\"'$(Configuration)|$(Platform)'=='"; + (*stream ) << config << this->Platform << "'\""; + if(attribute) + { + (*stream ) << attribute; + } + // close the tag + (*stream ) << ">"; + if(end) + { + (*stream ) << end; + } +} + +void cmVisualStudio10TargetGenerator::WriteString(const char* line, + int indentLevel) +{ + this->BuildFileStream->fill(' '); + this->BuildFileStream->width(indentLevel*2 ); + // write an empty string to get the fill level indent to print + (*this->BuildFileStream ) << ""; + (*this->BuildFileStream ) << line; +} + +void cmVisualStudio10TargetGenerator::Generate() +{ + // Tell the global generator the name of the project file + this->Target->SetProperty("GENERATOR_FILE_NAME",this->Target->GetName()); + this->Target->SetProperty("GENERATOR_FILE_NAME_EXT", + ".vcxproj"); + cmMakefile* mf = this->Target->GetMakefile(); + std::string path = mf->GetStartOutputDirectory(); + path += "/"; + path += this->Target->GetName(); + path += ".vcxproj"; + this->BuildFileStream = + new cmGeneratedFileStream(path.c_str()); + this->BuildFileStream->SetCopyIfDifferent(true); + + // Write the encoding header into the file + char magic[] = {0xEF,0xBB, 0xBF}; + this->BuildFileStream->write(magic, 3); + this->WriteString("\n", + 0); + this->WriteProjectConfigurations(); + this->WriteString("\n", 1); + this->WriteString("", 2); + (*this->BuildFileStream) << "{" << this->GUID << "}\n"; + + this->WriteString("\n", 2); + this->WriteString("\n", 2); + this->WriteString("Win32Proj\n", 2); + this->WriteString("\n", 1); + this->WriteString("\n", + 1); + this->WriteProjectConfigurationValues(); + this->WriteString( + "\n", 1); + this->WriteString("\n", 1); + this->WriteString("\n", 1); + this->WriteString("\n", 1); + this->WriteString("\n", 2); + this->WriteString("\n", 1); + this->WriteString("\n", 1); + this->WritePathAndIncrementalLinkOptions(); + this->WriteItemDefinitionGroups(); + this->WriteCustomCommands(); + this->WriteSources(); + this->WriteProjectReferences(); + this->WriteString( + "\n", 1); + this->WriteString("\n", 1); + this->WriteString("\n", 1); + this->WriteString("", 0); + // The groups are stored in a separate file for VS 10 + this->WriteGroups(); +} + +// ConfigurationType Application, Utility StaticLibrary DynamicLibrary + +void cmVisualStudio10TargetGenerator::WriteProjectConfigurations() +{ + this->WriteString("\n", 1); + std::vector *configs = + static_cast + (this->GlobalGenerator)->GetConfigurations(); + for(std::vector::iterator i = configs->begin(); + i != configs->end(); ++i) + { + this->WriteString("BuildFileStream ) << *i << this->Platform << "\">\n"; + this->WriteString("", 3); + (*this->BuildFileStream ) << *i << "\n"; + this->WriteString("Win32\n", 3); + this->WriteString("\n", 2); + } + this->WriteString("\n", 1); +} + +void cmVisualStudio10TargetGenerator::WriteProjectConfigurationValues() +{ + std::vector *configs = + static_cast + (this->GlobalGenerator)->GetConfigurations(); + for(std::vector::iterator i = configs->begin(); + i != configs->end(); ++i) + { + this->WritePlatformConfigTag("PropertyGroup", + i->c_str(), + 1, " Label=\"Configuration\"", "\n"); + std::string configType = ""; + switch(this->Target->GetType()) + { + case cmTarget::SHARED_LIBRARY: + case cmTarget::MODULE_LIBRARY: + configType += "DynamicLibrary"; + break; + case cmTarget::STATIC_LIBRARY: + configType += "StaticLibrary"; + break; + case cmTarget::EXECUTABLE: + configType += "Application"; + break; + case cmTarget::UTILITY: + configType += "Utility"; + break; + } + configType += "\n"; + this->WriteString(configType.c_str(), 2); + const char* mfcFlag = + this->Target->GetMakefile()->GetDefinition("CMAKE_MFC_FLAG"); + if(mfcFlag) + { + this->WriteString("true\n", 2); + } + else + { + this->WriteString("false\n", 2); + } + this->WriteString("MultiByte\n", 2); + this->WriteString("\n", 1); + } +} + +void cmVisualStudio10TargetGenerator::WriteCustomCommands() +{ + this->WriteString("\n", 1); + std::vectorconst & sources = this->Target->GetSourceFiles(); + for(std::vector::const_iterator source = sources.begin(); + source != sources.end(); ++source) + { + if(cmCustomCommand const* command = (*source)->GetCustomCommand()) + { + this->WriteCustomRule(*source, *command); + } + } + this->WriteString("\n", 1); +} + +void +cmVisualStudio10TargetGenerator::WriteCustomRule(cmSourceFile* source, + cmCustomCommand const & + command) +{ + std::string sourcePath = source->GetFullPath(); + // the rule file seems to need to exist for vs10 + if (source->GetExtension() == "rule") + { + if(!cmSystemTools::FileExists(sourcePath.c_str())) + { + std::ofstream fout(sourcePath.c_str()); + if(fout) + { + fout << "# generated from CMake\n"; + fout.flush(); + fout.close(); + } + } + } + cmLocalVisualStudio7Generator* lg = this->LocalGenerator; + std::string comment = lg->ConstructComment(command); + std::vector *configs = + static_cast + (this->GlobalGenerator)->GetConfigurations(); + this->WriteString("BuildFileStream ) << + cmSystemTools::RelativePath(this->Makefile->GetCurrentOutputDirectory(), + sourcePath.c_str()) << "\">\n"; + for(std::vector::iterator i = configs->begin(); + i != configs->end(); ++i) + { + std::string script = lg->ConstructScript(command.GetCommandLines(), + command.GetWorkingDirectory(), + i->c_str(), + command.GetEscapeOldStyle(), + command.GetEscapeAllowMakeVars()); + this->WritePlatformConfigTag("Message",i->c_str(), 3); + (*this->BuildFileStream ) << comment << "\n"; + this->WritePlatformConfigTag("Command", i->c_str(), 3); + (*this->BuildFileStream ) << script << "\n"; + this->WritePlatformConfigTag("AdditionalInputs", i->c_str(), 3); + + (*this->BuildFileStream ) << source->GetFullPath(); + for(std::vector::const_iterator d = + command.GetDepends().begin(); + d != command.GetDepends().end(); + ++d) + { + std::string dep = this->LocalGenerator-> + GetRealDependency(d->c_str(), i->c_str()); + this->ConvertToWindowsSlash(dep); + (*this->BuildFileStream ) << ";" << dep; + } + (*this->BuildFileStream ) << ";%(AdditionalInputs)\n"; + this->WritePlatformConfigTag("Outputs", i->c_str(), 3); + const char* sep = ""; + for(std::vector::const_iterator o = + command.GetOutputs().begin(); + o != command.GetOutputs().end(); + ++o) + { + std::string out = *o; + this->ConvertToWindowsSlash(out); + (*this->BuildFileStream ) << sep << out; + sep = ";"; + } + (*this->BuildFileStream ) << ";%(Outputs)\n"; + } + this->WriteString("\n", 2); +} + +void cmVisualStudio10TargetGenerator::ConvertToWindowsSlash(std::string& s) +{ + // first convert all of the slashes + std::string::size_type pos = 0; + while((pos = s.find('/', pos)) != std::string::npos) + { + s[pos] = '\\'; + pos++; + } +} +void cmVisualStudio10TargetGenerator::WriteGroups() +{ + // This should create a target.vcxproj.filters file + // something like this: + +/* +  + + + + + + + {05072589-c7be-439a-8fd7-5db6ee5008a9} + + + + + Source Files + + + Source Files + + + +*/ +} + + +void cmVisualStudio10TargetGenerator::WriteSources() +{ + this->WriteString("\n", 1); + if(this->Target->GetType() > cmTarget::MODULE_LIBRARY) + { + this->WriteString("BuildFileStream ) << this->Target->GetDirectory() + << "\\" << this->Target->GetName() + << "\" />\n"; + } + else + { + std::vectorconst & sources = this->Target->GetSourceFiles(); + for(std::vector::const_iterator source = sources.begin(); + source != sources.end(); ++source) + { + // if it is not a custom command then add it as a c file, + // TODO: need to check for idl or rc, or exclude from build + if(!(*source)->GetCustomCommand() + && !(*source)->GetPropertyAsBool("HEADER_FILE_ONLY") + && !this->GlobalGenerator->IgnoreFile + ((*source)->GetExtension().c_str())) + { + const char* lang = (*source)->GetLanguage(); + if(lang && (strcmp(lang, "C") == 0 || strcmp(lang, "CXX") ==0)) + { + std::string sourceFile = (*source)->GetFullPath(); + // output the source file + this->WriteString("BuildFileStream ) << sourceFile << "\""; + // ouput any flags specific to this source file + if(this->OutputSourceSpecificFlags(*source)) + { + // if the source file has specific flags the tag + // is ended on a new line + this->WriteString("\n", 2); + } + else + { + (*this->BuildFileStream ) << " />\n"; + } + } + } + } + } + this->WriteString("\n", 1); +} + +bool cmVisualStudio10TargetGenerator::OutputSourceSpecificFlags( + cmSourceFile* source) +{ + cmSourceFile& sf = *source; + std::string flags; + std::string defines; + if(const char* cflags = sf.GetProperty("COMPILE_FLAGS")) + { + flags += cflags; + } + if(const char* cdefs = sf.GetProperty("COMPILE_DEFINITIONS")) + { + defines += cdefs; + } + const char* lang = + this->GlobalGenerator->GetLanguageFromExtension + (sf.GetExtension().c_str()); + const char* sourceLang = this->LocalGenerator->GetSourceFileLanguage(sf); + const char* linkLanguage = this->Target->GetLinkerLanguage + (this->LocalGenerator->GetGlobalGenerator()); + bool needForceLang = false; + // source file does not match its extension language + if(lang && sourceLang && strcmp(lang, sourceLang) != 0) + { + needForceLang = true; + lang = sourceLang; + } + // if the source file does not match the linker language + // then force c or c++ + if(needForceLang || (linkLanguage && lang + && strcmp(lang, linkLanguage) != 0)) + { + if(strcmp(lang, "CXX") == 0) + { + // force a C++ file type + flags += " /TP "; + } + else if(strcmp(lang, "C") == 0) + { + // force to c + flags += " /TC "; + } + } + // for the first time we need a new line if there is something + // produced here. + const char* firstString = ">\n"; + std::vector *configs = + static_cast + (this->GlobalGenerator)->GetConfigurations(); + bool hasFlags = false; + for( std::vector::iterator config = configs->begin(); + config != configs->end(); ++config) + { + std::string configUpper = cmSystemTools::UpperCase(*config); + std::string configDefines = defines; + std::string defPropName = "COMPILE_DEFINITIONS_"; + defPropName += configUpper; + if(const char* ccdefs = sf.GetProperty(defPropName.c_str())) + { + if(configDefines.size()) + { + configDefines += ","; + } + configDefines += ccdefs; + } + // if we have flags or defines for this config then + // use them + if(flags.size() || configDefines.size()) + { + (*this->BuildFileStream ) << firstString; + firstString = ""; // only do firstString once + hasFlags = true; + cmVisualStudioGeneratorOptions + clOptions(this->LocalGenerator, + 10, cmVisualStudioGeneratorOptions::Compiler, + cmVS10CLFlagTable, 0, this); + clOptions.Parse(flags.c_str()); + clOptions.AddDefines(configDefines.c_str()); + clOptions.SetConfiguration((*config).c_str()); + clOptions.OutputAdditionalOptions(*this->BuildFileStream, " ", ""); + clOptions.OutputFlagMap(*this->BuildFileStream, " "); + clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ", + "\n"); + + } + } + return hasFlags; +} + + +void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions() +{ + this->WriteString("\n", 2); + this->WriteString("<_ProjectFileVersion>10.0.20506.1" + "\n", 3); + std::vector *configs = + static_cast + (this->GlobalGenerator)->GetConfigurations(); + for(std::vector::iterator config = configs->begin(); + config != configs->end(); ++config) + { + std::string targetNameFull = + this->Target->GetFullName(config->c_str()); + std::string intermediateDir = this->LocalGenerator-> + GetTargetDirectory(*this->Target); + intermediateDir += "/"; + intermediateDir += *config; + intermediateDir += "/"; + this->ConvertToWindowsSlash(intermediateDir); + std::string outDir = this->Target->GetDirectory(config->c_str()); + this->ConvertToWindowsSlash(outDir); + this->WritePlatformConfigTag("OutDir", config->c_str(), 3); + *this->BuildFileStream << outDir + << "\\" + << "\n"; + this->WritePlatformConfigTag("IntDir", config->c_str(), 3); + *this->BuildFileStream << intermediateDir + << "\n"; + this->WritePlatformConfigTag("TargetName", config->c_str(), 3); + *this->BuildFileStream << cmSystemTools::GetFilenameWithoutExtension( + targetNameFull.c_str()) + << "\n"; + + this->WritePlatformConfigTag("TargetExt", config->c_str(), 3); + *this->BuildFileStream << cmSystemTools::GetFilenameLastExtension( + targetNameFull.c_str()) + << "\n"; + this->OutputLinkIncremental(*config); + } + this->WriteString("\n", 2); + +} + + + +void +cmVisualStudio10TargetGenerator:: +OutputLinkIncremental(std::string const& configName) +{ + std::string CONFIG = cmSystemTools::UpperCase(configName); + // static libraries and things greater than modules do not need + // to set this option + if(this->Target->GetType() == cmTarget::STATIC_LIBRARY + || this->Target->GetType() > cmTarget::MODULE_LIBRARY) + { + return; + } + const char* linkType = "SHARED"; + if(this->Target->GetType() == cmTarget::EXECUTABLE) + { + linkType = "EXE"; + } + + // assume incremental linking + const char* incremental = "true"; + const char* linkLanguage = + this->Target->GetLinkerLanguage(this->GlobalGenerator); + if(!linkLanguage) + { + cmSystemTools::Error + ("CMake can not determine linker language for target:", + this->Target->GetName()); + return; + } + std::string linkFlagVarBase = "CMAKE_"; + linkFlagVarBase += linkType; + linkFlagVarBase += "_LINKER_FLAGS"; + std::string flags = this-> + Target->GetMakefile()->GetRequiredDefinition(linkFlagVarBase.c_str()); + std::string linkFlagVar = linkFlagVarBase + "_" + CONFIG; + flags += this-> + Target->GetMakefile()->GetRequiredDefinition(linkFlagVar.c_str()); + if(strcmp(linkLanguage, "C") == 0 || strcmp(linkLanguage, "CXX") == 0 + || strcmp(linkLanguage, "Fortran") == 0) + { + std::string baseFlagVar = "CMAKE_"; + baseFlagVar += linkLanguage; + baseFlagVar += "_FLAGS"; + flags += this-> + Target->GetMakefile()->GetRequiredDefinition(baseFlagVar.c_str()); + std::string flagVar = baseFlagVar + std::string("_") + CONFIG; + flags += + Target->GetMakefile()->GetRequiredDefinition(flagVar.c_str()); + } + if(flags.find("INCREMENTAL:NO") != flags.npos) + { + incremental = "false"; + } + this->WritePlatformConfigTag("LinkIncremental", configName.c_str(), 3); + *this->BuildFileStream << incremental + << "\n"; +} + + +void +cmVisualStudio10TargetGenerator:: +WriteClOptions(std::string const& + configName, + std::vector const & includes) +{ + + // much of this was copied from here: + // copied from cmLocalVisualStudio7Generator.cxx 805 + + this->WriteString("\n", 2); + cmVisualStudioGeneratorOptions + clOptions(this->LocalGenerator, + 10, cmVisualStudioGeneratorOptions::Compiler, + cmVS10CLFlagTable); + std::string flags; + // collect up flags for + if(this->Target->GetType() < cmTarget::UTILITY) + { + const char* linkLanguage = + this->Target->GetLinkerLanguage(this->GlobalGenerator); + if(!linkLanguage) + { + cmSystemTools::Error + ("CMake can not determine linker language for target:", + this->Target->GetName()); + return; + } + if(strcmp(linkLanguage, "C") == 0 || strcmp(linkLanguage, "CXX") == 0 + || strcmp(linkLanguage, "Fortran") == 0) + { + std::string baseFlagVar = "CMAKE_"; + baseFlagVar += linkLanguage; + baseFlagVar += "_FLAGS"; + flags = this-> + Target->GetMakefile()->GetRequiredDefinition(baseFlagVar.c_str()); + std::string flagVar = baseFlagVar + std::string("_") + + cmSystemTools::UpperCase(configName); + flags += " "; + flags += this-> + Target->GetMakefile()->GetRequiredDefinition(flagVar.c_str()); + } + // set the correct language + if(strcmp(linkLanguage, "C") == 0) + { + flags += " /TC "; + } + if(strcmp(linkLanguage, "CXX") == 0) + { + flags += " /TP "; + } + } + std::string configUpper = cmSystemTools::UpperCase(configName); + std::string defPropName = "COMPILE_DEFINITIONS_"; + defPropName += configUpper; + + // Get preprocessor definitions for this directory. + std::string defineFlags = this->Target->GetMakefile()->GetDefineFlags(); + clOptions.FixExceptionHandlingDefault(); + clOptions.Parse(flags.c_str()); + clOptions.Parse(defineFlags.c_str()); + clOptions.AddDefines + (this->Makefile->GetProperty("COMPILE_DEFINITIONS")); + clOptions.AddDefines(this->Target->GetProperty("COMPILE_DEFINITIONS")); + clOptions.AddDefines(this->Makefile->GetProperty(defPropName.c_str())); + clOptions.AddDefines(this->Target->GetProperty(defPropName.c_str())); + clOptions.SetVerboseMakefile( + this->Makefile->IsOn("CMAKE_VERBOSE_MAKEFILE")); + + // Add a definition for the configuration name. + std::string configDefine = "CMAKE_INTDIR=\""; + configDefine += configName; + configDefine += "\""; + clOptions.AddDefine(configDefine); + if(const char* exportMacro = this->Target->GetExportMacro()) + { + clOptions.AddDefine(exportMacro); + } + clOptions.OutputAdditionalOptions(*this->BuildFileStream, " ", ""); + this->OutputIncludes(includes); + clOptions.OutputFlagMap(*this->BuildFileStream, " "); + clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ", + "\n"); + this->WriteString("", 3); + *this->BuildFileStream << configName + << "\n"; + this->WriteString("$(IntDir)\n", 3); + this->WriteString("", 3); + *this->BuildFileStream << this->Target->GetDirectory(configName.c_str()) + << "/" + << this->Target->GetPDBName(configName.c_str()) + << "\n"; + this->WriteString("\n", 2); +} + +void cmVisualStudio10TargetGenerator:: +OutputIncludes(std::vector const & includes) +{ + this->WriteString("", 3); + for(std::vector::const_iterator i = includes.begin(); + i != includes.end(); ++i) + { + *this->BuildFileStream << *i << ";"; + } + this->WriteString("%(AdditionalIncludeDirectories)" + "\n", 0); +} + + + +void cmVisualStudio10TargetGenerator:: +WriteRCOptions(std::string const& config, + std::vector const & includes) +{ + this->WriteString("\n", 2); + this->OutputIncludes(includes); + this->WriteString("\n", 2); +} + + +void cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const& + config) +{ + + // static libraries and things greater than modules do not need + // to set this option + if(this->Target->GetType() == cmTarget::STATIC_LIBRARY + || this->Target->GetType() > cmTarget::MODULE_LIBRARY) + { + return; + } + const char* linkLanguage = + this->Target->GetLinkerLanguage(this->GlobalGenerator); + if(!linkLanguage) + { + cmSystemTools::Error + ("CMake can not determine linker language for target:", + this->Target->GetName()); + return; + } + + this->WriteString("\n", 2); + std::string CONFIG = cmSystemTools::UpperCase(config); + + const char* linkType = "SHARED"; + if(this->Target->GetType() == cmTarget::MODULE_LIBRARY) + { + linkType = "MODULE"; + } + if(this->Target->GetType() == cmTarget::EXECUTABLE) + { + linkType = "EXE"; + } + std::string stackVar = "CMAKE_"; + stackVar += linkLanguage; + stackVar += "_STACK_SIZE"; + const char* stackVal = this->Makefile->GetDefinition(stackVar.c_str()); + std::string flags; + if(stackVal) + { + flags += " "; + flags += stackVal; + } + // assume incremental linking + std::string linkFlagVarBase = "CMAKE_"; + linkFlagVarBase += linkType; + linkFlagVarBase += "_LINKER_FLAGS"; + flags += " "; + flags += this-> + Target->GetMakefile()->GetRequiredDefinition(linkFlagVarBase.c_str()); + std::string linkFlagVar = linkFlagVarBase + "_" + CONFIG; + flags += " "; + flags += this-> + Target->GetMakefile()->GetRequiredDefinition(linkFlagVar.c_str()); + const char* targetLinkFlags = this->Target->GetProperty("LINK_FLAGS"); + if(targetLinkFlags) + { + flags += " "; + flags += targetLinkFlags; + } + cmVisualStudioGeneratorOptions + linkOptions(this->LocalGenerator, + 10, cmVisualStudioGeneratorOptions::Compiler, + cmVS10LinkFlagTable); + if ( this->Target->GetPropertyAsBool("WIN32_EXECUTABLE") ) + { + flags += " /SUBSYSTEM:WINDOWS"; + } + else + { + flags += " /SUBSYSTEM:CONSOLE"; + } + cmSystemTools::ReplaceString(flags, "/INCREMENTAL:YES", ""); + cmSystemTools::ReplaceString(flags, "/INCREMENTAL:NO", ""); + std::string standardLibsVar = "CMAKE_"; + standardLibsVar += linkLanguage; + standardLibsVar += "_STANDARD_LIBRARIES"; + std::string + libs = this->Makefile->GetSafeDefinition(standardLibsVar.c_str()); + // Remove trailing spaces from libs + std::string::size_type pos = libs.size()-1; + if(libs.size() != 0) + { + while(libs[pos] == ' ') + { + pos--; + } + } + if(pos != libs.size()-1) + { + libs = libs.substr(0, pos+1); + } + // Replace spaces in libs with ; + cmSystemTools::ReplaceString(libs, " ", ";"); + cmComputeLinkInformation* pcli = + this->Target->GetLinkInformation(config.c_str()); + if(!pcli) + { + cmSystemTools::Error + ("CMake can not compute cmComputeLinkInformation for target:", + this->Target->GetName()); + return; + } + // add the libraries for the target to libs string + cmComputeLinkInformation& cli = *pcli; + this->AddLibraries(cli, libs); + linkOptions.AddFlag("AdditionalDependencies", libs.c_str()); + + std::vector const& ldirs = cli.GetDirectories(); + const char* sep = ""; + std::string linkDirs; + for(std::vector::const_iterator d = ldirs.begin(); + d != ldirs.end(); ++d) + { + linkDirs += sep; + linkDirs += *d; + sep = ";"; + } + linkDirs += "%(AdditionalLibraryDirectories)"; + linkOptions.AddFlag("AdditionalLibraryDirectories", linkDirs.c_str()); + linkOptions.AddFlag("AdditionalDependencies", libs.c_str()); + linkOptions.AddFlag("Version", "0.0"); + if(linkOptions.IsDebug() || flags.find("/debug") != flags.npos) + { + linkOptions.AddFlag("GenerateDebugInformation", "true"); + } + else + { + linkOptions.AddFlag("GenerateDebugInformation", "false"); + } + std::string targetName; + std::string targetNameSO; + std::string targetNameFull; + std::string targetNameImport; + std::string targetNamePDB; + if(this->Target->GetType() == cmTarget::EXECUTABLE) + { + this->Target->GetExecutableNames(targetName, targetNameFull, + targetNameImport, targetNamePDB, + config.c_str()); + } + else + { + this->Target->GetLibraryNames(targetName, targetNameSO, targetNameFull, + targetNameImport, targetNamePDB, + config.c_str()); + } + std::string dir = this->Target->GetDirectory(config.c_str()); + dir += "/"; + std::string imLib = dir; + imLib += targetNameImport; + std::string pdb = dir; + pdb += targetNamePDB; + linkOptions.AddFlag("ImportLibrary", imLib.c_str()); + linkOptions.AddFlag("ProgramDataBaseFileName", pdb.c_str()); + linkOptions.Parse(flags.c_str()); + linkOptions.OutputAdditionalOptions(*this->BuildFileStream, " ", ""); + linkOptions.OutputFlagMap(*this->BuildFileStream, " "); + + this->WriteString("\n", 2); +} + +void cmVisualStudio10TargetGenerator::AddLibraries( + cmComputeLinkInformation& cli, + std::string& libstring) +{ + typedef cmComputeLinkInformation::ItemVector ItemVector; + ItemVector libs = cli.GetItems(); + const char* sep = ";"; + for(ItemVector::const_iterator l = libs.begin(); l != libs.end(); ++l) + { + if(l->IsPath) + { + std::string path = this->LocalGenerator-> + Convert(l->Value.c_str(), + cmLocalGenerator::START_OUTPUT, + cmLocalGenerator::UNCHANGED); + libstring += sep; + libstring += path; + } + else + { + libstring += sep; + libstring += l->Value; + } + } +} + + +void cmVisualStudio10TargetGenerator:: +WriteMidlOptions(std::string const& + config, + std::vector const & includes) +{ + this->WriteString("\n", 2); + this->OutputIncludes(includes); + // Need this stuff, but there is an midl.xml file... + // should we look for .idl language?, and flags? + /* + false + Win32 + true + %(FileName).tlb + $(IntDir)\ + %(FileName).h + + + %(FileName)_i.c + %(FileName)_p.c + */ + this->WriteString("\n", 2); +} + +void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups() +{ + std::vector *configs = + static_cast + (this->GlobalGenerator)->GetConfigurations(); + std::vector includes; + this->LocalGenerator->GetIncludeDirectories(includes); + for(std::vector::iterator i = configs->begin(); + i != configs->end(); ++i) + { + this->WritePlatformConfigTag("ItemDefinitionGroup", i->c_str(), 1); + *this->BuildFileStream << "\n"; + // output cl compile flags + if(this->Target->GetType() <= cmTarget::MODULE_LIBRARY) + { + this->WriteClOptions(*i, includes); + // output rc compile flags + this->WriteRCOptions(*i, includes); + } + // output midl flags + this->WriteMidlOptions(*i, includes); + // output link flags or + this->WriteLinkOptions(*i); + // TODO: need a WriteLibOptions for static + this->WriteString("\n", 1); + } +} + +// TODO handle .obj file direct stuff + +void cmVisualStudio10TargetGenerator::WriteProjectReferences() +{ + // TODO + // This should have dependent targets listed like this: + /* + + + {2f1e4f3c-0a51-46c3-aaf9-e486599604f2} + + + */ +} diff --git a/Source/cmVisualStudio10TargetGenerator.h b/Source/cmVisualStudio10TargetGenerator.h new file mode 100644 index 000000000..618b9936b --- /dev/null +++ b/Source/cmVisualStudio10TargetGenerator.h @@ -0,0 +1,81 @@ +/*========================================================================= + + Program: CMake - Cross-Platform Makefile Generator + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. + See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#ifndef cmVisualStudioTargetGenerator_h +#define cmVisualStudioTargetGenerator_h +#include "cmStandardIncludes.h" + +class cmTarget; +class cmMakefile; +class cmGeneratedFileStream; +class cmGlobalVisualStudio7Generator; +class cmSourceFile; +class cmCustomCommand; +class cmLocalVisualStudio7Generator; +class cmComputeLinkInformation; + +class cmVisualStudio10TargetGenerator +{ +public: + cmVisualStudio10TargetGenerator(cmTarget* target, + cmGlobalVisualStudio7Generator* gg); + ~cmVisualStudio10TargetGenerator(); + void Generate(); + // used by cmVisualStudioGeneratorOptions + void WritePlatformConfigTag( + const char* tag, + const char* config, + int indentLevel, + const char* attribute = 0, + const char* end = 0, + std::ostream* strm = 0 + ); + +private: + void ConvertToWindowsSlash(std::string& s); + void WriteString(const char* line, int indentLevel); + void WriteProjectConfigurations(); + void WriteProjectConfigurationValues(); + void WriteSources(); + void WritePathAndIncrementalLinkOptions(); + void WriteItemDefinitionGroups(); + void WriteClOptions(std::string const& config, + std::vector const & includes); + void WriteRCOptions(std::string const& config, + std::vector const & includes); + void WriteLinkOptions(std::string const& config); + void WriteMidlOptions(std::string const& config, + std::vector const & includes); + void OutputIncludes(std::vector const & includes); + void OutputLinkIncremental(std::string const& configName); + void WriteCustomRule(cmSourceFile* source, + cmCustomCommand const & command); + void WriteCustomCommands(); + void WriteGroups(); + void WriteProjectReferences(); + bool OutputSourceSpecificFlags(cmSourceFile* source); + void AddLibraries(cmComputeLinkInformation& cli, std::string& libstring); +private: + cmTarget* Target; + cmMakefile* Makefile; + std::string Platform; + std::string GUID; + cmGlobalVisualStudio7Generator* GlobalGenerator; + cmGeneratedFileStream* BuildFileStream; + cmLocalVisualStudio7Generator* LocalGenerator; +}; + +#endif diff --git a/Source/cmVisualStudioGeneratorOptions.cxx b/Source/cmVisualStudioGeneratorOptions.cxx new file mode 100644 index 000000000..179dc5b73 --- /dev/null +++ b/Source/cmVisualStudioGeneratorOptions.cxx @@ -0,0 +1,420 @@ +#include "cmVisualStudioGeneratorOptions.h" +#include "cmSystemTools.h" +#include +#include "cmVisualStudio10TargetGenerator.h" + +inline std::string cmVisualStudioGeneratorOptionsEscapeForXML(const char* s) +{ + std::string ret = s; + cmSystemTools::ReplaceString(ret, "&", "&"); + cmSystemTools::ReplaceString(ret, "\"", """); + cmSystemTools::ReplaceString(ret, "<", "<"); + cmSystemTools::ReplaceString(ret, ">", ">"); + cmSystemTools::ReplaceString(ret, "\n", " "); + return ret; +} + +//---------------------------------------------------------------------------- +cmVisualStudioGeneratorOptions +::cmVisualStudioGeneratorOptions(cmLocalGenerator* lg, + int version, + Tool tool, + cmVS7FlagTable const* table, + cmVS7FlagTable const* extraTable, + cmVisualStudio10TargetGenerator* g): + LocalGenerator(lg), Version(version), CurrentTool(tool), + DoingDefine(false), FlagTable(table), ExtraFlagTable(extraTable), + TargetGenerator(g) +{ +} + +//---------------------------------------------------------------------------- +void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault() +{ + // Exception handling is on by default because the platform file has + // "/EHsc" in the flags. Normally, that will override this + // initialization to off, but the user has the option of removing + // the flag to disable exception handling. When the user does + // remove the flag we need to override the IDE default of on. + switch (this->Version) + { + case 7: + case 71: + this->FlagMap["ExceptionHandling"] = "FALSE"; + break; + case 10: + // by default VS puts empty + // for a project, to make our projects look the same put a new line + // and space over for the closing as the default + // value + this->FlagMap["ExceptionHandling"] = "\n "; + break; + default: + this->FlagMap["ExceptionHandling"] = "0"; + break; + } +} + +//---------------------------------------------------------------------------- +void cmVisualStudioGeneratorOptions::SetVerboseMakefile(bool verbose) +{ + // If verbose makefiles have been requested and the /nologo option + // was not given explicitly in the flags we want to add an attribute + // to the generated project to disable logo suppression. Otherwise + // the GUI default is to enable suppression. + if(verbose && + this->FlagMap.find("SuppressStartupBanner") == this->FlagMap.end()) + { + if(this->Version == 10) + { + this->FlagMap["SuppressStartupBanner"] = "false"; + } + else + { + this->FlagMap["SuppressStartupBanner"] = "FALSE"; + } + } +} + +//---------------------------------------------------------------------------- +void cmVisualStudioGeneratorOptions::AddDefine(const std::string& def) +{ + this->Defines.push_back(def); +} + +//---------------------------------------------------------------------------- +void cmVisualStudioGeneratorOptions::AddDefines(const char* defines) +{ + if(defines) + { + // Expand the list of definitions. + cmSystemTools::ExpandListArgument(defines, this->Defines); + } +} + +//---------------------------------------------------------------------------- +void cmVisualStudioGeneratorOptions::AddFlag(const char* flag, + const char* value) +{ + this->FlagMap[flag] = value; +} + + +bool cmVisualStudioGeneratorOptions::IsDebug() +{ + return this->FlagMap.find("DebugInformationFormat") != this->FlagMap.end(); +} + +//---------------------------------------------------------------------------- +bool cmVisualStudioGeneratorOptions::UsingUnicode() +{ + // Look for the a _UNICODE definition. + for(std::vector::const_iterator di = this->Defines.begin(); + di != this->Defines.end(); ++di) + { + if(*di == "_UNICODE") + { + return true; + } + } + return false; +} + +//---------------------------------------------------------------------------- +void cmVisualStudioGeneratorOptions::Parse(const char* flags) +{ + // Parse the input string as a windows command line since the string + // is intended for writing directly into the build files. + std::vector args; + cmSystemTools::ParseWindowsCommandLine(flags, args); + + // Process flags that need to be represented specially in the IDE + // project file. + for(std::vector::iterator ai = args.begin(); + ai != args.end(); ++ai) + { + this->HandleFlag(ai->c_str()); + } +} + +//---------------------------------------------------------------------------- +void cmVisualStudioGeneratorOptions::HandleFlag(const char* flag) +{ + // If the last option was -D then this option is the definition. + if(this->DoingDefine) + { + this->DoingDefine = false; + this->Defines.push_back(flag); + return; + } + + // Look for known arguments. + if(flag[0] == '-' || flag[0] == '/') + { + // Look for preprocessor definitions. + if(this->CurrentTool == Compiler && flag[1] == 'D') + { + if(flag[2] == '\0') + { + // The next argument will have the definition. + this->DoingDefine = true; + } + else + { + // Store this definition. + this->Defines.push_back(flag+2); + } + return; + } + + // Look through the available flag tables. + bool flag_handled = false; + if(this->FlagTable && + this->CheckFlagTable(this->FlagTable, flag, flag_handled)) + { + return; + } + if(this->ExtraFlagTable && + this->CheckFlagTable(this->ExtraFlagTable, flag, flag_handled)) + { + return; + } + + // If any map entry handled the flag we are done. + if(flag_handled) + { + return; + } + } + // This option is not known. Store it in the output flags. + this->FlagString += " "; + this->FlagString += + cmSystemTools::EscapeWindowsShellArgument( + flag, + cmsysSystem_Shell_Flag_AllowMakeVariables | + cmsysSystem_Shell_Flag_VSIDE); +} + +//---------------------------------------------------------------------------- +bool +cmVisualStudioGeneratorOptions +::CheckFlagTable(cmVS7FlagTable const* table, const char* flag, + bool& flag_handled) +{ + // Look for an entry in the flag table matching this flag. + for(cmVS7FlagTable const* entry = table; entry->IDEName; ++entry) + { + bool entry_found = false; + if(entry->special & cmVS7FlagTable::UserValue) + { + // This flag table entry accepts a user-specified value. If + // the entry specifies UserRequired we must match only if a + // non-empty value is given. + int n = static_cast(strlen(entry->commandFlag)); + if(strncmp(flag+1, entry->commandFlag, n) == 0 && + (!(entry->special & cmVS7FlagTable::UserRequired) || + static_cast(strlen(flag+1)) > n)) + { + if(entry->special & cmVS7FlagTable::UserIgnored) + { + // Ignore the user-specified value. + this->FlagMap[entry->IDEName] = entry->value; + } + else if(entry->special & cmVS7FlagTable::SemicolonAppendable) + { + const char *new_value = flag+1+n; + + std::map::iterator itr; + itr = this->FlagMap.find(entry->IDEName); + if(itr != this->FlagMap.end()) + { + // Append to old value (if present) with semicolons; + itr->second += ";"; + itr->second += new_value; + } + else + { + this->FlagMap[entry->IDEName] = new_value; + } + } + else + { + // Use the user-specified value. + this->FlagMap[entry->IDEName] = flag+1+n; + } + entry_found = true; + } + } + else if(strcmp(flag+1, entry->commandFlag) == 0) + { + // This flag table entry provides a fixed value. + this->FlagMap[entry->IDEName] = entry->value; + entry_found = true; + } + + // If the flag has been handled by an entry not requesting a + // search continuation we are done. + if(entry_found && !(entry->special & cmVS7FlagTable::Continue)) + { + return true; + } + + // If the entry was found the flag has been handled. + flag_handled = flag_handled || entry_found; + } + + return false; +} + + +void cmVisualStudioGeneratorOptions::SetConfiguration(const char* config) +{ + this->Configuration = config; +} + +//---------------------------------------------------------------------------- +void +cmVisualStudioGeneratorOptions +::OutputPreprocessorDefinitions(std::ostream& fout, + const char* prefix, + const char* suffix) +{ + if(this->Defines.empty()) + { + return; + } + if(this->Version == 10) + { + // if there are configuration specifc flags, then + // use the configuration specific tag for PreprocessorDefinitions + if(this->Configuration.size()) + { + fout << prefix; + this->TargetGenerator->WritePlatformConfigTag( + "PreprocessorDefinitions", + this->Configuration.c_str(), + 0, + 0, 0, &fout); + } + else + { + fout << prefix << ""; + } + } + else + { + fout << prefix << "PreprocessorDefinitions=\""; + } + const char* comma = ""; + for(std::vector::const_iterator di = this->Defines.begin(); + di != this->Defines.end(); ++di) + { + // Escape the definition for the compiler. + std::string define; + if(this->Version != 10) + { + define = + this->LocalGenerator->EscapeForShell(di->c_str(), true); + } + else + { + define = *di; + } + // Escape this flag for the IDE. + if(this->Version != 10) + { + define = cmVisualStudioGeneratorOptionsEscapeForXML(define.c_str()); + } + // Store the flag in the project file. + fout << comma << define; + if(this->Version == 10) + { + comma = ";"; + } + else + { + comma = ","; + } + } + if(this->Version == 10) + { + fout << ";%(PreprocessorDefinitions)" << suffix; + } + else + { + fout << "\"" << suffix; + } +} + +//---------------------------------------------------------------------------- +void +cmVisualStudioGeneratorOptions +::OutputFlagMap(std::ostream& fout, const char* indent) +{ + if(this->Version == 10) + { + for(std::map::iterator m = this->FlagMap.begin(); + m != this->FlagMap.end(); ++m) + { + fout << indent; + if(this->Configuration.size()) + { + this->TargetGenerator->WritePlatformConfigTag( + m->first.c_str(), + this->Configuration.c_str(), + 0, + 0, 0, &fout); + } + else + { + fout << "<" << m->first << ">"; + } + fout << m->second << "first << ">\n"; + } + } + else + { + for(std::map::iterator m = this->FlagMap.begin(); + m != this->FlagMap.end(); ++m) + { + fout << indent << m->first << "=\"" << m->second << "\"\n"; + } + } +} + +//---------------------------------------------------------------------------- +void +cmVisualStudioGeneratorOptions +::OutputAdditionalOptions(std::ostream& fout, + const char* prefix, + const char* suffix) +{ + if(!this->FlagString.empty()) + { + if(this->Version == 10) + { + fout << prefix; + if(this->Configuration.size()) + { + this->TargetGenerator->WritePlatformConfigTag( + "AdditionalOptions", + this->Configuration.c_str(), + 0, + 0, 0, &fout); + } + else + { + fout << ""; + } + fout << this->FlagString.c_str() + << " %(AdditionalOptions)\n"; + } + else + { + fout << prefix << "AdditionalOptions=\""; + fout << + cmVisualStudioGeneratorOptionsEscapeForXML(this->FlagString.c_str()); + fout << "\"" << suffix; + } + } +} diff --git a/Source/cmVisualStudioGeneratorOptions.h b/Source/cmVisualStudioGeneratorOptions.h new file mode 100644 index 000000000..8577e4793 --- /dev/null +++ b/Source/cmVisualStudioGeneratorOptions.h @@ -0,0 +1,122 @@ +/*========================================================================= + + Program: CMake - Cross-Platform Makefile Generator + Module: $RCSfile$ + Language: C++ + Date: $Date$ + Version: $Revision$ + + Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. + See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notices for more information. + +=========================================================================*/ +#ifndef cmVisualStudioGeneratorOptions_h +#define cmVisualStudioGeneratorOptions_h + +#include "cmLocalGenerator.h" +class cmVisualStudio10TargetGenerator; + +// This is a table mapping XML tag IDE names to command line options +struct cmVS7FlagTable +{ + const char* IDEName; // name used in the IDE xml file + const char* commandFlag; // command line flag + const char* comment; // comment + const char* value; // string value + unsigned int special; // flags for special handling requests + enum + { + UserValue = (1<<0), // flag contains a user-specified value + UserIgnored = (1<<1), // ignore any user value + UserRequired = (1<<2), // match only when user value is non-empty + Continue = (1<<3), // continue looking for matching entries + SemicolonAppendable = (1<<4), // a flag that if specified multiple times + // should have its value appended to the + // old value with semicolons (e.g. + // /NODEFAULTLIB: => + // IgnoreDefaultLibraryNames) + + UserValueIgnored = UserValue | UserIgnored, + UserValueRequired = UserValue | UserRequired + }; +}; + +//---------------------------------------------------------------------------- +class cmVisualStudioGeneratorOptions +{ +public: + // Construct an options table for a given tool. + enum Tool + { + Compiler, + Linker, + FortranCompiler + }; + cmVisualStudioGeneratorOptions(cmLocalGenerator* lg, + int version, + Tool tool, + cmVS7FlagTable const* table, + cmVS7FlagTable const* extraTable = 0, + cmVisualStudio10TargetGenerator* g = 0); + + // Store options from command line flags. + void Parse(const char* flags); + + // Fix the ExceptionHandling option to default to off. + void FixExceptionHandlingDefault(); + + // Store options for verbose builds. + void SetVerboseMakefile(bool verbose); + + // Store definitions and flags. + void AddDefine(const std::string& define); + void AddDefines(const char* defines); + void AddFlag(const char* flag, const char* value); + + // Check for specific options. + bool UsingUnicode(); + + bool IsDebug(); + // Write options to output. + void OutputPreprocessorDefinitions(std::ostream& fout, + const char* prefix, + const char* suffix); + void OutputFlagMap(std::ostream& fout, const char* indent); + void OutputAdditionalOptions(std::ostream& fout, + const char* prefix, + const char* suffix); + void SetConfiguration(const char* config); +private: + cmLocalGenerator* LocalGenerator; + int Version; + + // create a map of xml tags to the values they should have in the output + // for example, "BufferSecurityCheck" = "TRUE" + // first fill this table with the values for the configuration + // Debug, Release, etc, + // Then parse the command line flags specified in CMAKE_CXX_FLAGS + // and CMAKE_C_FLAGS + // and overwrite or add new values to this map + std::map FlagMap; + + // Preprocessor definitions. + std::vector Defines; + + // Unrecognized flags that get no special handling. + cmStdString FlagString; + std::string Configuration; + cmVisualStudio10TargetGenerator* TargetGenerator; + Tool CurrentTool; + bool DoingDefine; + cmVS7FlagTable const* FlagTable; + cmVS7FlagTable const* ExtraFlagTable; + void HandleFlag(const char* flag); + bool CheckFlagTable(cmVS7FlagTable const* table, const char* flag, + bool& flag_handled); +}; + +#endif diff --git a/Source/cmake.cxx b/Source/cmake.cxx index 461354a96..efc8da0d7 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -67,6 +67,7 @@ # include "cmGlobalVisualStudio8Generator.h" # include "cmGlobalVisualStudio9Generator.h" # include "cmGlobalVisualStudio9Win64Generator.h" +# include "cmGlobalVisualStudio10Generator.h" # include "cmGlobalVisualStudio8Win64Generator.h" # include "cmGlobalBorlandMakefileGenerator.h" # include "cmGlobalNMakeMakefileGenerator.h" @@ -2412,6 +2413,8 @@ void cmake::AddDefaultGenerators() &cmGlobalVisualStudio6Generator::New; this->Generators[cmGlobalVisualStudio7Generator::GetActualName()] = &cmGlobalVisualStudio7Generator::New; + this->Generators[cmGlobalVisualStudio10Generator::GetActualName()] = + &cmGlobalVisualStudio10Generator::New; this->Generators[cmGlobalVisualStudio71Generator::GetActualName()] = &cmGlobalVisualStudio71Generator::New; this->Generators[cmGlobalVisualStudio8Generator::GetActualName()] = diff --git a/Source/cmparseMSBuildXML.py b/Source/cmparseMSBuildXML.py new file mode 100755 index 000000000..0d1959cd3 --- /dev/null +++ b/Source/cmparseMSBuildXML.py @@ -0,0 +1,294 @@ +# This python script parses the spec files from MSBuild to create +# mappings from compiler options to IDE XML specifications. For +# more information see here: + +# http://blogs.msdn.com/vcblog/archive/2008/12/16/msbuild-task.aspx +# cl.xml +# +# BoolProperty true|false +# simple example: +# +# +# +# true +# +# +# argument means it might be this: /MP3 +# example with argument: +# +# +# Multi-processor Compilation +# +# +# Multi-processor Compilation +# +# +# +# +# true +# 4 +# +# IntProperty +# not used AFIT +# + + +# per config options example +# true +# +# EnumProperty +# +# +# Optimization +# +# +# Select option for code optimization; choose Custom to use specific optimization options. (/Od, /O1, /O2, /Ox) +# +# +# +# Maximize Speed +# +# +# Equivalent to /Og /Oi /Ot /Oy /Ob2 /Gs /GF /Gy +# +# +# +# +# Minimize Size +# +# +# Equivalent to /Og /Os /Oy /Ob2 /Gs /GF /Gy +# +# +# example for O2 would be this: +# MaxSpeed +# example for O1 would be this: +# MinSpace +# +# StringListProperty +# +# +# Preprocessor Definitions +# +# +# Defines a preprocessing symbols for your source file. +# +# + +# +# +# Additional Include Directories +# +# +# Specifies one or more directories to add to the include path; separate with semi-colons if more than one. (/I[path]) +# +# +# StringProperty + +# Example add bill include: + +# ..\..\..\..\..\..\bill;%(AdditionalIncludeDirectories) + + +import sys +from xml.dom.minidom import parse, parseString + +def getText(node): + nodelist = node.childNodes + rc = "" + for child in nodelist: + if child.nodeType == child.TEXT_NODE: + rc = rc + child.data + return rc + +def print_tree(document, spaces=""): + for i in range(len(document.childNodes)): + if document.childNodes[i].nodeType == document.childNodes[i].ELEMENT_NODE: + print spaces+str(document.childNodes[i].nodeName ) + print_tree(document.childNodes[i],spaces+"----") + pass + +########################################################################################### +#Data structure that stores a property of MSBuild +class Property: + #type = type of MSBuild property (ex. if the property is EnumProperty type should be "Enum") + #attributeNames = a list of any attributes that this property could have (ex. if this was a EnumProperty it should be ["Name","Category"]) + #document = the dom file that's root node is the Property node (ex. if you were parsing a BoolProperty the root node should be something like + def __init__(self,type,attributeNames,document=None): + self.suffix_type = "Property" + self.prefix_type = type + self.attributeNames = attributeNames + self.attributes = {} + self.DisplayName = "" + self.Description = "" + self.argumentProperty = "" + self.argumentIsRequired = "" + self.values = [] + if document is not None: + self.populate(document) + pass + + #document = the dom file that's root node is the Property node (ex. if you were parsing a BoolProperty the root node should be something like + #spaces = do not use + def populate(self,document, spaces = ""): + if document.nodeName == self.prefix_type+self.suffix_type: + for i in self.attributeNames: + self.attributes[i] = document.getAttribute(i) + for i in range(len(document.childNodes)): + child = document.childNodes[i] + if child.nodeType == child.ELEMENT_NODE: + if child.nodeName == self.prefix_type+self.suffix_type+".DisplayName": + self.DisplayName = getText(child.childNodes[1]) + if child.nodeName == self.prefix_type+self.suffix_type+".Description": + self.Description = getText(child.childNodes[1]) + if child.nodeName == "Argument": + self.argumentProperty = child.getAttribute("Property") + self.argumentIsRequired = child.getAttribute("IsRequired") + if child.nodeName == self.prefix_type+"Value": + va = Property(self.prefix_type,["Name","Switch"]) + va.suffix_type = "Value" + va.populate(child) + self.values.append(va) + self.populate(child,spaces+"----") + pass + + #toString function + def __str__(self): + toReturn = self.prefix_type+self.suffix_type+":" + for i in self.attributeNames: + toReturn += "\n "+i+": "+self.attributes[i] + if self.argumentProperty != "": + toReturn += "\n Argument:\n Property: "+self.argumentProperty+"\n IsRequired: "+self.argumentIsRequired + for i in self.values: + toReturn+="\n "+str(i).replace("\n","\n ") + return toReturn +########################################################################################### + +########################################################################################### +#Class that populates itself from an MSBuild file and outputs it in CMake +#format + +class MSBuildToCMake: + #document = the entire MSBuild xml file + def __init__(self,document=None): + self.enumProperties = [] + self.stringProperties = [] + self.stringListProperties = [] + self.boolProperties = [] + self.intProperties = [] + if document!=None : + self.populate(document) + pass + + #document = the entire MSBuild xml file + #spaces = don't use + #To add a new property (if they exist) copy and paste this code and fill in appropriate places + # + #if child.nodeName == "Property": + # self.Properties.append(Property("",[],child)) + # + #Replace with the name of the new property (ex. if property is StringProperty replace with String) + #Replace with a list of attributes in your property's root node + #in the __init__ function add the line self.Properties = [] + # + #That is all that is required to add new properties + # + def populate(self,document, spaces=""): + for i in range(len(document.childNodes)): + child = document.childNodes[i] + if child.nodeType == child.ELEMENT_NODE: + if child.nodeName == "EnumProperty": + self.enumProperties.append(Property("Enum",["Name","Category"],child)) + if child.nodeName == "StringProperty": + self.stringProperties.append(Property("String",["Name","Subtype","Separator","Category","Visible","IncludeInCommandLine","Switch","ReadOnly"],child)) + if child.nodeName == "StringListProperty": + self.stringListProperties.append(Property("StringList",["Name","Category","Switch","Subtype"],child)) + if child.nodeName == "BoolProperty": + self.boolProperties.append(Property("Bool",["ReverseSwitch","Name","Category","Switch","SwitchPrefix","IncludeInCommandLine"],child)) + if child.nodeName == "IntProperty": + self.intProperties.append(Property("Int",["Name","Category","Visible"],child)) + self.populate(child,spaces+"----") + pass + + #outputs information that CMake needs to know about MSBuild xml files + def toCMake(self): + toReturn = "static cmVS7FlagTable cmVS10CxxTable[] =\n{\n" + toReturn += "\n //Enum Properties\n" + for i in self.enumProperties: + for j in i.values: + toReturn+=" {\""+i.attributes["Name"]+"\", \""+j.attributes["Switch"]+"\", \""+j.DisplayName+"\", \""+j.attributes["Name"]+"\", 0},\n" + toReturn += "\n" + + + toReturn += "\n //Bool Properties\n" + for i in self.boolProperties: + if i.argumentProperty == "": + if i.attributes["ReverseSwitch"] != "": + toReturn += " {\""+i.attributes["Name"]+"\", \""+i.attributes["ReverseSwitch"]+"\", \"\", \"false\", 0},\n" + if i.attributes["Switch"] != "": + toReturn += " {\""+i.attributes["Name"]+"\", \""+i.attributes["Switch"]+"\", \"\", \"true\", 0},\n" + + toReturn += "\n //Bool Properties With Argument\n" + for i in self.boolProperties: + if i.argumentProperty != "": + if i.attributes["ReverseSwitch"] != "": + toReturn += " {\""+i.attributes["Name"]+"\", \""+i.attributes["ReverseSwitch"]+"\", \"\", \"false\", cmVS7FlagTable::Continue},\n" + toReturn += " {\""+i.attributes["Name"]+"\", \""+i.attributes["ReverseSwitch"]+"\", \""+i.DisplayName+"\", \"\", cmVS7FlagTable::UserValueRequired},\n" + if i.attributes["Switch"] != "": + toReturn += " {\""+i.attributes["Name"]+"\", \""+i.attributes["Switch"]+"\", \"\", \"true\", cmVS7FlagTable::Continue},\n" + toReturn += " {\""+i.argumentProperty+"\", \""+i.attributes["Switch"]+"\", \""+i.DisplayName+"\", \"\", cmVS7FlagTable::UserValueRequired},\n" + + toReturn += "\n //String List Properties\n" + for i in self.stringListProperties: + toReturn+=" {\""+i.attributes["Name"]+"\", \""+i.attributes["Switch"]+"\", \""+i.DisplayName+"\", \"\", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},\n" + + toReturn += " {0,0,0,0,0}\n};" + return toReturn + pass + + #toString function + def __str__(self): + toReturn = "" + allList = [self.enumProperties,self.stringProperties,self.stringListProperties,self.boolProperties,self.intProperties] + for p in allList: + for i in p: + toReturn += "==================================================\n"+str(i).replace("\n","\n ")+"\n==================================================\n" + + return toReturn +########################################################################################### + +########################################################################################### +# main function +def main(argv): + xml_file = None + help = """ + Please specify an input xml file with -x + + Exiting... + Have a nice day :)""" + for i in range(0,len(argv)): + if argv[i] == "-x": + xml_file = argv[i+1] + if argv[i] == "-h": + print help + sys.exit(0) + pass + if xml_file == None: + print help + sys.exit(1) + + f = open(xml_file,"r") + xml_str = f.read() + xml_dom = parseString(xml_str) + + convertor = MSBuildToCMake(xml_dom) + print convertor.toCMake() + + xml_dom.unlink() +########################################################################################### +# main entry point +if __name__ == "__main__": + main(sys.argv) + +sys.exit(0) diff --git a/Source/kwsys/ProcessWin32.c b/Source/kwsys/ProcessWin32.c index cba1e61be..7886c2158 100644 --- a/Source/kwsys/ProcessWin32.c +++ b/Source/kwsys/ProcessWin32.c @@ -806,7 +806,7 @@ int kwsysProcess_SetPipeFile(kwsysProcess* cp, int pipe, const char* file) } if(file) { - *pfile = malloc(strlen(file)+1); + *pfile = (char*)malloc(strlen(file)+1); if(!*pfile) { return 0; @@ -1666,7 +1666,7 @@ int kwsysProcessInitialize(kwsysProcess* cp) cp->RealWorkingDirectoryLength = GetCurrentDirectory(0, 0); if(cp->RealWorkingDirectoryLength > 0) { - cp->RealWorkingDirectory = malloc(cp->RealWorkingDirectoryLength); + cp->RealWorkingDirectory = (char*)malloc(cp->RealWorkingDirectoryLength); if(!cp->RealWorkingDirectory) { return 0; @@ -1834,7 +1834,7 @@ int kwsysProcessCreate(kwsysProcess* cp, int index, /* The forwarding executable is given a handle to the error pipe and resume and kill events. */ - realCommand = malloc(strlen(cp->Win9x)+strlen(cp->Commands[index])+100); + realCommand = (char*)malloc(strlen(cp->Win9x)+strlen(cp->Commands[index])+100); if(!realCommand) { return 0; @@ -2672,7 +2672,7 @@ static int kwsysProcess_List__New_NT4(kwsysProcess_List* self) loaded in this program. This does not actually increment the reference count to the module so we do not need to close the handle. */ - HANDLE hNT = GetModuleHandle("ntdll.dll"); + HMODULE hNT = GetModuleHandle("ntdll.dll"); if(hNT) { /* Get pointers to the needed API functions. */ @@ -2776,7 +2776,7 @@ static int kwsysProcess_List__New_Snapshot(kwsysProcess_List* self) loaded in this program. This does not actually increment the reference count to the module so we do not need to close the handle. */ - HANDLE hKernel = GetModuleHandle("kernel32.dll"); + HMODULE hKernel = GetModuleHandle("kernel32.dll"); if(hKernel) { self->P_CreateToolhelp32Snapshot =