Add ninja generator flag for writing library deps.

pylib/gyp/generator/ninja.py

 # Copyright (c) 2013 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 hashlib
 import multiprocessing
 import os.path
 import re
 import signal
@@ skipping 192 matching lines @@
 # - GypPathToNinja translates a gyp path (i.e. relative to the .gyp file)
 #   into the equivalent ninja path.
 #
 # - GypPathToUniqueOutput translates a gyp path into a ninja path to write
 #   an output file; the result can be namespaced such that it is unique
 #   to the input file name as well as the output target name.
 
 class NinjaWriter:
   def __init__(self, qualified_target, target_outputs, base_dir, build_dir,
                output_file, toplevel_build, output_file_name, flavor,
-               toplevel_dir=None):
+               deps_file_name=None, toplevel_dir=None):

[Nico, 2013/09/10 21:58:02]

rename to deps_file

     """
     base_dir: path from source root to directory containing this gyp file,
               by gyp semantics, all input paths are relative to this
     build_dir: path from source root to build output
     toplevel_dir: path to the toplevel directory
     """
 
     self.qualified_target = qualified_target
     self.target_outputs = target_outputs
     self.base_dir = base_dir
@@ skipping 14 matching lines @@
       for arch in ('x86', 'x64'):
         self.win_env[arch] = 'environment.' + arch
 
     # Relative path from build output dir to base dir.
     build_to_top = gyp.common.InvertRelativePath(build_dir, toplevel_dir)
     self.build_to_base = os.path.join(build_to_top, base_dir)
     # Relative path from base dir to build dir.
     base_to_top = gyp.common.InvertRelativePath(base_dir, toplevel_dir)
     self.base_to_build = os.path.join(base_to_top, build_dir)
 
+    # The self.link_deps_file will either be a file object if the file is
+    # requested, or it will be false if not. This file should contain a
+    # mapping from target to the list of library dependencies it has.
+    if deps_file_name:
+      self.link_deps_file = open(deps_file_name, 'ab')
+    else:
+      self.link_deps_file = None

[Nico, 2013/09/10 21:58:02]

remove most of this, and just keep `self.link_deps_file = deps_file`

+
   def ExpandSpecial(self, path, product_dir=None):
     """Expand specials like $!PRODUCT_DIR in |path|.
 
     If |product_dir| is None, assumes the cwd is already the product
     dir.  Otherwise, |product_dir| is the relative path to the product
     dir.
     """
 
     PRODUCT_DIR = '$!PRODUCT_DIR'
     if PRODUCT_DIR in path:
@@ skipping 710 matching lines @@
       # - Linkable dependencies (like a .a or a .so): add them to the link line.
       # - Non-linkable dependencies (like a rule that generates a file
       #   and writes a stamp file): add them to implicit_deps
       extra_link_deps = set()
       for dep in spec['dependencies']:
         target = self.target_outputs.get(dep)
         if not target:
           continue
         linkable = target.Linkable()
         if linkable:
+          if self.link_deps_file:
+            # Save the mapping of link deps.
+            self.link_deps_file.write(self.qualified_target)
+            self.link_deps_file.write(' ')
+            self.link_deps_file.write(target.binary)
+            self.link_deps_file.write('\n')
+
           if (self.flavor == 'win' and
               target.component_objs and
               self.msvs_settings.IsUseLibraryDependencyInputs(config_name)):
             extra_link_deps |= set(target.component_objs)
           elif self.flavor == 'win' and target.import_lib:
             extra_link_deps.add(target.import_lib)
           elif target.UsesToc(self.flavor):
             solibs.add(target.binary)
             implicit_deps.add(target.binary + '.TOC')
           else:
@@ skipping 1024 matching lines @@
       gyp.xcode_emulation.MergeGlobalXcodeSettingsToSpec(data[build_file], spec)
 
     build_file = gyp.common.RelativePath(build_file, options.toplevel_dir)
 
     base_path = os.path.dirname(build_file)
     obj = 'obj'
     if toolset != 'target':
       obj += '.' + toolset
     output_file = os.path.join(obj, base_path, name + '.ninja')
 
+    # Extract the optional link deps file name.
+    LINK_DEPS_FILE = 'link_deps_file'
+    if LINK_DEPS_FILE in generator_flags:
+      link_deps_file = generator_flags.get(LINK_DEPS_FILE)

[Nico, 2013/09/10 21:58:02]

Do link_deps_file = open(gen…ILE), 'wb') here

+    else:
+      link_deps_file = None
+
     writer = NinjaWriter(qualified_target, target_outputs, base_path, build_dir,
                          OpenOutput(os.path.join(toplevel_build, output_file)),
                          toplevel_build, output_file,
-                         flavor, toplevel_dir=options.toplevel_dir)
+                         flavor, link_deps_file,
+                         toplevel_dir=options.toplevel_dir)
     master_ninja.subninja(output_file)
 
     target = writer.WriteSpec(spec, config_name, generator_flags)
     if target:
       if name != target.FinalOutput() and spec['toolset'] == 'target':
         target_short_names.setdefault(name, []).append(target)
       target_outputs[qualified_target] = target
       if qualified_target in all_targets:
         all_outputs.add(target.FinalOutput())
 
@@ skipping 51 matching lines @@
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
         pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)