Add support for MIDL include directories

pylib/gyp/generator/msvs.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 ntpath
 import os
 import posixpath
 import re
 import subprocess
@@ skipping 1088 matching lines @@
 
   Arguments:
     p: The target project being generated.
     spec: The target dictionary containing the properties of the target.
     config_type: The configuration type, a number as defined by Microsoft.
     config_name: The name of the configuration.
     config: The dictionary that defines the special processing to be done
             for this configuration.
   """
   # Get the information for this configuration
-  include_dirs, resource_include_dirs = _GetIncludeDirs(config)
+  include_dirs, midl_include_dirs, resource_include_dirs = \
+      _GetIncludeDirs(config)
   libraries = _GetLibraries(spec)
   library_dirs = _GetLibraryDirs(config)
   out_file, vc_tool, _ = _GetOutputFilePathAndTool(spec, msbuild=False)
   defines = _GetDefines(config)
   defines = [_EscapeCppDefineForMSVS(d) for d in defines]
   disabled_warnings = _GetDisabledWarnings(config)
   prebuild = config.get('msvs_prebuild')
   postbuild = config.get('msvs_postbuild')
   def_file = _GetModuleDefinition(spec)
   precompiled_header = config.get('msvs_precompiled_header')
 
   # Prepare the list of tools as a dictionary.
   tools = dict()
   # Add in user specified msvs_settings.
   msvs_settings = config.get('msvs_settings', {})
   MSVSSettings.ValidateMSVSSettings(msvs_settings)
 
   # Prevent default library inheritance from the environment.
   _ToolAppend(tools, 'VCLinkerTool', 'AdditionalDependencies', ['$(NOINHERIT)'])
 
   for tool in msvs_settings:
     settings = config['msvs_settings'][tool]
     for setting in settings:
       _ToolAppend(tools, tool, setting, settings[setting])
   # Add the information to the appropriate tool
   _ToolAppend(tools, 'VCCLCompilerTool',
               'AdditionalIncludeDirectories', include_dirs)
+  _ToolAppend(tools, 'VCMIDLTool',
+              'AdditionalIncludeDirectories', midl_include_dirs)
   _ToolAppend(tools, 'VCResourceCompilerTool',
               'AdditionalIncludeDirectories', resource_include_dirs)
   # Add in libraries.
   _ToolAppend(tools, 'VCLinkerTool', 'AdditionalDependencies', libraries)
   _ToolAppend(tools, 'VCLinkerTool', 'AdditionalLibraryDirectories',
               library_dirs)
   if out_file:
     _ToolAppend(tools, vc_tool, 'OutputFile', out_file, only_if_unset=True)
   # Add defines.
   _ToolAppend(tools, 'VCCLCompilerTool', 'PreprocessorDefinitions', defines)
@@ skipping 35 matching lines @@
     config: The dictionary that defines the special processing to be done
             for this configuration.
   Returns:
     The list of directory paths.
   """
   # TODO(bradnelson): include_dirs should really be flexible enough not to
   #                   require this sort of thing.
   include_dirs = (
       config.get('include_dirs', []) +
       config.get('msvs_system_include_dirs', []))
+  midl_include_dirs = config.get('midl_include_dirs', [])

[scottmg, 2014/09/25 16:53:10]

should msvs_system_include_dirs be included here for the common ones like
ObjIdl.idl, etc?

[Shezan Baig (Bloomberg), 2014/09/25 17:00:21]

Hmm, I didn't seem to need it in my test.  I can add it though, if you think it
is required.

[scottmg, 2014/09/25 17:05:31]

I think by default midl uses cl /E, which means it uses %INCLUDE% which is
probably set to include the system dirs on the bots
http://msdn.microsoft.com/en-us/library/windows/desktop/aa367299(v=vs.85).aspx

But, in general, it wouldn't have to be (and I know Nico had to do ... something
with the clang-win build because of Chrome's non-system toolchain install)

So, I think it would be sensible to include it in that list, if it doesn't cause
any problems.

[Shezan Baig (Bloomberg), 2014/09/25 17:15:59]

