Support MASM in MSBuild and Winja

pylib/gyp/generator/msvs.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import copy
 import ntpath
 import os
 import posixpath
 import re
 import subprocess
@@ skipping 900 matching lines @@
   gyp_file = os.path.split(project.build_file)[1]
   sources, excluded_sources = _PrepareListOfSources(spec, generator_flags,
                                                     gyp_file)
 
   # Add rules.
   actions_to_add = {}
   _GenerateRulesForMSVS(p, project_dir, options, spec,
                         sources, excluded_sources,
                         actions_to_add)
   list_excluded = generator_flags.get('msvs_list_excluded_files', True)
-  sources, excluded_sources, excluded_idl = (
+  sources, excluded_sources, excluded_custom_files = (
       _AdjustSourcesAndConvertToFilterHierarchy(
           spec, options, project_dir, sources, excluded_sources, list_excluded))
 
   # Add in files.
   missing_sources = _VerifySourcesExist(sources, project_dir)
   p.AddFiles(sources)
 
   _AddToolFilesToMSVS(p, spec)
   _HandlePreCompiledHeaders(p, sources, spec)
   _AddActions(actions_to_add, spec, relative_path_of_gyp_file)
   _AddCopies(actions_to_add, spec)
   _WriteMSVSUserFile(project.path, version, spec)
 
   # NOTE: this stanza must appear after all actions have been decided.
   # Don't excluded sources with actions attached, or they won't run.
   excluded_sources = _FilterActionsFromExcluded(
       excluded_sources, actions_to_add)
-  _ExcludeFilesFromBeingBuilt(p, spec, excluded_sources, excluded_idl,
+  _ExcludeFilesFromBeingBuilt(p, spec, excluded_sources, excluded_custom_files,
                               list_excluded)
   _AddAccumulatedActionsToMSVS(p, spec, actions_to_add)
 
   # Write it out.
   p.WriteIfChanged()
 
   return missing_sources
 
 
 def _GetUniquePlatforms(spec):
@@ skipping 68 matching lines @@
 
   Arguments:
     p: The target project being generated.
     spec: The target dictionary containing the properties of the target.
     config_type: The configuration type, a number as defined by Microsoft.
     config_name: The name of the configuration.
     config: The dictionnary that defines the special processing to be done
             for this configuration.
   """
   # Get the information for this configuration
-  include_dirs, resource_include_dirs = _GetIncludeDirs(config)
+  include_dirs, resource_include_dirs, _ = _GetIncludeDirs(config)
   libraries = _GetLibraries(spec)
   out_file, vc_tool, _ = _GetOutputFilePathAndTool(spec, msbuild=False)
   defines = _GetDefines(config)
   defines = [_EscapeCppDefineForMSVS(d) for d in defines]
   disabled_warnings = _GetDisabledWarnings(config)
   prebuild = config.get('msvs_prebuild')
   postbuild = config.get('msvs_postbuild')
   def_file = _GetModuleDefinition(spec)
   precompiled_header = config.get('msvs_precompiled_header')
 
@@ skipping 48 matching lines @@
   _AddConfigurationToMSVS(p, spec, tools, config, config_type, config_name)
 
 
 def _GetIncludeDirs(config):
   """Returns the list of directories to be used for #include directives.
 
   Arguments:
     config: The dictionnary that defines the special processing to be done
             for this configuration.
   Returns:
-    The list of directory paths.
+    A triple of (C++ include directory paths, Resource Compiler include
+        directory paths, MASM inclue directory paths)

[scottmg, 2013/01/03 03:36:40]

inclue

   """
   # TODO(bradnelson): include_dirs should really be flexible enough not to
   #                   require this sort of thing.
   include_dirs = (
       config.get('include_dirs', []) +
       config.get('msvs_system_include_dirs', []))
   resource_include_dirs = config.get('resource_include_dirs', include_dirs)
+  masm_include_dirs = config.get('masm_include_dirs', include_dirs)
   include_dirs = _FixPaths(include_dirs)
   resource_include_dirs = _FixPaths(resource_include_dirs)
-  return include_dirs, resource_include_dirs
+  masm_include_dirs = _FixPaths(masm_include_dirs)
+  return include_dirs, resource_include_dirs, masm_include_dirs
 
 
 def _GetLibraries(spec):
   """Returns the list of libraries for this configuration.
 
   Arguments:
     spec: The target dictionary containing the properties of the target.
   Returns:
     The list of directory paths.
   """
@@ skipping 212 matching lines @@
   Also converts the sets to lists.
 
   Arguments:
     spec: The target dictionary containing the properties of the target.
     options: Global generator options.
     gyp_dir: The path to the gyp file being processed.
     sources: A set of sources to be included for this project.
     excluded_sources: A set of sources to be excluded for this project.
   Returns:
     A trio of (list of sources, list of excluded sources,
-               path of excluded IDL file)
+               path of excluded files being handled by non-MSVS-native rules)
   """
   # Exclude excluded sources coming into the generator.
   excluded_sources.update(set(spec.get('sources_excluded', [])))
   # Add excluded sources into sources for good measure.
   sources.update(excluded_sources)
   # Convert to proper windows form.
   # NOTE: sources goes from being a set to a list here.
   # NOTE: excluded_sources goes from being a set to a list here.
   sources = _FixPaths(sources)
   # Convert to proper windows form.
   excluded_sources = _FixPaths(excluded_sources)
 
-  excluded_idl = _IdlFilesHandledNonNatively(spec, sources)
+  excluded_custom_files = _FilesHandledNonNatively(spec, sources)
 
   precompiled_related = _GetPrecompileRelatedFiles(spec)
   # Find the excluded ones, minus the precompiled header related ones.
   fully_excluded = [i for i in excluded_sources if i not in precompiled_related]
 
   # Convert to folders and the right slashes.
   sources = [i.split('\\') for i in sources]
   sources = _ConvertSourcesToFilterHierarchy(sources, excluded=fully_excluded,
                                              list_excluded=list_excluded)
 
-  return sources, excluded_sources, excluded_idl
+  return sources, excluded_sources, excluded_custom_files
 
 
-def _IdlFilesHandledNonNatively(spec, sources):
-  # If any non-native rules use 'idl' as an extension exclude idl files.
+def _FilesHandledNonNatively(spec, sources):
+  # If any non-native rules exist for extensions normally handled by MSVS, such
+  # as .idl or .asm, then exclude files with those extensions.
   # Gather a list here to use later.
-  using_idl = False
-  for rule in spec.get('rules', []):
-    if rule['extension'] == 'idl' and int(rule.get('msvs_external_rule', 0)):
-      using_idl = True
-      break
-  if using_idl:
-    excluded_idl = [i for i in sources if i.endswith('.idl')]
-  else:
-    excluded_idl = []
-  return excluded_idl
+  excluded_files = []
+  for extension in ['idl', 'asm']:
+    using_custom_rule = False
+    for rule in spec.get('rules', []):
+      if (rule['extension'] == extension and
+          int(rule.get('msvs_external_rule', 0))):
+        using_custom_rule = True
+        break
+    if using_custom_rule:
+      excluded_files.extend([i for i in sources if i.endswith('.' + extension)])
+  return excluded_files
 
 
 def _GetPrecompileRelatedFiles(spec):
   # Gather a list of precompiled header related sources.
   precompiled_related = []
   for _, config in spec['configurations'].iteritems():
     for k in precomp_keys:
       f = config.get(k)
       if f:
         precompiled_related.append(_FixPath(f))
   return precompiled_related
 
 
-def _ExcludeFilesFromBeingBuilt(p, spec, excluded_sources, excluded_idl,
-                                list_excluded):
-  exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl)
+def _ExcludeFilesFromBeingBuilt(p, spec, excluded_sources,
+                                excluded_custom_files, list_excluded):
+  exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources,
+                                          excluded_custom_files)
   for file_name, excluded_configs in exclusions.iteritems():
     if (not list_excluded and
             len(excluded_configs) == len(spec['configurations'])):
       # If we're not listing excluded files, then they won't appear in the
       # project, so don't try to configure them to be excluded.
       pass
     else:
       for config_name, config in excluded_configs:
         p.AddFileConfig(file_name, _ConfigFullName(config_name, config),
                         {'ExcludedFromBuild': 'true'})
 
 
