ninja windows: Support magic idl build rules

pylib/gyp/generator/ninja.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 gyp
 import gyp.common
 import gyp.msvs_emulation
 import gyp.MSVSVersion
 import gyp.system_test
@@ skipping 366 matching lines @@
 
     if self.name != output and self.toolset == 'target':
       # Write a short name to build this target.  This benefits both the
       # "build chrome" case as well as the gyp tests, which expect to be
       # able to run actions and build libraries by their short name.
       self.ninja.build(self.name, 'phony', output)
 
     assert self.target.FinalOutput(), output
     return self.target
 
+  def _HandleIdlFiles(self, spec, prebuild):
+    """Visual Studio has implicit .idl build rules for MIDL files, but other

[Nico, 2012/04/05 04:37:11]

I'd make the docstring just """Writes rules for MSVC's implicit idl rules."""
and put the rest in a normal comment.

[scottmg, 2012/04/05 17:52:42]

Done.

+    projects (e.g., WebKit) use .idl of a different import format with custom
+    build rules. So, we only do the implicit rules if they're not overridden by
+    explicit rules."""

[Nico, 2012/04/05 04:37:11]

This function is fairly long and branchy. I find functions more readable when
all the things they do are at about the same level of abstraction, this is
currently not quite true for this one.

[scottmg, 2012/04/05 17:52:42]

True, improved-ish?

+    native_idl = True
+    for rule in spec.get('rules', []):
+      if rule['extension'] == 'idl' and int(rule.get('msvs_external_rule', 0)):
+        native_idl = False
+    if not native_idl:
+      return []

[Nico, 2012/04/05 04:37:11]

Maybe this could be

  if self.msvs_settings.HasExplicitIdlRules(spec.get('rules', [])):
    return []

[scottmg, 2012/04/05 17:52:42]

Done.

+    outputs = []
+    for source in spec['sources']:

[Nico, 2012/04/05 04:37:11]

Maybe

for source in filter(lambda x: x.endswith('.idl'), spec['sources']):

[scottmg, 2012/04/05 17:52:42]

Done.

+      dirname, basename = os.path.split(source)
+      root, ext = os.path.splitext(basename)
+      if ext == '.idl':
+        input = self.GypPathToNinja(source)
+        outdir, output, vars, flags = self.msvs_settings.GetIdlBuildData(
+            source, self.config_name)
+        outdir = self.GypPathToNinja(self.msvs_settings.ConvertVSMacros(outdir))
+        def fix_path(path, rel=None):
+          path = os.path.join(outdir, path)
+          path = self.ExpandRuleVariables(
+              path, root, dirname, source, ext, basename)
+          if rel:
+            path = os.path.relpath(path, rel)
+          return path
+        vars = [(name, fix_path(value, outdir)) for name, value in vars]
+        output = [fix_path(p) for p in output]
+        vars.append(('outdir', outdir))
+        vars.append(('idlflags', flags))
+        outputs.extend(output)
+        self.ninja.build(output, 'idl', input,
+            variables=vars, order_only=prebuild)
+    return outputs
+
   def WriteActionsRulesCopies(self, spec, extra_sources, prebuild,
                               mac_bundle_depends):
     """Write out the Actions, Rules, and Copies steps.  Return a path
     representing the outputs of these steps."""
     outputs = []
     extra_mac_bundle_resources = []
 
     if 'actions' in spec:
       outputs += self.WriteActions(spec['actions'], extra_sources, prebuild,
                                    extra_mac_bundle_resources)
     if 'rules' in spec:
       outputs += self.WriteRules(spec['rules'], extra_sources, prebuild,
                                  extra_mac_bundle_resources)
     if 'copies' in spec:
       outputs += self.WriteCopies(spec['copies'], prebuild)
 
+    if 'sources' in spec:
+      outputs += self._HandleIdlFiles(spec, prebuild)

[Nico, 2012/04/05 04:37:11]

For consistency with the rest of this function, WriteWinIdlFiles(). Only call if
flavor == win

[scottmg, 2012/04/05 17:52:42]

Done.

+
     stamp = self.WriteCollapsedDependencies('actions_rules_copies', outputs)
 
     if self.is_mac_bundle:
       mac_bundle_resources = spec.get('mac_bundle_resources', []) + \
                              extra_mac_bundle_resources
       self.WriteMacBundleResources(mac_bundle_resources, mac_bundle_depends)
       self.WriteMacInfoPlist(mac_bundle_depends)
 
     return stamp
 
@@ skipping 238 matching lines @@
       ext = ext[1:]
       if ext in ('cc', 'cpp', 'cxx'):
         command = 'cxx'
       elif ext in ('c', 's', 'S'):
         command = 'cc'
       elif self.flavor == 'mac' and ext == 'm':
         command = 'objc'
       elif self.flavor == 'mac' and ext == 'mm':
         command = 'objcxx'
       else:
-        # TODO: should we assert here on unexpected extensions?
+        # Ignore unhandled extensions.
         continue
       input = self.GypPathToNinja(source)
       output = self.GypPathToUniqueOutput(filename + self.obj_ext)
       implicit = precompiled_header.GetObjDependencies([input], [output])
       self.ninja.build(output, command, input,
                        implicit=[gch for _, _, gch in implicit],
                        order_only=predepends)
       outputs.append(output)
 
     self.WritePchTargets(pch_commands)
@@ skipping 505 matching lines @@
     master_ninja.rule(
       'cxx',
       description='CXX $out',
       command=('cmd /s /c "$cxx /nologo /showIncludes '
                '@$out.rsp '
                '$cflags_pch_cc /c $in /Fo$out /Fd$pdbname '
                '| ninja-deplist-helper -q -f cl -o $out.dl"'),
       deplist='$out.dl',
       rspfile='$out.rsp',
       rspfile_content='$defines $includes $cflags $cflags_cc')
+    master_ninja.rule(
+      'idl',
+      description='IDL $in',
+      command=('python gyp-win-tool midl-wrapper $outdir '
+               '$tlb $h $dlldata $iid $proxy $in '
+               '$idlflags'))
 
   if flavor != 'mac' and flavor != 'win':
     master_ninja.rule(
       'alink',
       description='AR $out',
       command='rm -f $out && $ar rcsT $out $in')
     master_ninja.rule(
       'solink',
       description='SOLINK $out',
       command=('$ld -shared $ldflags -o $out -Wl,-soname=$soname '
@@ skipping 155 matching lines @@
 
   user_config = params.get('generator_flags', {}).get('config', None)
   if user_config:
     GenerateOutputForConfig(target_list, target_dicts, data, params,
                             user_config)
   else:
     config_names = target_dicts[target_list[0]]['configurations'].keys()
     for config_name in config_names:
       GenerateOutputForConfig(target_list, target_dicts, data, params,
                               config_name)