Remove default import library inheritance/configuration.

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 187 matching lines @@
                                                 excluded=excluded,
                                                 list_excluded=list_excluded)
     contents = MSVSProject.Filter(f, contents=contents)
     result.append(contents)
 
   return result
 
 
 def _ToolAppend(tools, tool_name, setting, value, only_if_unset=False):
   if not value: return
+  _ToolSetOrAppend(tools, tool_name, setting, value, only_if_unset)
+
+
+def _ToolSetOrAppend(tools, tool_name, setting, value, only_if_unset=False):
   # TODO(bradnelson): ugly hack, fix this more generally!!!
   if 'Directories' in setting or 'Dependencies' in setting:
     if type(value) == str:
       value = value.replace('/', '\\')
     else:
       value = [i.replace('/', '\\') for i in value]
   if not tools.get(tool_name):
     tools[tool_name] = dict()
   tool = tools[tool_name]
   if tool.get(setting):
     if only_if_unset: return
     if type(tool[setting]) == list:
       tool[setting] += value
     else:
       raise TypeError(
           'Appending "%s" to a non-list setting "%s" for tool "%s" is '
           'not allowed, previous value: %s' % (
               value, setting, tool_name, str(tool[setting])))
   else:
     tool[setting] = value
 
 
 def _ConfigPlatform(config_data):
   return config_data.get('msvs_configuration_platform', 'Win32')
 
 
 def _ConfigBaseName(config_name, platform_name):
   if config_name.endswith('_' + platform_name):
-    return config_name[0:-len(platform_name)-1]
+    return config_name[0:-len(platform_name) - 1]
   else:
     return config_name
 
 
 def _ConfigFullName(config_name, config_data):
   platform_name = _ConfigPlatform(config_data)
   return '%s|%s' % (_ConfigBaseName(config_name, platform_name), platform_name)
 
 
 def _BuildCommandLineForRuleRaw(spec, cmd, cygwin_shell, has_input_path,
@@ skipping 17 matching lines @@
                             '`cygpath -m "${INTDIR}"`') for i in direct_cmd]
     direct_cmd = [i.replace('$(OutDir)',
                             '`cygpath -m "${OUTDIR}"`') for i in direct_cmd]
     direct_cmd = [i.replace('$(InputDir)',
                             '`cygpath -m "${INPUTDIR}"`') for i in direct_cmd]
     if has_input_path:
       direct_cmd = [i.replace('$(InputPath)',
                               '`cygpath -m "${INPUTPATH}"`')
                     for i in direct_cmd]
     direct_cmd = ['\\"%s\\"' % i.replace('"', '\\\\\\"') for i in direct_cmd]
-    #direct_cmd = gyp.common.EncodePOSIXShellList(direct_cmd)
+    # direct_cmd = gyp.common.EncodePOSIXShellList(direct_cmd)
     direct_cmd = ' '.join(direct_cmd)
     # TODO(quote):  regularize quoting path names throughout the module
     cmd = ''
     if do_setup_env:
       cmd += 'call "$(ProjectDir)%(cygwin_dir)s\\setup_env.bat" && '
     cmd += 'set CYGWIN=nontsec&& '
     if direct_cmd.find('NUMBER_OF_PROCESSORS') >= 0:
       cmd += 'set /a NUMBER_OF_PROCESSORS_PLUS_1=%%NUMBER_OF_PROCESSORS%%+1&& '
     if direct_cmd.find('INTDIR') >= 0:
       cmd += 'set INTDIR=$(IntDir)&& '
@@ skipping 15 matching lines @@
     # after the other without aborting in Incredibuild, since IB makes a bat
     # file out of the raw command string, and some commands (like python) are
     # actually batch files themselves.
     command.insert(0, 'call')
     # Fix the paths
     # TODO(quote): This is a really ugly heuristic, and will miss path fixing
     #              for arguments like "--arg=path" or "/opt:path".
     # If the argument starts with a slash or dash, it's probably a command line
     # switch
     arguments = [i if (i[:1] in "/-") else _FixPath(i) for i in cmd[1:]]
-    arguments = [i.replace('$(InputDir)','%INPUTDIR%') for i in arguments]
+    arguments = [i.replace('$(InputDir)', '%INPUTDIR%') for i in arguments]
     arguments = [MSVSSettings.FixVCMacroSlashes(i) for i in arguments]
     if quote_cmd:
       # Support a mode for using cmd directly.
       # Convert any paths to native form (first element is used directly).
       # TODO(quote):  regularize quoting path names throughout the module
       arguments = ['"%s"' % i for i in arguments]
     # Collapse into a single command.
     return input_dir_preamble + ' '.join(command + arguments)
 
 
@@ skipping 393 matching lines @@
   return s
 
 
 quote_replacer_regex2 = re.compile(r'(\\+)"')
 
 
 def _EscapeCommandLineArgumentForMSBuild(s):
   """Escapes a Windows command-line argument for use by MSBuild."""
 
   def _Replace(match):
-    return (len(match.group(1))/2*4)*'\\' + '\\"'
+    return (len(match.group(1)) / 2 * 4) * '\\' + '\\"'
 
   # Escape all quotes so that they are interpreted literally.
   s = quote_replacer_regex2.sub(_Replace, s)
   return s
 
 
 def _EscapeMSBuildSpecialCharacters(s):
   escape_dictionary = {
       '%': '%25',
       '$': '%24',
@@ skipping 300 matching lines @@
   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.
@@ skipping 745 matching lines @@
                                websiteProperties=False,
                                version=msvs_version)
     sln.Write()
 
   if missing_sources:
     error_message = "Missing input files:\n" + \
                     '\n'.join(set(missing_sources))
     if generator_flags.get('msvs_error_on_missing_sources', False):
       raise GypError(error_message)
     else:
-      print >>sys.stdout, "Warning: " + error_message
+      print >> sys.stdout, "Warning: " + error_message
 
 
 def _GenerateMSBuildFiltersFile(filters_path, source_files,
                                 extension_to_rule_name):
   """Generate the filters file.
 
   This file is used by Visual Studio to organize the presentation of source
   files into folders.
 
   Arguments:
@@ skipping 914 matching lines @@
   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, 'ResourceCompile',
               'AdditionalIncludeDirectories', resource_include_dirs)
-  # Add in libraries.
-  _ToolAppend(msbuild_settings, 'Link', 'AdditionalDependencies', libraries)
+  # 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)
   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 13 matching lines @@
   # Set the module definition file if any.
   if def_file:
     _ToolAppend(msbuild_settings, 'Link', 'ModuleDefinitionFile', def_file)
   configuration['finalized_msbuild_settings'] = msbuild_settings
 
 
 def _GetValueFormattedForMSBuild(tool_name, name, value):
   if type(value) == list:
     # For some settings, VS2010 does not automatically extends the settings
     # TODO(jeanluc) Is this what we want?
-    if name in ['AdditionalDependencies',
-                'AdditionalIncludeDirectories',
+    if name in ['AdditionalIncludeDirectories',
                 'AdditionalLibraryDirectories',
                 'AdditionalOptions',
                 'DelayLoadDLLs',
                 'DisableSpecificWarnings',
                 'PreprocessorDefinitions']:
       value.append('%%(%s)' % name)
     # For most tools, entries in a list should be separated with ';' but some
     # settings use a space.  Check for those first.
     exceptions = {
         'ClCompile': ['AdditionalOptions'],
@@ skipping 301 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)