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):
+               generator_flags, toplevel_dir=None):

[Nico, 2013/09/09 23:27:27]

It's nicer to not pass in the whole flags object, just the bits you need
(deps_file_name=None) and do the flags parsing where the NinjaWriters are
instantiated.

[brettw, 2013/09/10 21:12:13]

Done.

     """
     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.
+    LINK_DEPS_FILE = 'link_deps_file'
+    if LINK_DEPS_FILE in generator_flags:
+      self.link_deps_file = open(generator_flags.get(LINK_DEPS_FILE), 'ab')

[Nico, 2013/09/09 23:27:27]

Do you want to empty the file before creating the first NinjaWriter? Else this
file will grow and grow every time gyp runs.

[brettw, 2013/09/10 21:12:13]

I currently delete it from GN before doing the spawning. I guess I can add the
delete logic to GYP also, but that would be in a different file and it seemed
messy (since these are generator flags).

[Nico, 2013/09/10 21:56:55]

Huh? Couldn't you create the file in GenerateOutputForConfig() at the bottom, i
guess even just once in 'wb' mode, and then pass in the file object to every
NinjaWriter?

+    else:
+      self.link_deps_file = False

[Evan Martin, 2013/09/09 23:49:34]

Why not "None" (also above in the comment), since it's still falsey and it makes
link_deps_file well-typed.

[brettw, 2013/09/10 21:12:13]

Good idea, done.

+
   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)

[Nico, 2013/09/09 23:27:27]

This isn't correct on windows if you want to use incremental linking. Not sure
if you care.

Note that target.binary can contain spaces. self.qualified_target won't so this
encoding is fine (but maybe surprising)

[brettw, 2013/09/10 21:12:13]

I'll worry about this later, I don't understand how it works now.
 
Okay, I think my parser handles this currently so we should be OK.

+            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 1027 matching lines @@
 
     base_path = os.path.dirname(build_file)
     obj = 'obj'
     if toolset != 'target':
       obj += '.' + toolset
     output_file = os.path.join(obj, base_path, name + '.ninja')
 
     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, generator_flags,
+                         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)