ninja/win: Support VCLinkerTool.GenerateManifest

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 494 matching lines @@
       ldflags.append('/DYNAMICBASE')
 
     # If the NXCOMPAT flag has not been specified, default to on. Despite the
     # documentation that says this only defaults to on when the subsystem is
     # Vista or greater (which applies to the linker), the IDE defaults it on
     # unless it's explicitly off.
     if not filter(lambda x: 'NXCOMPAT' in x, ldflags):
       ldflags.append('/NXCOMPAT')
 
     have_def_file = filter(lambda x: x.startswith('/DEF:'), ldflags)
-    manifest_flags, intermediate_manifest_file = self._GetLdManifestFlags(
-        config, manifest_base_name, is_executable and not have_def_file)
+    manifest_flags, manifest_files = self._GetLdManifestFlags(
+        config, manifest_base_name, gyp_to_build_path,
+        is_executable and not have_def_file)
     ldflags.extend(manifest_flags)
-    manifest_files = self._GetAdditionalManifestFiles(config, gyp_to_build_path)
-    manifest_files.append(intermediate_manifest_file)
-
     return ldflags, manifest_files
 
-  def _GetLdManifestFlags(self, config, name, allow_isolation):
+  def _GetLdManifestFlags(self, config, name, gyp_to_build_path,
+                          allow_isolation):
     """Returns the set of flags that need to be added to the link to generate
-    a default manifest, as well as the name of the generated file."""
-    # The manifest is generated by default.
+    a default manifest, as well as the list of all the manifest files to be
+    merged by the manifest tool."""
+    generate_manifest = self._Setting(('VCLinkerTool', 'GenerateManifest'),
+                                      config,
+                                      default='true')
+    if generate_manifest != 'true':
+      # This means not only that the linker should not generate the intermediate
+      # manifest but also that the manifest tool should do nothing even when
+      # additional manifests are specified.
+      return ['/MANIFEST:NO'], []
+
     output_name = name + '.intermediate.manifest'
     flags = [
       '/MANIFEST',
       '/ManifestFile:' + output_name,
     ]
 
     config = self._TargetConfig(config)
     enable_uac = self._Setting(('VCLinkerTool', 'EnableUAC'), config,
                                default='true')
     if enable_uac == 'true':
       execution_level = self._Setting(('VCLinkerTool', 'UACExecutionLevel'),
                                       config, default='0')
       execution_level_map = {
         '0': 'asInvoker',
         '1': 'highestAvailable',
         '2': 'requireAdministrator'
       }
 
       ui_access = self._Setting(('VCLinkerTool', 'UACUIAccess'), config,
                                 default='false')
       flags.append('''/MANIFESTUAC:"level='%s' uiAccess='%s'"''' %
           (execution_level_map[execution_level], ui_access))
     else:
       flags.append('/MANIFESTUAC:NO')
 
     if allow_isolation:
       flags.append('/ALLOWISOLATION')
-    return flags, output_name
+
+    manifest_files = [output_name]
+    manifest_files += self._GetAdditionalManifestFiles(config,
+                                                       gyp_to_build_path)
+    return flags, manifest_files
 
   def _GetAdditionalManifestFiles(self, config, gyp_to_build_path):
     """Gets additional manifest files that are added to the default one
     generated by the linker."""
     files = self._Setting(('VCManifestTool', 'AdditionalManifestFiles'), config,
                           default=[])
     if isinstance(files, str):
       files = files.split(';')
     return [os.path.normpath(
                 gyp_to_build_path(self.ConvertVSMacros(f, config=config)))
@@ skipping 307 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