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

Merge topic 'vs-masm' 

cbd1d42b Help: Add notes for topic 'vs-masm'
0f8522a6 VS: Add MASM support to VS 8 and 9 (#8170, #14984)
a43f4400 VS: Move internal MasmEnabled member up to VS 7 generator
df3b007d VS: Add test for MASM support
e8727449 VS: Populate MASM tool build settings in .vcxproj files
0271a5f9 VS: Manually fix MASM flag table entries
1d662e48 VS: Generate MASM flag tables from MSBuild tool files
4f6940df VS: Fix ASM_MASM support in VS >= 10
d7866c52 ASM_MASM: Fix selection of ml64
0374abdb ASM_MASM: Add preprocessor definitions to compile lines
5b0a46e1 ASM_MASM: Do not require compiler to be a full path
802dbe52 cmLocalVisualStudio7Generator: Rename local 'lang' var
This commit is contained in:
Brad King 2014-08-22 10:37:55 -04:00 committed by CMake Topic Stage
parent b4d3e7a7b0 cbd1d42b34
commit 8c30014982
22 changed files with 592 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Help/release/dev/vs-masm.rst Normal file
View File

@ -0,0 +1,5 @@
vs-masm
-------
* Visual Studio generators for VS 8 and later learned to support
the ``ASM_MASM`` language.

2
Modules/CMakeASM_MASMInformation.cmake
View File

@ -18,7 +18,7 @@ set(ASM_DIALECT "_MASM")
set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS asm) set(CMAKE_ASM${ASM_DIALECT}_SOURCE_FILE_EXTENSIONS asm)
set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <FLAGS> /c /Fo <OBJECT> <SOURCE>") set(CMAKE_ASM${ASM_DIALECT}_COMPILE_OBJECT "<CMAKE_ASM${ASM_DIALECT}_COMPILER> <DEFINES> <FLAGS> /c /Fo <OBJECT> <SOURCE>")
include(CMakeASMInformation) include(CMakeASMInformation)
set(ASM_DIALECT) set(ASM_DIALECT)

3
Modules/CMakeDetermineASM_MASMCompiler.cmake
View File

@ -17,7 +17,8 @@
set(ASM_DIALECT "_MASM") set(ASM_DIALECT "_MASM")
# if we are using the 64bit cl compiler, assume we also want the 64bit assembler # if we are using the 64bit cl compiler, assume we also want the 64bit assembler
if(CMAKE_CL_64) if(";${CMAKE_VS_PLATFORM_NAME};${MSVC_C_ARCHITECTURE_ID};${MSVC_CXX_ARCHITECTURE_ID};"
MATCHES ";(Win64|Itanium|x64|IA64);")
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ml64) set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ml64)
else() else()
set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ml) set(CMAKE_ASM${ASM_DIALECT}_COMPILER_INIT ml)

3
Source/cmGlobalGenerator.cxx
View File

