ninja windows: Make pch work on VS2012, and simplify implementation

pylib/gyp/generator/ninja.py

 # Copyright (c) 2013 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 hashlib
 import multiprocessing
 import os.path
 import re
 import signal
@@ skipping 400 matching lines @@
 
     # Write out the compilation steps, if any.
     link_deps = []
     sources = spec.get('sources', []) + extra_sources
     if sources:
       pch = None
       if self.flavor == 'win':
         gyp.msvs_emulation.VerifyMissingSources(
             sources, self.abs_build_dir, generator_flags, self.GypPathToNinja)
         pch = gyp.msvs_emulation.PrecompiledHeader(
-            self.msvs_settings, config_name, self.GypPathToNinja)
+            self.msvs_settings, config_name, self.GypPathToNinja,
+            self.GypPathToUniqueOutput, self.obj_ext)
       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, pch,
           case_sensitive_filesystem, spec)
       # 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)]
@@ skipping 382 matching lines @@
         # Ignore unhandled extensions.
         continue
       input = self.GypPathToNinja(source)
       output = self.GypPathToUniqueOutput(filename + obj_ext)
       # Ninja's depfile handling gets confused when the case of a filename
       # changes on a case-insensitive file system. To work around that, always
       # convert .o filenames to lowercase on such file systems. See
       # https://github.com/martine/ninja/issues/402 for details.
       if not case_sensitive_filesystem:
         output = output.lower()
       implicit = precompiled_header.GetObjDependencies([input], [output])

[Nico, 2013/01/23 21:43:35]

Ah, here. Thanks.

+      variables = []
+      if self.flavor == 'win':
+        variables, implicit, output = precompiled_header.GetFlagsModifications(
+            input, output, implicit, command, cflags_c, cflags_cc,
+            self.ExpandSpecial)
       self.ninja.build(output, command, input,
                        implicit=[gch for _, _, gch in implicit],
-                       order_only=predepends)
+                       order_only=predepends, variables=variables)
       outputs.append(output)
 
     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:
       var_name = {
         'c': 'cflags_pch_c',
         'cc': 'cflags_pch_cc',
         'm': 'cflags_pch_objc',
         'mm': 'cflags_pch_objcc',
       }[lang]
 
       map = { 'c': 'cc', 'cc': 'cxx', 'm': 'objc', 'mm': 'objcxx', }
-      if self.flavor == 'win':
-        map.update({'c': 'cc_pch', 'cc': 'cxx_pch'})
       cmd = map.get(lang)
       self.ninja.build(gch, cmd, input, variables=[(var_name, lang_flag)])
 
   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',
@@ skipping 587 matching lines @@
       description='CC $out',
       command=('$cc $defines $includes $cflags $cflags_c '
               '$cflags_pch_c -c $in -o $out'))
     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:
-    # Template for compile commands mostly shared between compiling files
-    # and generating PCH. In the case of PCH, the "output" is specified by /Fp
-    # rather than /Fo (for object files), but we still need to specify an /Fo
-    # when compiling PCH.
-    cc_template = ('ninja -t msvc -o $out -e $arch '
+    cc_command = ('ninja -t msvc -o $out -e $arch '
+                  '-- '
+                  '$cc /nologo /showIncludes /FC '
+                  '@$out.rsp /c $in /Fo$out /Fd$pdbname ')
+    cxx_command = ('ninja -t msvc -o $out -e $arch '
                    '-- '
-                   '$cc /nologo /showIncludes /FC '
-                   '@$out.rsp '
-                   '$cflags_pch_c /c $in %(outspec)s /Fd$pdbname ')
-    cxx_template = ('ninja -t msvc -o $out -e $arch '
-                    '-- '
-                    '$cxx /nologo /showIncludes /FC '
-                    '@$out.rsp '
-                    '$cflags_pch_cc /c $in %(outspec)s $pchobj /Fd$pdbname ')
+                   '$cxx /nologo /showIncludes /FC '
+                   '@$out.rsp /c $in /Fo$out /Fd$pdbname ')
     master_ninja.rule(
       'cc',
       description='CC $out',
-      command=cc_template % {'outspec': '/Fo$out'},
-      depfile='$out.d',
-      rspfile='$out.rsp',
-      rspfile_content='$defines $includes $cflags $cflags_c')
-    master_ninja.rule(
-      'cc_pch',
-      description='CC PCH $out',
-      command=cc_template % {'outspec': '/Fp$out /Fo$out.obj'},
+      command=cc_command,
       depfile='$out.d',
       rspfile='$out.rsp',
       rspfile_content='$defines $includes $cflags $cflags_c')
     master_ninja.rule(
       'cxx',
       description='CXX $out',
-      command=cxx_template % {'outspec': '/Fo$out'},
-      depfile='$out.d',
-      rspfile='$out.rsp',
-      rspfile_content='$defines $includes $cflags $cflags_cc')
-    master_ninja.rule(
-      'cxx_pch',
-      description='CXX PCH $out',
-      command=cxx_template % {'outspec': '/Fp$out /Fo$out.obj'},
+      command=cxx_command,
       depfile='$out.d',
       rspfile='$out.rsp',
       rspfile_content='$defines $includes $cflags $cflags_cc')
     master_ninja.rule(
       'idl',
       description='IDL $in',
       command=('%s gyp-win-tool midl-wrapper $arch $outdir '
                '$tlb $h $dlldata $iid $proxy $in '
                '$idlflags' % sys.executable))
     master_ninja.rule(
@@ skipping 284 matching lines @@
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
           pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)