-def _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl):
+def _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_custom_files):
   exclusions = {}
   # Exclude excluded sources from being built.
   for f in excluded_sources:
     excluded_configs = []
     for config_name, config in spec['configurations'].iteritems():
       precomped = [_FixPath(config.get(i, '')) for i in precomp_keys]
       # Don't do this for ones that are precompiled header related.
       if f not in precomped:
         excluded_configs.append((config_name, config))
     exclusions[f] = excluded_configs
   # If any non-native rules use 'idl' as an extension exclude idl files.
   # Exclude them now.
-  for f in excluded_idl:
+  for f in excluded_custom_files:
     excluded_configs = []
     for config_name, config in spec['configurations'].iteritems():
       excluded_configs.append((config_name, config))
     exclusions[f] = excluded_configs
   return exclusions
 
 
 def _AddToolFilesToMSVS(p, spec):
   # Add in tool files (rules).
   tool_files = set()
@@ skipping 532 matching lines @@
     element = 'ClCompile'
   elif ext in ['.h', '.hxx']:
     group = 'include'
     element = 'ClInclude'
   elif ext == '.rc':
     group = 'resource'
     element = 'ResourceCompile'
   elif ext == '.idl':
     group = 'midl'
     element = 'Midl'
+  elif ext == '.asm':
+    group = 'masm'
+    element = 'MASM'
   else:
     group = 'none'
     element = 'None'
   return (group, element)
 
 
 def _GenerateRulesForMSBuild(output_dir, options, spec,
                              sources, excluded_sources,
                              props_files_of_rules, targets_files_of_rules,
                              actions_to_add, extension_to_rule_name):