@ -620,7 +620,8 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
"No " << compilerName << " could be found.\n" "No " << compilerName << " could be found.\n"
; ;
} }
else if(strcmp(lang, "RC") != 0) else if(strcmp(lang, "RC") != 0 &&
strcmp(lang, "ASM_MASM") != 0)
{ {
if(!cmSystemTools::FileIsFullPath(compilerFile)) if(!cmSystemTools::FileIsFullPath(compilerFile))
{ {

10
Source/cmGlobalVisualStudio10Generator.cxx
View File

@ -99,7 +99,6 @@ cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator(
"ProductDir", vc10Express, cmSystemTools::KeyWOW64_32); "ProductDir", vc10Express, cmSystemTools::KeyWOW64_32);
this->SystemIsWindowsPhone = false; this->SystemIsWindowsPhone = false;
this->SystemIsWindowsStore = false; this->SystemIsWindowsStore = false;
this->MasmEnabled = false;
this->MSBuildCommandInitialized = false; this->MSBuildCommandInitialized = false;
} }
@ -257,15 +256,6 @@ void cmGlobalVisualStudio10Generator
::EnableLanguage(std::vector<std::string>const & lang, ::EnableLanguage(std::vector<std::string>const & lang,
cmMakefile *mf, bool optional) cmMakefile *mf, bool optional)
{ {
for(std::vector<std::string>::const_iterator it = lang.begin();
it != lang.end(); ++it)
{
if(*it == "ASM_MASM")
{
this->MasmEnabled = true;
}
}
cmGlobalVisualStudio8Generator::EnableLanguage(lang, mf, optional); cmGlobalVisualStudio8Generator::EnableLanguage(lang, mf, optional);
} }

4
Source/cmGlobalVisualStudio10Generator.h
View File

@ -58,9 +58,6 @@ public:
/** Is the installed VS an Express edition? */ /** Is the installed VS an Express edition? */
bool IsExpressEdition() const { return this->ExpressEdition; } bool IsExpressEdition() const { return this->ExpressEdition; }
/** Is the Microsoft Assembler enabled? */
bool IsMasmEnabled() const { return this->MasmEnabled; }
/** The toolset name for the target platform. */ /** The toolset name for the target platform. */
const char* GetPlatformToolset() const; const char* GetPlatformToolset() const;
@ -123,7 +120,6 @@ protected:
bool SystemIsWindowsPhone; bool SystemIsWindowsPhone;
bool SystemIsWindowsStore; bool SystemIsWindowsStore;
bool ExpressEdition; bool ExpressEdition;
bool MasmEnabled;
bool UseFolderProperty(); bool UseFolderProperty();

1
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -23,6 +23,7 @@ cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator(
{ {
this->IntelProjectVersion = 0; this->IntelProjectVersion = 0;
this->DevEnvCommandInitialized = false; this->DevEnvCommandInitialized = false;
this->MasmEnabled = false;
if (platformName.empty()) if (platformName.empty())
{ {

4
Source/cmGlobalVisualStudio7Generator.h
View File

@ -102,6 +102,9 @@ public:
virtual void FindMakeProgram(cmMakefile*); virtual void FindMakeProgram(cmMakefile*);
/** Is the Microsoft Assembler enabled? */
bool IsMasmEnabled() const { return this->MasmEnabled; }
// Encoding for Visual Studio files // Encoding for Visual Studio files
virtual std::string Encoding(); virtual std::string Encoding();
@ -173,6 +176,7 @@ protected:
// There is one SLN file per project. // There is one SLN file per project.
std::string CurrentProject; std::string CurrentProject;
std::string PlatformName; std::string PlatformName;
bool MasmEnabled;
private: private:
char* IntelProjectVersion; char* IntelProjectVersion;

8
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -136,6 +136,14 @@ void cmGlobalVisualStudio8Generator
::EnableLanguage(std::vector<std::string>const & lang, ::EnableLanguage(std::vector<std::string>const & lang,
cmMakefile *mf, bool optional) cmMakefile *mf, bool optional)
{ {
for(std::vector<std::string>::const_iterator it = lang.begin();
it != lang.end(); ++it)
{
if(*it == "ASM_MASM")
{
this->MasmEnabled = true;
}
}
this->AddPlatformDefinitions(mf); this->AddPlatformDefinitions(mf);
cmGlobalVisualStudio7Generator::EnableLanguage(lang, mf, optional); cmGlobalVisualStudio7Generator::EnableLanguage(lang, mf, optional);
} }

57
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -44,6 +44,16 @@ private:
extern cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[]; extern cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[];
static void cmConvertToWindowsSlash(std::string& s)
{
std::string::size_type pos = 0;
while((pos = s.find('/', pos)) != std::string::npos)
{
s[pos] = '\\';
pos++;
}
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmLocalVisualStudio7Generator::cmLocalVisualStudio7Generator(VSVersion v): cmLocalVisualStudio7Generator::cmLocalVisualStudio7Generator(VSVersion v):
cmLocalVisualStudioGenerator(v) cmLocalVisualStudioGenerator(v)
@ -862,6 +872,31 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(std::ostream& fout,
} }
} }
fout << "/>\n"; // end of <Tool Name=VCCLCompilerTool fout << "/>\n"; // end of <Tool Name=VCCLCompilerTool
if(gg->IsMasmEnabled() && !this->FortranProject)
{
Options masmOptions(this, Options::MasmCompiler, 0, 0);
fout <<
"\t\t\t<Tool\n"
"\t\t\t\tName=\"MASM\"\n"
"\t\t\t\tIncludePaths=\""
;
const char* sep = "";
for(i = includes.begin(); i != includes.end(); ++i)
{
std::string inc = *i;
cmConvertToWindowsSlash(inc);
fout << sep << this->EscapeForXML(inc);
sep = ";";
}
fout << "\"\n";
// Use same preprocessor definitions as VCCLCompilerTool.
targetOptions.OutputPreprocessorDefinitions(fout, "\t\t\t\t", "\n",
"ASM_MASM");
masmOptions.OutputFlagMap(fout, "\t\t\t\t");
fout <<
"\t\t\t\tObjectFile=\"$(IntDir)\\\"\n"
"\t\t\t/>\n";
}
tool = "VCCustomBuildTool"; tool = "VCCustomBuildTool";
if(this->FortranProject) if(this->FortranProject)
{ {
@ -1695,11 +1730,12 @@ bool cmLocalVisualStudio7Generator
else if(!fcinfo.FileConfigMap.empty()) else if(!fcinfo.FileConfigMap.empty())
{ {
const char* aCompilerTool = "VCCLCompilerTool"; const char* aCompilerTool = "VCCLCompilerTool";
const char* lang = "CXX"; const char* ppLang = "CXX";
if(this->FortranProject) if(this->FortranProject)
{ {
aCompilerTool = "VFFortranCompilerTool"; aCompilerTool = "VFFortranCompilerTool";
} }
std::string const& lang = (*sf)->GetLanguage();
std::string ext = (*sf)->GetExtension(); std::string ext = (*sf)->GetExtension();
ext = cmSystemTools::LowerCase(ext); ext = cmSystemTools::LowerCase(ext);
if(ext == "idl") if(ext == "idl")
@ -1713,7 +1749,7 @@ bool cmLocalVisualStudio7Generator
if(ext == "rc") if(ext == "rc")
{ {
aCompilerTool = "VCResourceCompilerTool"; aCompilerTool = "VCResourceCompilerTool";
lang = "RC"; ppLang = "RC";
if(this->FortranProject) if(this->FortranProject)
{ {
aCompilerTool = "VFResourceCompilerTool"; aCompilerTool = "VFResourceCompilerTool";
@ -1727,6 +1763,11 @@ bool cmLocalVisualStudio7Generator
aCompilerTool = "VFCustomBuildTool"; aCompilerTool = "VFCustomBuildTool";
} }
} }
if (gg->IsMasmEnabled() && !this->FortranProject &&
lang == "ASM_MASM")
{
aCompilerTool = "MASM";
}
for(std::map<std::string, cmLVS7GFileConfig>::const_iterator for(std::map<std::string, cmLVS7GFileConfig>::const_iterator
fci = fcinfo.FileConfigMap.begin(); fci = fcinfo.FileConfigMap.begin();
fci != fcinfo.FileConfigMap.end(); ++fci) fci != fcinfo.FileConfigMap.end(); ++fci)
@ -1763,7 +1804,7 @@ bool cmLocalVisualStudio7Generator
fileOptions.OutputFlagMap(fout, "\t\t\t\t\t"); fileOptions.OutputFlagMap(fout, "\t\t\t\t\t");
fileOptions.OutputPreprocessorDefinitions(fout, fileOptions.OutputPreprocessorDefinitions(fout,
"\t\t\t\t\t", "\n", "\t\t\t\t\t", "\n",
lang); ppLang);
} }
if(!fc.AdditionalDeps.empty()) if(!fc.AdditionalDeps.empty())
{ {
@ -2095,6 +2136,16 @@ cmLocalVisualStudio7Generator::WriteProjectStart(std::ostream& fout,
<< "\t<Platforms>\n" << "\t<Platforms>\n"
<< "\t\t<Platform\n\t\t\tName=\"" << gg->GetPlatformName() << "\"/>\n" << "\t\t<Platform\n\t\t\tName=\"" << gg->GetPlatformName() << "\"/>\n"
<< "\t</Platforms>\n"; << "\t</Platforms>\n";
if(gg->IsMasmEnabled())
{
fout <<
"\t<ToolFiles>\n"
"\t\t<DefaultToolFile\n"
"\t\t\tFileName=\"masm.rules\"\n"
"\t\t/>\n"
"\t</ToolFiles>\n"
;
}
} }

96
Source/cmVS10MASMFlagTable.h Normal file
View File

@ -0,0 +1,96 @@
static cmVS7FlagTable cmVS10MASMFlagTable[] =
{
//Enum Properties
{"PreserveIdentifierCase", "",
"Default", "0", 0},
{"PreserveIdentifierCase", "/Cp",
"Preserves Identifier Case (/Cp)", "1", 0},
{"PreserveIdentifierCase", "/Cu",
"Maps all identifiers to upper case. (/Cu)", "2", 0},
{"PreserveIdentifierCase", "/Cx",
"Preserves case in public and extern symbols. (/Cx)", "3", 0},
{"WarningLevel", "/W0",
"Warning Level 0 (/W0)", "0", 0},
{"WarningLevel", "/W1",
"Warning Level 1 (/W1)", "1", 0},
{"WarningLevel", "/W2",
"Warning Level 2 (/W2)", "2", 0},
{"WarningLevel", "/W3",
"Warning Level 3 (/W3)", "3", 0},
{"PackAlignmentBoundary", "",
"Default", "0", 0},
{"PackAlignmentBoundary", "/Zp1",
"One Byte Boundary (/Zp1)", "1", 0},
{"PackAlignmentBoundary", "/Zp2",
"Two Byte Boundary (/Zp2)", "2", 0},
{"PackAlignmentBoundary", "/Zp4",
"Four Byte Boundary (/Zp4)", "3", 0},
{"PackAlignmentBoundary", "/Zp8",
"Eight Byte Boundary (/Zp8)", "4", 0},
{"PackAlignmentBoundary", "/Zp16",
"Sixteen Byte Boundary (/Zp16)", "5", 0},
{"CallingConvention", "",
"Default", "0", 0},
{"CallingConvention", "/Gd",
"Use C-style Calling Convention (/Gd)", "1", 0},
{"CallingConvention", "/Gz",
"Use stdcall Calling Convention (/Gz)", "2", 0},
{"CallingConvention", "/Gc",
"Use Pascal Calling Convention (/Gc)", "3", 0},
{"ErrorReporting", "/errorReport:prompt",
"Prompt to send report immediately (/errorReport:prompt)", "0", 0},
{"ErrorReporting", "/errorReport:queue",
"Prompt to send report at the next logon (/errorReport:queue)", "1", 0},
{"ErrorReporting", "/errorReport:send",
"Automatically send report (/errorReport:send)", "2", 0},
{"ErrorReporting", "/errorReport:none",
"Do not send report (/errorReport:none)", "3", 0},
//Bool Properties
{"NoLogo", "/nologo", "", "true", 0},
{"GeneratePreprocessedSourceListing", "/EP", "", "true", 0},
{"ListAllAvailableInformation", "/Sa", "", "true", 0},
{"UseSafeExceptionHandlers", "/safeseh", "", "true", 0},
{"AddFirstPassListing", "/Sf", "", "true", 0},
{"EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0},
{"DisableSymbolTable", "/Sn", "", "true", 0},
{"EnableFalseConditionalsInListing", "/Sx", "", "true", 0},
{"TreatWarningsAsErrors", "/WX", "", "true", 0},
{"MakeAllSymbolsPublic", "/Zf", "", "true", 0},
{"GenerateDebugInformation", "/Zi", "", "true", 0},
{"EnableMASM51Compatibility", "/Zm", "", "true", 0},
{"PerformSyntaxCheckOnly", "/Zs", "", "true", 0},
//Bool Properties With Argument
//String List Properties
{"PreprocessorDefinitions", "/D",
"Preprocessor Definitions",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
{"IncludePaths", "/I",
"Include Paths",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
{"BrowseFile", "/FR",
"Generate Browse Information File",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
// Skip [AdditionalDependencies] - no command line Switch.
//String Properties
// Skip [Inputs] - no command line Switch.
{"ObjectFileName", "/Fo",
"Object File Name",
"", cmVS7FlagTable::UserValue},
{"AssembledCodeListingFile", "/Fl",
"Assembled Code Listing File",
"", cmVS7FlagTable::UserValue},
// Skip [CommandLineTemplate] - no command line Switch.
// Skip [ExecutionDescription] - no command line Switch.
// Skip [AdditionalOptions] - no command line Switch.
{0,0,0,0,0}
};

96
Source/cmVS11MASMFlagTable.h Normal file
View File

@ -0,0 +1,96 @@
static cmVS7FlagTable cmVS11MASMFlagTable[] =
{
//Enum Properties
{"PreserveIdentifierCase", "",
"Default", "0", 0},
{"PreserveIdentifierCase", "/Cp",
"Preserves Identifier Case (/Cp)", "1", 0},
{"PreserveIdentifierCase", "/Cu",
"Maps all identifiers to upper case. (/Cu)", "2", 0},
{"PreserveIdentifierCase", "/Cx",
"Preserves case in public and extern symbols. (/Cx)", "3", 0},
{"WarningLevel", "/W0",
"Warning Level 0 (/W0)", "0", 0},
{"WarningLevel", "/W1",
"Warning Level 1 (/W1)", "1", 0},
{"WarningLevel", "/W2",
"Warning Level 2 (/W2)", "2", 0},
{"WarningLevel", "/W3",
"Warning Level 3 (/W3)", "3", 0},
{"PackAlignmentBoundary", "",
"Default", "0", 0},
{"PackAlignmentBoundary", "/Zp1",
"One Byte Boundary (/Zp1)", "1", 0},
{"PackAlignmentBoundary", "/Zp2",
"Two Byte Boundary (/Zp2)", "2", 0},
{"PackAlignmentBoundary", "/Zp4",
"Four Byte Boundary (/Zp4)", "3", 0},
{"PackAlignmentBoundary", "/Zp8",
"Eight Byte Boundary (/Zp8)", "4", 0},
{"PackAlignmentBoundary", "/Zp16",
"Sixteen Byte Boundary (/Zp16)", "5", 0},
{"CallingConvention", "",
"Default", "0", 0},
{"CallingConvention", "/Gd",
"Use C-style Calling Convention (/Gd)", "1", 0},
{"CallingConvention", "/Gz",
"Use stdcall Calling Convention (/Gz)", "2", 0},
{"CallingConvention", "/Gc",
"Use Pascal Calling Convention (/Gc)", "3", 0},
{"ErrorReporting", "/errorReport:prompt",
"Prompt to send report immediately (/errorReport:prompt)", "0", 0},
{"ErrorReporting", "/errorReport:queue",
"Prompt to send report at the next logon (/errorReport:queue)", "1", 0},
{"ErrorReporting", "/errorReport:send",
"Automatically send report (/errorReport:send)", "2", 0},
{"ErrorReporting", "/errorReport:none",
"Do not send report (/errorReport:none)", "3", 0},
//Bool Properties
{"NoLogo", "/nologo", "", "true", 0},
{"GeneratePreprocessedSourceListing", "/EP", "", "true", 0},
{"ListAllAvailableInformation", "/Sa", "", "true", 0},
{"UseSafeExceptionHandlers", "/safeseh", "", "true", 0},
{"AddFirstPassListing", "/Sf", "", "true", 0},
{"EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0},
{"DisableSymbolTable", "/Sn", "", "true", 0},
{"EnableFalseConditionalsInListing", "/Sx", "", "true", 0},
{"TreatWarningsAsErrors", "/WX", "", "true", 0},
{"MakeAllSymbolsPublic", "/Zf", "", "true", 0},
{"GenerateDebugInformation", "/Zi", "", "true", 0},
{"EnableMASM51Compatibility", "/Zm", "", "true", 0},
{"PerformSyntaxCheckOnly", "/Zs", "", "true", 0},
//Bool Properties With Argument
//String List Properties
{"PreprocessorDefinitions", "/D",
"Preprocessor Definitions",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
{"IncludePaths", "/I",
"Include Paths",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
{"BrowseFile", "/FR",
"Generate Browse Information File",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
// Skip [AdditionalDependencies] - no command line Switch.
//String Properties
// Skip [Inputs] - no command line Switch.
{"ObjectFileName", "/Fo",
"Object File Name",
"", cmVS7FlagTable::UserValue},
{"AssembledCodeListingFile", "/Fl",
"Assembled Code Listing File",
"", cmVS7FlagTable::UserValue},
// Skip [CommandLineTemplate] - no command line Switch.
// Skip [ExecutionDescription] - no command line Switch.
// Skip [AdditionalOptions] - no command line Switch.
{0,0,0,0,0}
};

96
Source/cmVS12MASMFlagTable.h Normal file
View File

@ -0,0 +1,96 @@
static cmVS7FlagTable cmVS12MASMFlagTable[] =
{
//Enum Properties
{"PreserveIdentifierCase", "",
"Default", "0", 0},
{"PreserveIdentifierCase", "/Cp",
"Preserves Identifier Case (/Cp)", "1", 0},
{"PreserveIdentifierCase", "/Cu",
"Maps all identifiers to upper case. (/Cu)", "2", 0},
{"PreserveIdentifierCase", "/Cx",
"Preserves case in public and extern symbols. (/Cx)", "3", 0},
{"WarningLevel", "/W0",
"Warning Level 0 (/W0)", "0", 0},
{"WarningLevel", "/W1",
"Warning Level 1 (/W1)", "1", 0},
{"WarningLevel", "/W2",
"Warning Level 2 (/W2)", "2", 0},
{"WarningLevel", "/W3",
"Warning Level 3 (/W3)", "3", 0},
{"PackAlignmentBoundary", "",
"Default", "0", 0},
{"PackAlignmentBoundary", "/Zp1",
"One Byte Boundary (/Zp1)", "1", 0},
{"PackAlignmentBoundary", "/Zp2",
"Two Byte Boundary (/Zp2)", "2", 0},
{"PackAlignmentBoundary", "/Zp4",
"Four Byte Boundary (/Zp4)", "3", 0},
{"PackAlignmentBoundary", "/Zp8",
"Eight Byte Boundary (/Zp8)", "4", 0},
{"PackAlignmentBoundary", "/Zp16",
"Sixteen Byte Boundary (/Zp16)", "5", 0},
{"CallingConvention", "",
"Default", "0", 0},
{"CallingConvention", "/Gd",
"Use C-style Calling Convention (/Gd)", "1", 0},
{"CallingConvention", "/Gz",
"Use stdcall Calling Convention (/Gz)", "2", 0},
{"CallingConvention", "/Gc",
"Use Pascal Calling Convention (/Gc)", "3", 0},
{"ErrorReporting", "/errorReport:prompt",
"Prompt to send report immediately (/errorReport:prompt)", "0", 0},
{"ErrorReporting", "/errorReport:queue",
"Prompt to send report at the next logon (/errorReport:queue)", "1", 0},
{"ErrorReporting", "/errorReport:send",
"Automatically send report (/errorReport:send)", "2", 0},
{"ErrorReporting", "/errorReport:none",
"Do not send report (/errorReport:none)", "3", 0},
//Bool Properties
{"NoLogo", "/nologo", "", "true", 0},
{"GeneratePreprocessedSourceListing", "/EP", "", "true", 0},
{"ListAllAvailableInformation", "/Sa", "", "true", 0},
{"UseSafeExceptionHandlers", "/safeseh", "", "true", 0},
{"AddFirstPassListing", "/Sf", "", "true", 0},
{"EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0},
{"DisableSymbolTable", "/Sn", "", "true", 0},
{"EnableFalseConditionalsInListing", "/Sx", "", "true", 0},
{"TreatWarningsAsErrors", "/WX", "", "true", 0},
{"MakeAllSymbolsPublic", "/Zf", "", "true", 0},
{"GenerateDebugInformation", "/Zi", "", "true", 0},
{"EnableMASM51Compatibility", "/Zm", "", "true", 0},
{"PerformSyntaxCheckOnly", "/Zs", "", "true", 0},
//Bool Properties With Argument
//String List Properties
{"PreprocessorDefinitions", "/D",
"Preprocessor Definitions",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
{"IncludePaths", "/I",
"Include Paths",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
{"BrowseFile", "/FR",
"Generate Browse Information File",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
// Skip [AdditionalDependencies] - no command line Switch.
//String Properties
// Skip [Inputs] - no command line Switch.
{"ObjectFileName", "/Fo",
"Object File Name",
"", cmVS7FlagTable::UserValue},
{"AssembledCodeListingFile", "/Fl",
"Assembled Code Listing File",
"", cmVS7FlagTable::UserValue},
// Skip [CommandLineTemplate] - no command line Switch.
// Skip [ExecutionDescription] - no command line Switch.
// Skip [AdditionalOptions] - no command line Switch.
{0,0,0,0,0}
};

96
Source/cmVS14MASMFlagTable.h Normal file
View File

@ -0,0 +1,96 @@
static cmVS7FlagTable cmVS14MASMFlagTable[] =
{
//Enum Properties
{"PreserveIdentifierCase", "",
"Default", "0", 0},
{"PreserveIdentifierCase", "/Cp",
"Preserves Identifier Case (/Cp)", "1", 0},
{"PreserveIdentifierCase", "/Cu",
"Maps all identifiers to upper case. (/Cu)", "2", 0},
{"PreserveIdentifierCase", "/Cx",
"Preserves case in public and extern symbols. (/Cx)", "3", 0},
{"WarningLevel", "/W0",
"Warning Level 0 (/W0)", "0", 0},
{"WarningLevel", "/W1",
"Warning Level 1 (/W1)", "1", 0},
{"WarningLevel", "/W2",
"Warning Level 2 (/W2)", "2", 0},
{"WarningLevel", "/W3",
"Warning Level 3 (/W3)", "3", 0},
{"PackAlignmentBoundary", "",
"Default", "0", 0},
{"PackAlignmentBoundary", "/Zp1",
"One Byte Boundary (/Zp1)", "1", 0},
{"PackAlignmentBoundary", "/Zp2",
"Two Byte Boundary (/Zp2)", "2", 0},
{"PackAlignmentBoundary", "/Zp4",
"Four Byte Boundary (/Zp4)", "3", 0},
{"PackAlignmentBoundary", "/Zp8",
"Eight Byte Boundary (/Zp8)", "4", 0},
{"PackAlignmentBoundary", "/Zp16",
"Sixteen Byte Boundary (/Zp16)", "5", 0},
{"CallingConvention", "",
"Default", "0", 0},
{"CallingConvention", "/Gd",
"Use C-style Calling Convention (/Gd)", "1", 0},
{"CallingConvention", "/Gz",
"Use stdcall Calling Convention (/Gz)", "2", 0},
{"CallingConvention", "/Gc",
"Use Pascal Calling Convention (/Gc)", "3", 0},
{"ErrorReporting", "/errorReport:prompt",
"Prompt to send report immediately (/errorReport:prompt)", "0", 0},
{"ErrorReporting", "/errorReport:queue",
"Prompt to send report at the next logon (/errorReport:queue)", "1", 0},
{"ErrorReporting", "/errorReport:send",
"Automatically send report (/errorReport:send)", "2", 0},
{"ErrorReporting", "/errorReport:none",
"Do not send report (/errorReport:none)", "3", 0},
//Bool Properties
{"NoLogo", "/nologo", "", "true", 0},
{"GeneratePreprocessedSourceListing", "/EP", "", "true", 0},
{"ListAllAvailableInformation", "/Sa", "", "true", 0},
{"UseSafeExceptionHandlers", "/safeseh", "", "true", 0},
{"AddFirstPassListing", "/Sf", "", "true", 0},
{"EnableAssemblyGeneratedCodeListing", "/Sg", "", "true", 0},
{"DisableSymbolTable", "/Sn", "", "true", 0},
{"EnableFalseConditionalsInListing", "/Sx", "", "true", 0},
{"TreatWarningsAsErrors", "/WX", "", "true", 0},
{"MakeAllSymbolsPublic", "/Zf", "", "true", 0},
{"GenerateDebugInformation", "/Zi", "", "true", 0},
{"EnableMASM51Compatibility", "/Zm", "", "true", 0},
{"PerformSyntaxCheckOnly", "/Zs", "", "true", 0},
//Bool Properties With Argument
//String List Properties
{"PreprocessorDefinitions", "/D",
"Preprocessor Definitions",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
{"IncludePaths", "/I",
"Include Paths",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
{"BrowseFile", "/FR",
"Generate Browse Information File",
"", cmVS7FlagTable::UserValue | cmVS7FlagTable::SemicolonAppendable},
// Skip [AdditionalDependencies] - no command line Switch.
//String Properties
// Skip [Inputs] - no command line Switch.
{"ObjectFileName", "/Fo",
"Object File Name",
"", cmVS7FlagTable::UserValue},
{"AssembledCodeListingFile", "/Fl",
"Assembled Code Listing File",
"", cmVS7FlagTable::UserValue},
// Skip [CommandLineTemplate] - no command line Switch.
// Skip [ExecutionDescription] - no command line Switch.
// Skip [AdditionalOptions] - no command line Switch.
{0,0,0,0,0}
};

94
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -24,18 +24,22 @@
#include "cmVS10RCFlagTable.h" #include "cmVS10RCFlagTable.h"
#include "cmVS10LinkFlagTable.h" #include "cmVS10LinkFlagTable.h"
#include "cmVS10LibFlagTable.h" #include "cmVS10LibFlagTable.h"
#include "cmVS10MASMFlagTable.h"
#include "cmVS11CLFlagTable.h" #include "cmVS11CLFlagTable.h"
#include "cmVS11RCFlagTable.h" #include "cmVS11RCFlagTable.h"
#include "cmVS11LinkFlagTable.h" #include "cmVS11LinkFlagTable.h"
#include "cmVS11LibFlagTable.h" #include "cmVS11LibFlagTable.h"
#include "cmVS11MASMFlagTable.h"
#include "cmVS12CLFlagTable.h" #include "cmVS12CLFlagTable.h"
#include "cmVS12RCFlagTable.h" #include "cmVS12RCFlagTable.h"
#include "cmVS12LinkFlagTable.h" #include "cmVS12LinkFlagTable.h"
#include "cmVS12LibFlagTable.h" #include "cmVS12LibFlagTable.h"
#include "cmVS12MASMFlagTable.h"
#include "cmVS14CLFlagTable.h" #include "cmVS14CLFlagTable.h"
#include "cmVS14RCFlagTable.h" #include "cmVS14RCFlagTable.h"
#include "cmVS14LinkFlagTable.h" #include "cmVS14LinkFlagTable.h"
#include "cmVS14LibFlagTable.h" #include "cmVS14LibFlagTable.h"
#include "cmVS14MASMFlagTable.h"
#include <cmsys/auto_ptr.hxx> #include <cmsys/auto_ptr.hxx>
@ -111,6 +115,24 @@ cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetLinkFlagTable() const
return 0; return 0;
} }
cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetMasmFlagTable() const
{
if(this->MSTools)
{
cmLocalVisualStudioGenerator::VSVersion
v = this->LocalGenerator->GetVersion();
if(v >= cmLocalVisualStudioGenerator::VS14)
{ return cmVS14MASMFlagTable; }
else if(v >= cmLocalVisualStudioGenerator::VS12)
{ return cmVS12MASMFlagTable; }
else if(v == cmLocalVisualStudioGenerator::VS11)
{ return cmVS11MASMFlagTable; }
else
{ return cmVS10MASMFlagTable; }
}
return 0;
}
static std::string cmVS10EscapeXML(std::string arg) static std::string cmVS10EscapeXML(std::string arg)
{ {
cmSystemTools::ReplaceString(arg, "&", "&amp;"); cmSystemTools::ReplaceString(arg, "&", "&amp;");
@ -251,6 +273,10 @@ void cmVisualStudio10TargetGenerator::Generate()
{ {
return; return;
} }
if(!this->ComputeMasmOptions())
{
return;
}
if(!this->ComputeLinkOptions()) if(!this->ComputeLinkOptions())
{ {
return; return;
@ -1192,7 +1218,7 @@ void cmVisualStudio10TargetGenerator::WriteAllSources()
{ {
tool = "ClCompile"; tool = "ClCompile";
} }
else if (lang == "ASM_NASM" && else if (lang == "ASM_MASM" &&
this->GlobalGenerator->IsMasmEnabled()) this->GlobalGenerator->IsMasmEnabled())
{ {
tool = "MASM"; tool = "MASM";
@ -1715,6 +1741,71 @@ WriteRCOptions(std::string const& configName,
this->WriteString("</ResourceCompile>\n", 2); this->WriteString("</ResourceCompile>\n", 2);
} }
//----------------------------------------------------------------------------
bool cmVisualStudio10TargetGenerator::ComputeMasmOptions()
{
if(!this->GlobalGenerator->IsMasmEnabled())
{
return true;
}
std::vector<std::string> const* configs =
this->GlobalGenerator->GetConfigurations();
for(std::vector<std::string>::const_iterator i = configs->begin();
i != configs->end(); ++i)
{
if(!this->ComputeMasmOptions(*i))
{
return false;
}
}
return true;
}
//----------------------------------------------------------------------------
bool cmVisualStudio10TargetGenerator::ComputeMasmOptions(
std::string const& configName)
{
cmsys::auto_ptr<Options> pOptions(
new Options(this->LocalGenerator, Options::MasmCompiler,
this->GetMasmFlagTable()));
Options& masmOptions = *pOptions;
std::string CONFIG = cmSystemTools::UpperCase(configName);
std::string configFlagsVar = std::string("CMAKE_ASM_MASM_FLAGS_") + CONFIG;
std::string flags =
std::string(this->Makefile->GetSafeDefinition("CMAKE_ASM_MASM_FLAGS")) +
std::string(" ") +
std::string(this->Makefile->GetSafeDefinition(configFlagsVar));
masmOptions.Parse(flags.c_str());
this->MasmOptions[configName] = pOptions.release();
return true;
}
void cmVisualStudio10TargetGenerator::
WriteMasmOptions(std::string const& configName,
std::vector<std::string> const& includes)
{
if(!this->MSTools || !this->GlobalGenerator->IsMasmEnabled())
{
return;
}
this->WriteString("<MASM>\n", 2);
// Preprocessor definitions and includes are shared with clOptions.
Options& clOptions = *(this->ClOptions[configName]);
clOptions.OutputPreprocessorDefinitions(*this->BuildFileStream, " ",
"\n", "ASM_MASM");
Options& masmOptions = *(this->MasmOptions[configName]);
masmOptions.AppendFlag("IncludePaths", includes);
masmOptions.AppendFlag("IncludePaths", "%(IncludePaths)");
masmOptions.OutputFlagMap(*this->BuildFileStream, " ");
masmOptions.OutputAdditionalOptions(*this->BuildFileStream, " ", "");
this->WriteString("</MASM>\n", 2);
}
void void
cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config) cmVisualStudio10TargetGenerator::WriteLibOptions(std::string const& config)
@ -2059,6 +2150,7 @@ void cmVisualStudio10TargetGenerator::WriteItemDefinitionGroups()
this->WriteClOptions(*i, includes); this->WriteClOptions(*i, includes);
// output rc compile flags <ResourceCompile></ResourceCompile> // output rc compile flags <ResourceCompile></ResourceCompile>
this->WriteRCOptions(*i, includes); this->WriteRCOptions(*i, includes);
this->WriteMasmOptions(*i, includes);
} }
// output midl flags <Midl></Midl> // output midl flags <Midl></Midl>
this->WriteMidlOptions(*i, includes); this->WriteMidlOptions(*i, includes);

6
Source/cmVisualStudio10TargetGenerator.h
View File

@ -78,6 +78,10 @@ private:
bool ComputeRcOptions(std::string const& config); bool ComputeRcOptions(std::string const& config);
void WriteRCOptions(std::string const& config, void WriteRCOptions(std::string const& config,
std::vector<std::string> const & includes); std::vector<std::string> const & includes);
bool ComputeMasmOptions();
bool ComputeMasmOptions(std::string const& config);
void WriteMasmOptions(std::string const& config,
std::vector<std::string> const& includes);
bool ComputeLinkOptions(); bool ComputeLinkOptions();
bool ComputeLinkOptions(std::string const& config); bool ComputeLinkOptions(std::string const& config);
void WriteLinkOptions(std::string const& config); void WriteLinkOptions(std::string const& config);
@ -109,12 +113,14 @@ private:
cmIDEFlagTable const* GetRcFlagTable() const; cmIDEFlagTable const* GetRcFlagTable() const;
cmIDEFlagTable const* GetLibFlagTable() const; cmIDEFlagTable const* GetLibFlagTable() const;
cmIDEFlagTable const* GetLinkFlagTable() const; cmIDEFlagTable const* GetLinkFlagTable() const;
cmIDEFlagTable const* GetMasmFlagTable() const;
private: private:
typedef cmVisualStudioGeneratorOptions Options; typedef cmVisualStudioGeneratorOptions Options;
typedef std::map<std::string, Options*> OptionsMap; typedef std::map<std::string, Options*> OptionsMap;
OptionsMap ClOptions; OptionsMap ClOptions;
OptionsMap RcOptions; OptionsMap RcOptions;
OptionsMap MasmOptions;
OptionsMap LinkOptions; OptionsMap LinkOptions;
std::string PathToVcxproj; std::string PathToVcxproj;
cmTarget* Target; cmTarget* Target;

1
Source/cmVisualStudioGeneratorOptions.h
View File

@ -28,6 +28,7 @@ public:
{ {
Compiler, Compiler,
ResourceCompiler, ResourceCompiler,
MasmCompiler,
Linker, Linker,
FortranCompiler FortranCompiler
}; };

8
Tests/CMakeLists.txt
View File

@ -1679,6 +1679,14 @@ ${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MFC") list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MFC")
endif() endif()
if(MSVC AND NOT MSVC_VERSION LESS 1310
AND NOT CMAKE_GENERATOR MATCHES "Visual Studio [67]( |$)"
AND (NOT CMAKE_GENERATOR MATCHES "Visual Studio [89]( |$)"
OR CMAKE_SIZEOF_VOID_P EQUAL 4)
)
ADD_TEST_MACRO(VSMASM VSMASM)
endif()
if(${CMAKE_GENERATOR} MATCHES "Visual Studio") if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
if(NOT MSVC60) if(NOT MSVC60)
ADD_TEST_MACRO(SBCS SBCS) ADD_TEST_MACRO(SBCS SBCS)

10
Tests/VSMASM/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
cmake_minimum_required(VERSION 2.8.12)
project(VSMASM C ASM_MASM)
if(CMAKE_SIZEOF_VOID_P EQUAL 8)
add_definitions(-DTESTx64)
else()
add_definitions(-DTESTi386)
set(CMAKE_ASM_MASM_FLAGS "${CMAKE_ASM_MASM_FLAGS} /safeseh")
endif()
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
add_executable(VSMASM main.c foo.asm)

7
Tests/VSMASM/foo.asm Normal file
View File

@ -0,0 +1,7 @@
ifndef TESTx64
.386
.model flat, c
endif
.code
include <foo-proc.asm>
end

4
Tests/VSMASM/include/foo-proc.asm Normal file
View File

@ -0,0 +1,4 @@
foo proc public
mov eax,0
ret
foo endp

2
Tests/VSMASM/main.c Normal file
View File

@ -0,0 +1,2 @@
extern int foo(void);
int main(void) { return foo(); }