ninja windows: support precompiled headers

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 359 matching lines @@
     # If we have actions/rules/copies, we depend directly on those, but
     # otherwise we depend on dependent target's actions/rules/copies etc.
     # We never need to explicitly depend on previous target's link steps,
     # because no compile ever depends on them.
     compile_depends_stamp = (self.target.actions_stamp or compile_depends)
 
     # Write out the compilation steps, if any.
     link_deps = []
     sources = spec.get('sources', []) + extra_sources
     if sources:
+      pch = None
+      if self.flavor == 'win':
+        pch = gyp.msvs_emulation.PrecompiledHeader(
+            self.msvs_settings, config_name, self.GypPathToNinja)
+      else:
+        pch = gyp.xcode_emulation.MacPrefixHeader(
+            self.xcode_settings, self.GypPathToNinja,
+            lambda path, lang: self.GypPathToUniqueOutput(path + '-' + lang))
       link_deps = self.WriteSources(
-          config_name, config, sources, compile_depends_stamp,
-          gyp.xcode_emulation.MacPrefixHeader(
-              self.xcode_settings, self.GypPathToNinja,
-              lambda path, lang: self.GypPathToUniqueOutput(path + '-' + lang)))
+          config_name, config, sources, compile_depends_stamp, pch)
       # Some actions/rules output 'sources' that are already object files.
       link_deps += [self.GypPathToNinja(f)
           for f in sources if f.endswith(self.obj_ext)]
 
     if self.flavor == 'win' and self.target.type == 'static_library':
       self.target.component_objs = link_deps
 
     # Write out a link step, if needed.
     output = None
     if link_deps or self.target.actions_stamp or actions_depends:
@@ skipping 279 matching lines @@
       cflags_objc = ['$cflags_c'] + \
                     self.xcode_settings.GetCflagsObjC(config_name)
       cflags_objcc = ['$cflags_cc'] + \
                      self.xcode_settings.GetCflagsObjCC(config_name)
     elif self.flavor == 'win':
       cflags = self.msvs_settings.GetCflags(config_name)
       cflags_c = self.msvs_settings.GetCflagsC(config_name)
       cflags_cc = self.msvs_settings.GetCflagsCC(config_name)
       extra_defines = self.msvs_settings.GetComputedDefines(config_name)
       self.WriteVariableList('pdbname', [self.name + '.pdb'])
+      self.WriteVariableList('pchprefix', [self.name])
     else:
       cflags = config.get('cflags', [])
       cflags_c = config.get('cflags_c', [])
       cflags_cc = config.get('cflags_cc', [])
 
     defines = config.get('defines', []) + extra_defines
     self.WriteVariableList('defines', [Define(d, self.flavor) for d in defines])
     if self.flavor == 'win':
       self.WriteVariableList('rcflags',
           [QuoteShellArgument(self.ExpandSpecial(f), self.flavor)
            for f in self.msvs_settings.GetRcflags(config_name)])
 
     include_dirs = config.get('include_dirs', [])
     if self.flavor == 'win':
       include_dirs = self.msvs_settings.AdjustIncludeDirs(include_dirs,
                                                           config_name)
     self.WriteVariableList('includes',
         [QuoteShellArgument('-I' + self.GypPathToNinja(i), self.flavor)
          for i in include_dirs])
 
-    pch_commands = precompiled_header.GetGchBuildCommands()
+    pch_commands = precompiled_header.GetPchBuildCommands()
     if self.flavor == 'mac':
       self.WriteVariableList('cflags_pch_c',
                              [precompiled_header.GetInclude('c')])
       self.WriteVariableList('cflags_pch_cc',
                              [precompiled_header.GetInclude('cc')])
       self.WriteVariableList('cflags_pch_objc',
                              [precompiled_header.GetInclude('m')])
       self.WriteVariableList('cflags_pch_objcc',
                              [precompiled_header.GetInclude('mm')])
 
@@ skipping 40 matching lines @@
     self.WritePchTargets(pch_commands)
 
     self.ninja.newline()
     return outputs
 
   def WritePchTargets(self, pch_commands):
     """Writes ninja rules to compile prefix headers."""
     if not pch_commands:
       return
 
-    for gch, lang_flag, lang, input in pch_commands:
+    for gch, lang_flag, lang, input, extra_variables in pch_commands:
       var_name = {
         'c': 'cflags_pch_c',
         'cc': 'cflags_pch_cc',
         'm': 'cflags_pch_objc',
         'mm': 'cflags_pch_objcc',
       }[lang]
 
       cmd = { 'c': 'cc', 'cc': 'cxx', 'm': 'objc', 'mm': 'objcxx', }.get(lang)
-      self.ninja.build(gch, cmd, input, variables=[(var_name, lang_flag)])
-
+      variables = [(var_name, lang_flag)]
+      variables += extra_variables

[Nico, 2012/05/25 22:35:39]

maybe:
variables = [(var_name, lang_flag)] + extra_variables

[scottmg, 2012/05/26 02:27:12]

Done.

+      self.ninja.build(gch, cmd, input, variables=variables)
 
   def WriteLink(self, spec, config_name, config, link_deps):
     """Write out a link step. Fills out target.binary. """
 
     command = {
       'executable':      'link',
       'loadable_module': 'solink_module',
       'shared_library':  'solink',
     }[spec['type']]
 
@@ skipping 496 matching lines @@
       depfile='$out.d')
     master_ninja.rule(
       'cxx',
       description='CXX $out',
       command=('$cxx -MMD -MF $out.d $defines $includes $cflags $cflags_cc '
               '$cflags_pch_cc -c $in -o $out'),
       depfile='$out.d')
   else:
     # TODO(scottmg): Requires fork of ninja for dependency and linking
     # support: https://github.com/sgraham/ninja
+    #
+    # Normally, we want to name the object file when we run compile step. This
+    # is done with /Fo. However, when compiling a precompiled header, the
+    # flag is /Fp, so override that in the pch compile step.
+    master_ninja.variable('outflag', '/Fo')
     master_ninja.rule(
       'cc',
       description='CC $out',
       command=('cmd /s /c "$cc /nologo /showIncludes '
                '@$out.rsp '
-               '$cflags_pch_c /c $in /Fo$out /Fd$pdbname '
+               '$cflags_pch_c /c $in $outflag$out $pchobj /Fd$pdbname '
                '| ninja-deplist-helper -r . -q -f cl -o $out.dl"'),
       deplist='$out.dl',
       rspfile='$out.rsp',
       rspfile_content='$defines $includes $cflags $cflags_c')
     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 '
+               '$cflags_pch_cc /c $in $outflag$out $pchobj /Fd$pdbname '
                '| ninja-deplist-helper -r . -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'))
@@ skipping 177 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)