ninja windows: Support magic idl build rules

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 112 matching lines @@
 
     self.msvs_cygwin_dirs = spec.get('msvs_cygwin_dirs', ['.'])
 
   def ConvertVSMacros(self, s):
     """Convert from VS macro names to something equivalent."""
     if '$' in s:
       replacements = {
           '$(VSInstallDir)': self.vs_version.Path(),
           '$(VCInstallDir)': os.path.join(self.vs_version.Path(), 'VC'),
           '$(OutDir)\\': '',
+          '$(IntDir)': '$!INTERMEDIATE_DIR',
+          '$(InputName)': '${root}',
       }
       dxsdk_dir = os.environ.get('DXSDK_DIR')
       if dxsdk_dir:
         replacements['$(DXSDK_DIR)'] = dxsdk_dir + '\\'
       for old, new in replacements.iteritems():
         s = s.replace(old, new)
     return s
 
   def AdjustLibraries(self, libraries):
     """Strip -l from library if it's specified with that."""
     return [lib[2:] if lib.startswith('-l') else lib for lib in libraries]
 
   def _GetAndMunge(self, field, path, default, prefix, append, map):
     """Retrieve a value from |field| at |path| or return |default|. If
     |append| is specified, and the item is found, it will be appended to that
     object instead of returned. If |map| is specified, results will be
     remapped through |map| before being returned or appended."""
     result = _GenericRetrieve(field, default, path)
     result = _DoRemapping(result, map)
     result = _AddPrefix(result, prefix)
     return _AppendOrReturn(append, result)
 
   class _GetWrapper(object):
     def __init__(self, parent, field, base_path, append=None):
       self.parent = parent
       self.field = field
       self.base_path = [base_path]
       self.append = append
-    def __call__(self, name, map=None, prefix=''):
+    def __call__(self, name, map=None, prefix='', default=None):
       return self.parent._GetAndMunge(self.field, self.base_path + [name],
-          default=None, prefix=prefix, append=self.append, map=map)
+          default=default, prefix=prefix, append=self.append, map=map)
 
   def _Setting(self, path, config,
               default=None, prefix='', append=None, map=None):
     """_GetAndMunge for msvs_settings."""
     return self._GetAndMunge(
         self.msvs_settings[config], path, default, prefix, append, map)
 
   def _ConfigAttrib(self, path, config,
                    default=None, prefix='', append=None, map=None):
     """_GetAndMunge for msvs_configuration_attributes."""
@@ skipping 145 matching lines @@
         'call "%s\\setup_env.bat" && set CYGWIN=nontsec && ' % cygwin_dir +
         'bash -c "%s ; %s"' % (cd, bash_cmd))
     return cmd
 
   def IsRuleRunUnderCygwin(self, rule):
     """Determine if an action should be run under cygwin. If the variable is
     unset, or set to 1 we use cygwin."""
     return int(rule.get('msvs_cygwin_shell',
                         self.spec.get('msvs_cygwin_shell', 1))) != 0
 
+  def HasExplicitIdlRules(self, spec):
+    """Determine if there's an explicit rule for idl files. When there isn't we
+    need to generate implicit rules to build MIDL .idl files."""
+    for rule in spec.get('rules', []):
+      if rule['extension'] == 'idl' and int(rule.get('msvs_external_rule', 0)):
+        return True
+    return False
+
+  def GetIdlBuildData(self, source, config):
+    """Determine the implicit outputs for an idl file. Returns output
+    directory, outputs, and variables and flags that are required."""
+    midl_get = self._GetWrapper(self, self.msvs_settings[config], 'VCMIDLTool')
+    def midl(name, default=None):
+      return self.ConvertVSMacros(midl_get(name, default=default))
+    tlb = midl('TypeLibraryName', default='${root}.tlb')
+    header = midl('HeaderFileName', default='${root}.h')
+    dlldata = midl('DLLDataFileName', default='dlldata.c')
+    iid = midl('InterfaceIdentifierFileName', default='${root}_i.c')
+    proxy = midl('ProxyFileName', default='${root}_p.c')
+    # Note that .tlb is not included in the outputs as it is not always
+    # generated depending on the content of the input idl file.
+    outdir = midl('OutputDirectory')
+    output = [header, dlldata, iid, proxy]
+    variables = [('tlb', tlb),
+                 ('h', header),
+                 ('dlldata', dlldata),
+                 ('iid', iid),
+                 ('proxy', proxy)]
+    # TODO(scottmg): Non-default configuration maybe?
+    flags = ['/char', 'signed', '/env', 'win32', '/Oicf']
+    return outdir, output, variables, flags
+
 vs_version = None
 def GetVSVersion(generator_flags):
   global vs_version
   if not vs_version:
     vs_version = gyp.MSVSVersion.SelectVisualStudioVersion(
         generator_flags.get('msvs_version', 'auto'))
   return vs_version
 
 def _GetBinaryPath(generator_flags, tool):
   vs = GetVSVersion(generator_flags)
   return ('"' +
           os.path.normpath(os.path.join(vs.Path(), "VC/bin", tool)) +
           '"')
 
 def GetCLPath(generator_flags):
   return _GetBinaryPath(generator_flags, 'cl.exe')
 
 def GetLinkPath(generator_flags):
   return _GetBinaryPath(generator_flags, 'link.exe')
 
 def GetLibPath(generator_flags):
   return _GetBinaryPath(generator_flags, 'lib.exe')
 
 def GetMidlPath(generator_flags):
   return _GetBinaryPath(generator_flags, 'midl.exe')