Adds support for the library_dirs key, which appears in the documentation but was never actually im…

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 1013 matching lines @@
   """Adds a configuration to the MSVS project.
 
   Many settings in a vcproj file are specific to a configuration.  This
   function the main part of the vcproj file that's configuration specific.
 
   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 dictionnary that defines the special processing to be done
+    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)
   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, '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)
   _ToolAppend(tools, 'VCResourceCompilerTool', 'PreprocessorDefinitions',
               defines)
   # Change program database directory to prevent collisions.
   _ToolAppend(tools, 'VCCLCompilerTool', 'ProgramDataBaseFileName',
               '$(IntDir)$(ProjectName)\\vc80.pdb', only_if_unset=True)
   # Add disabled warnings.
@@ skipping 19 matching lines @@
   if def_file:
     _ToolAppend(tools, 'VCLinkerTool', 'ModuleDefinitionFile', def_file)
 
   _AddConfigurationToMSVS(p, spec, tools, config, config_type, config_name)
 
 
 def _GetIncludeDirs(config):
   """Returns the list of directories to be used for #include directives.
 
   Arguments:
-    config: The dictionnary that defines the special processing to be done
+    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', []))
   resource_include_dirs = config.get('resource_include_dirs', include_dirs)
   include_dirs = _FixPaths(include_dirs)
   resource_include_dirs = _FixPaths(resource_include_dirs)
   return 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.
+  """
+
+  library_dirs = config.get('library_dirs', [])
+  library_dirs = _FixPaths(library_dirs)
+  return library_dirs
+
+
 def _GetLibraries(spec):
   """Returns the list of libraries for this configuration.
 
   Arguments:
     spec: The target dictionary containing the properties of the target.
   Returns:
     The list of directory paths.
   """
   libraries = spec.get('libraries', [])
   # Strip out -l, as it is not used on windows (but is needed so we can pass
@@ skipping 48 matching lines @@
     prefix = spec.get('product_prefix', '')
     product_name = spec.get('product_name', '$(ProjectName)')
     out_file = ntpath.join(out_dir, prefix + product_name + suffix)
   return out_file, vc_tool, msbuild_tool
 
 
 def _GetDefines(config):
   """Returns the list of preprocessor definitions for this configuation.
 
   Arguments:
-    config: The dictionnary that defines the special processing to be done
+    config: The dictionary that defines the special processing to be done
             for this configuration.
   Returns:
     The list of preprocessor definitions.
   """
   defines = []
   for d in config.get('defines', []):
     if type(d) == list:
       fd = '='.join([str(dpart) for dpart in d])
     else:
       fd = str(d)
@@ skipping 16 matching lines @@
           'Multiple module definition files in one target, target %s lists '
           'multiple .def files: %s' % (
               spec['target_name'], ' '.join(def_files)))
   return def_file
 
 
 def _ConvertToolsToExpectedForm(tools):
   """Convert tools to a form expected by Visual Studio.
 
   Arguments:
-    tools: A dictionnary of settings; the tool name is the key.
+    tools: A dictionary of settings; the tool name is the key.
   Returns:
     A list of Tool objects.
   """
   tool_list = []
   for tool, settings in tools.iteritems():
     # Collapse settings with lists.
     settings_fixed = {}
     for setting, value in settings.iteritems():
       if type(value) == list:
         if ((tool == 'VCLinkerTool' and
              setting == 'AdditionalDependencies') or
             setting == 'AdditionalOptions'):
           settings_fixed[setting] = ' '.join(value)
         else:
           settings_fixed[setting] = ';'.join(value)
       else:
         settings_fixed[setting] = value
     # Add in this tool.
     tool_list.append(MSVSProject.Tool(tool, settings_fixed))
   return tool_list
 
 
 def _AddConfigurationToMSVS(p, spec, tools, config, config_type, config_name):
   """Add to the project file the configuration specified by config.
 
   Arguments:
     p: The target project being generated.
     spec: the target project dict.
-    tools: A dictionnary of settings; the tool name is the key.
-    config: The dictionnary that defines the special processing to be done
+    tools: A dictionary of settings; the tool name is the key.
+    config: The dictionary that defines the special processing to be done
             for this configuration.
     config_type: The configuration type, a number as defined by Microsoft.
     config_name: The name of the configuration.
   """
   attributes = _GetMSVSAttributes(spec, config, config_type)
   # Add in this configuration.
   tool_list = _ConvertToolsToExpectedForm(tools)
   p.AddConfig(_ConfigFullName(config_name, config),
               attrs=attributes, tools=tool_list)
 
@@ skipping 1510 matching lines @@
   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)
   libraries = _GetLibraries(spec)
+  library_dirs = _GetLibraryDirs(configuration)
   out_file, _, msbuild_tool = _GetOutputFilePathAndTool(spec, msbuild=True)
   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_prebuild', 'msvs_postbuild', 'msvs_tool_files']
     for ignored_setting in ignored_settings:
       value = configuration.get(ignored_setting)
       if value:
@@ skipping 13 matching lines @@
   # 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, '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,
                 only_if_unset=True)
   # Add defines.
   _ToolAppend(msbuild_settings, 'ClCompile',
               'PreprocessorDefinitions', defines)
   _ToolAppend(msbuild_settings, 'ResourceCompile',
               'PreprocessorDefinitions', defines)
   # Add disabled warnings.
   _ToolAppend(msbuild_settings, 'ClCompile',
@@ skipping 373 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)