Sounds good -- I've uploaded a new patch.  I copied exactly how 'include_dirs'
is initialized, replacing 'include_dirs' with 'midl_include_dirs'

   resource_include_dirs = config.get('resource_include_dirs', include_dirs)
   include_dirs = _FixPaths(include_dirs)
+  midl_include_dirs = _FixPaths(midl_include_dirs)
   resource_include_dirs = _FixPaths(resource_include_dirs)
-  return include_dirs, resource_include_dirs
+  return include_dirs, midl_include_dirs, resource_include_dirs
 
 
 def _GetLibraryDirs(config):
   """Returns the list of directories to be used for library search paths.
 
   Arguments:
     config: The dictionary that defines the special processing to be done
             for this configuration.
   Returns:
     The list of directory paths.
@@ skipping 1701 matching lines @@
 
 def _FinalizeMSBuildSettings(spec, configuration):
   if 'msbuild_settings' in configuration:
     converted = False
     msbuild_settings = configuration['msbuild_settings']
     MSVSSettings.ValidateMSBuildSettings(msbuild_settings)
   else:
     converted = True
     msvs_settings = configuration.get('msvs_settings', {})
     msbuild_settings = MSVSSettings.ConvertToMSBuildSettings(msvs_settings)
-  include_dirs, resource_include_dirs = _GetIncludeDirs(configuration)
+  include_dirs, midl_include_dirs, resource_include_dirs = \
+      _GetIncludeDirs(configuration)
   libraries = _GetLibraries(spec)
   library_dirs = _GetLibraryDirs(configuration)
   out_file, _, msbuild_tool = _GetOutputFilePathAndTool(spec, msbuild=True)
   target_ext = _GetOutputTargetExt(spec)
   defines = _GetDefines(configuration)
   if converted:
     # Visual Studio 2010 has TR1
     defines = [d for d in defines if d != '_HAS_TR1=0']
     # Warn of ignored settings
     ignored_settings = ['msvs_tool_files']
     for ignored_setting in ignored_settings:
       value = configuration.get(ignored_setting)
       if value:
         print ('Warning: The automatic conversion to MSBuild does not handle '
                '%s.  Ignoring setting of %s' % (ignored_setting, str(value)))
 
   defines = [_EscapeCppDefineForMSBuild(d) for d in defines]
   disabled_warnings = _GetDisabledWarnings(configuration)
   prebuild = configuration.get('msvs_prebuild')
   postbuild = configuration.get('msvs_postbuild')
   def_file = _GetModuleDefinition(spec)
   precompiled_header = configuration.get('msvs_precompiled_header')
 
   # Add the information to the appropriate tool
   # TODO(jeanluc) We could optimize and generate these settings only if
   # the corresponding files are found, e.g. don't generate ResourceCompile
   # if you don't have any resources.
   _ToolAppend(msbuild_settings, 'ClCompile',
               'AdditionalIncludeDirectories', include_dirs)
+  _ToolAppend(msbuild_settings, 'Midl',
+              'AdditionalIncludeDirectories', midl_include_dirs)
   _ToolAppend(msbuild_settings, 'ResourceCompile',
               'AdditionalIncludeDirectories', resource_include_dirs)
   # Add in libraries, note that even for empty libraries, we want this
   # set, to prevent inheriting default libraries from the enviroment.
   _ToolSetOrAppend(msbuild_settings, 'Link', 'AdditionalDependencies',
                   libraries)
   _ToolAppend(msbuild_settings, 'Link', 'AdditionalLibraryDirectories',
               library_dirs)
   if out_file:
     _ToolAppend(msbuild_settings, msbuild_tool, 'OutputFile', out_file,
@@ skipping 398 matching lines @@
   action_spec.extend(
       # TODO(jeanluc) 'Document' for all or just if as_sources?
       [['FileType', 'Document'],
        ['Command', command],
        ['Message', description],
        ['Outputs', outputs]
       ])
   if additional_inputs:
     action_spec.append(['AdditionalInputs', additional_inputs])
   actions_spec.append(action_spec)