@@ skipping 787 matching lines @@
 
 def _FinalizeMSBuildSettings(spec, configuration):
   if 'msbuild_settings' in configuration:
     converted = False
     msbuild_settings = configuration['msbuild_settings']
     MSVSSettings.ValidateMSBuildSettings(msbuild_settings)
   else:
     converted = True
     msvs_settings = configuration.get('msvs_settings', {})
     msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(msvs_settings)
-  include_dirs, resource_include_dirs = _GetIncludeDirs(configuration)
+  include_dirs, resource_include_dirs, masm_include_dirs = \
+      _GetIncludeDirs(configuration)
   libraries = _GetLibraries(spec)
   out_file, _, msbuild_tool = _GetOutputFilePathAndTool(spec, msbuild=True)
   defines = _GetDefines(configuration)
   if converted:
     # Visual Studio 2010 has TR1
     defines = [d for d in defines if d != '_HAS_TR1=0']
     # Warn of ignored settings
     ignored_settings = ['msvs_prebuild', 'msvs_postbuild', 'msvs_tool_files']
     for ignored_setting in ignored_settings:
       value = configuration.get(ignored_setting)
@@ skipping 10 matching lines @@
   precompiled_header = configuration.get('msvs_precompiled_header')
 
   # Add the information to the appropriate tool
   # TODO(jeanluc) We could optimize and generate these settings only if
   # the corresponding files are found, e.g. don't generate ResourceCompile
   # if you don't have any resources.
   _ToolAppend(msbuild_settings, 'ClCompile',
               'AdditionalIncludeDirectories', include_dirs)
   _ToolAppend(msbuild_settings, 'ResourceCompile',
               'AdditionalIncludeDirectories', resource_include_dirs)
+  _ToolAppend(msbuild_settings, 'MASM',
+              'AdditionalIncludeDirectories', masm_include_dirs)
   # Add in libraries.
   _ToolAppend(msbuild_settings, 'Link', 'AdditionalDependencies', libraries)
   if out_file:
     _ToolAppend(msbuild_settings, msbuild_tool, 'OutputFile', out_file,
                 only_if_unset=True)
   # Add defines.
   _ToolAppend(msbuild_settings, 'ClCompile',
               'PreprocessorDefinitions', defines)
   _ToolAppend(msbuild_settings, 'ResourceCompile',
               'PreprocessorDefinitions', defines)
