Add Ninja support for MSVS $(TargetExt), $(TargetFileName) and $(TargetPath) macros.

pylib/gyp/msvs_emulation.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.
 
 """
 This module helps emulate Visual Studio 2008 behavior on top of other
 build systems, primarily ninja.
 """
 
 import os
@@ skipping 167 matching lines @@
       new_includes = [i for i in includes if i not in all_system_includes]
       config['msvs_system_include_dirs'] = new_includes
   return expanded_system_includes
 
 
 class MsvsSettings(object):
   """A class that understands the gyp 'msvs_...' values (especially the
   msvs_settings field). They largely correpond to the VS2008 IDE DOM. This
   class helps map those settings to command line options."""
 
+  # A dictionary of default target extensions by type.

[scottmg, 2014/10/03 22:19:59]

this is very similar to MSVSUtil.py, could it reuse that instead?

[chrisha, 2014/10/06 13:40:49]

Indeed it is. Removed it from here, and reused the MSVSUtil.TARGET_TYPE_EXT.
Also replaced another similar dictionary being used in the ninja generator.

+  _DEFAULT_EXTENSIONS_BY_TYPE = {
+    'loadable_module': 'dll',
+    'shared_library': 'dll',
+    'static_library': 'lib',
+    'executable': 'exe',
+  }
+
   def __init__(self, spec, generator_flags):
     self.spec = spec
     self.vs_version = GetVSVersion(generator_flags)
 
     supported_fields = [
         ('msvs_configuration_attributes', dict),
         ('msvs_settings', dict),
         ('msvs_system_include_dirs', list),
         ('msvs_disabled_warnings', list),
         ('msvs_precompiled_header', str),
@@ skipping 15 matching lines @@
     ]
     unsupported = []
     for field in unsupported_fields:
       for config in configs.values():
         if field in config:
           unsupported += ["%s not supported (target %s)." %
                           (field, spec['target_name'])]
     if unsupported:
       raise Exception('\n'.join(unsupported))
 
+  def GetExtension(self):
+    """Returns the extension for the target, with no leading dot.
+
+    Uses 'product_extension' if specified, otherwise uses MSVS defaults based on
+    the target type.
+    """
+    ext = self.spec.get('product_extension', None)
+    if ext:
+      return ext
+    return self._DEFAULT_EXTENSIONS_BY_TYPE.get(self.spec['type'], '')
+
   def GetVSMacroEnv(self, base_to_build=None, config=None):
     """Get a dict of variables mapping internal VS macro names to their gyp
     equivalents."""
     target_platform = 'Win32' if self.GetArch(config) == 'x86' else 'x64'
     target_name = self.spec.get('product_prefix', '') + \
         self.spec.get('product_name', self.spec['target_name'])
     target_dir = base_to_build + '\\' if base_to_build else ''
+    target_ext = '.' + self.GetExtension()
+    target_file_name = target_name + target_ext
+
     replacements = {
+        '$(InputName)': '${root}',
+        '$(InputPath)': '${source}',
+        '$(IntDir)': '$!INTERMEDIATE_DIR',
         '$(OutDir)\\': target_dir,
-        '$(TargetDir)\\': target_dir,
-        '$(IntDir)': '$!INTERMEDIATE_DIR',
-        '$(InputPath)': '${source}',
-        '$(InputName)': '${root}',
-        '$(ProjectName)': self.spec['target_name'],
-        '$(TargetName)': target_name,
         '$(PlatformName)': target_platform,
         '$(ProjectDir)\\': '',
+        '$(ProjectName)': self.spec['target_name'],
+        '$(TargetDir)\\': target_dir,
+        '$(TargetExt)': target_ext,
+        '$(TargetFileName)': target_file_name,
+        '$(TargetName)': target_name,
+        '$(TargetPath)': os.path.join(target_dir, target_file_name),
     }
     replacements.update(GetGlobalVSMacroEnv(self.vs_version))
     return replacements
 
   def ConvertVSMacros(self, s, base_to_build=None, config=None):
     """Convert from VS macro names to something equivalent."""
     env = self.GetVSMacroEnv(base_to_build, config=config)
     return ExpandMacros(s, env)
 
   def AdjustLibraries(self, libraries):
@@ skipping 779 matching lines @@
 
   # To determine processor word size on Windows, in addition to checking
   # PROCESSOR_ARCHITECTURE (which reflects the word size of the current
   # process), it is also necessary to check PROCESSOR_ARCHITEW6432 (which
   # contains the actual word size of the system when running thru WOW64).
   if ('64' in os.environ.get('PROCESSOR_ARCHITECTURE', '') or
       '64' in os.environ.get('PROCESSOR_ARCHITEW6432', '')):
     default_variables['MSVS_OS_BITS'] = 64
   else:
     default_variables['MSVS_OS_BITS'] = 32