ninja/win: Put common msvs_system_include_dirs into %INCLUDE%

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 879 matching lines @@
   return block
 
 def _ExtractCLPath(output_of_where):
   """Gets the path to cl.exe based on the output of calling the environment
   setup batch file, followed by the equivalent of `where`."""
   # Take the first line, as that's the first found in the PATH.
   for line in output_of_where.strip().splitlines():
     if line.startswith('LOC:'):
       return line[len('LOC:'):].strip()
 
-def GenerateEnvironmentFiles(toplevel_build_dir, generator_flags, open_out):
+def GenerateEnvironmentFiles(toplevel_build_dir, generator_flags,
+                             system_includes, open_out):
   """It's not sufficient to have the absolute path to the compiler, linker,
   etc. on Windows, as those tools rely on .dlls being in the PATH. We also
   need to support both x86 and x64 compilers within the same build (to support
   msvs_target_platform hackery). Different architectures require a different
   compiler binary, and different supporting environment variables (INCLUDE,
   LIB, LIBPATH). So, we extract the environment here, wrap all invocations
   of compiler tools (cl, link, lib, rc, midl, etc.) via win_tool.py which
   sets up the environment, and then we do not prefix the compiler with
   an absolute path, instead preferring something like "cl.exe" in the rule
   which will then run whichever the environment setup has put in the path.
@@ skipping 10 matching lines @@
   vs = GetVSVersion(generator_flags)
   cl_paths = {}
   for arch in archs:
     # Extract environment variables for subprocesses.
     args = vs.SetupScript(arch)
     args.extend(('&&', 'set'))
     popen = subprocess.Popen(
         args, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
     variables, _ = popen.communicate()
     env = _ExtractImportantEnvironment(variables)
+
+    # Inject system includes from gyp files into INCLUDE.
+    if system_includes:
+      system_includes = system_includes | set(env.get('INCLUDE', '').split(';'))

[scottmg, 2014/07/19 18:49:36]

i think order should be preserved (though i'm not sure what that means when
combining). mostly just that someone could prepend to INCLUDE to inject their
own blah.h i guess.

[Nico, 2014/07/19 23:05:35]

Changed everything to use OrderedDict

+      env['INCLUDE'] = ';'.join(system_includes)
+
     env_block = _FormatAsEnvironmentBlock(env)
     f = open_out(os.path.join(toplevel_build_dir, 'environment.' + arch), 'wb')
     f.write(env_block)
     f.close()
 
     # Find cl.exe location for this architecture.
     args = vs.SetupScript(arch)
     args.extend(('&&',
       'for', '%i', 'in', '(cl.exe)', 'do', '@echo', 'LOC:%~$PATH:i'))
     popen = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE)
@@ skipping 28 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