+  _ToolAppend(msbuild_settings, 'MASM',
+              'PreprocessorDefinitions', defines)
   # Add disabled warnings.
   _ToolAppend(msbuild_settings, 'ClCompile',
               'DisableSpecificWarnings', disabled_warnings)
   # Turn on precompiled headers if appropriate.
   if precompiled_header:
     precompiled_header = os.path.split(precompiled_header)[1]
     _ToolAppend(msbuild_settings, 'ClCompile', 'PrecompiledHeader', 'Use')
     _ToolAppend(msbuild_settings, 'ClCompile',
                 'PrecompiledHeaderFile', precompiled_header)
     _ToolAppend(msbuild_settings, 'ClCompile',
@@ skipping 57 matching lines @@
     else:
       if '$' not in source:
         full_path = os.path.join(root_dir, source)
         if not os.path.exists(full_path):
           missing_sources.append(full_path)
   return missing_sources
 
 
 def _GetMSBuildSources(spec, sources, exclusions, extension_to_rule_name,
                        actions_spec, sources_handled_by_action, list_excluded):
-  groups = ['none', 'midl', 'include', 'compile', 'resource', 'rule']
+  groups = ['none', 'midl', 'masm', 'include', 'compile', 'resource', 'rule']
   grouped_sources = {}
   for g in groups:
     grouped_sources[g] = []
 
   _AddSources2(spec, sources, exclusions, grouped_sources,
                extension_to_rule_name, sources_handled_by_action, list_excluded)
   sources = []
   for g in groups:
     if grouped_sources[g]:
       sources.append(['ItemGroup'] + grouped_sources[g])
@@ skipping 97 matching lines @@
   # Add rules.
   actions_to_add = {}
   props_files_of_rules = set()
   targets_files_of_rules = set()
   extension_to_rule_name = {}
   list_excluded = generator_flags.get('msvs_list_excluded_files', True)
   _GenerateRulesForMSBuild(project_dir, options, spec,
                            sources, excluded_sources,
                            props_files_of_rules, targets_files_of_rules,
                            actions_to_add, extension_to_rule_name)
-  sources, excluded_sources, excluded_idl = (
+  sources, excluded_sources, excluded_custom_files = (
       _AdjustSourcesAndConvertToFilterHierarchy(spec, options,
                                                 project_dir, sources,
                                                 excluded_sources,
                                                 list_excluded))
   _AddActions(actions_to_add, spec, project.build_file)
   _AddCopies(actions_to_add, spec)
 
   # NOTE: this stanza must appear after all actions have been decided.
   # Don't excluded sources with actions attached, or they won't run.
   excluded_sources = _FilterActionsFromExcluded(
       excluded_sources, actions_to_add)
 
-  exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources, excluded_idl)
+  exclusions = _GetExcludedFilesFromBuild(spec, excluded_sources,
+                                          excluded_custom_files)
   actions_spec, sources_handled_by_action = _GenerateActionsForMSBuild(
       spec, actions_to_add)
 
   _GenerateMSBuildFiltersFile(project.path + '.filters', sources,
                               extension_to_rule_name)
   missing_sources = _VerifySourcesExist(sources, project_dir)
 
   for configuration in configurations.itervalues():
     _FinalizeMSBuildSettings(spec, configuration)
 
@@ skipping 38 matching lines @@
 
   easy_xml.WriteXmlIfChanged(content, project.path, pretty=True, win32=True)
 
   return missing_sources
 
 
 def _GetMSBuildExtensions(props_files_of_rules):
   extensions = ['ImportGroup', {'Label': 'ExtensionSettings'}]
   for props_file in props_files_of_rules:
     extensions.append(['Import', {'Project': props_file}])
+  extensions.append(
+    ['Import', {'Project':
+                r'$(VCTargetsPath)\BuildCustomizations\masm.props'}])
   return [extensions]
 
 
 def _GetMSBuildExtensionTargets(targets_files_of_rules):
   targets_node = ['ImportGroup', {'Label': 'ExtensionTargets'}]
   for targets_file in sorted(targets_files_of_rules):
     targets_node.append(['Import', {'Project': targets_file}])
+  targets_node.append(
+    ['Import', {'Project':
+                r'$(VCTargetsPath)\BuildCustomizations\masm.targets'}])
   return [targets_node]
 
 
 def _GenerateActionsForMSBuild(spec, actions_to_add):
   """Add actions accumulated into an actions_to_add, merging as needed.
 
   Arguments:
     spec: the target project dict
     actions_to_add: dictionary keyed on input name, which maps to a list of
         dicts describing the actions attached to that input file.
@@ skipping 54 matching lines @@
   action_spec.extend(
       # TODO(jeanluc) 'Document' for all or just if as_sources?
       [['FileType', 'Document'],
        ['Command', command],
        ['Message', description],
        ['Outputs', outputs]
       ])
   if additional_inputs:
     action_spec.append(['AdditionalInputs', additional_inputs])
   actions_spec.append(action_spec)