This change supports '!' and '/' operators for 'dependencies' section.

pylib/gyp/input.py

 #!/usr/bin/python
 
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
@@ skipping 1024 matching lines @@
   """Make dependency links fully-qualified relative to the current directory.
 
   |targets| is a dict mapping fully-qualified target names to their target
   dicts.  For each target in this dict, keys known to contain dependency
   links are examined, and any dependencies referenced will be rewritten
   so that they are fully-qualified and relative to the current directory.
   All rewritten dependencies are suitable for use as keys to |targets| or a
   similar dict.
   """
 
+  all_dependency_sections = [dep + op
+                             for dep in dependency_sections
+                             for op in ('', '!', '/')]
+
   for target, target_dict in targets.iteritems():
     target_build_file = gyp.common.BuildFile(target)
     toolset = target_dict['toolset']
-    for dependency_key in dependency_sections:
+    for dependency_key in all_dependency_sections:
       dependencies = target_dict.get(dependency_key, [])
       for index in xrange(0, len(dependencies)):
         dep_file, dep_target, dep_toolset = gyp.common.ResolveTarget(
             target_build_file, dependencies[index], toolset)
         global multiple_toolsets
         if not multiple_toolsets:
           # Ignore toolset specification in the dependency if it is specified.
           dep_toolset = toolset
         dependency = gyp.common.QualifiedTarget(dep_file,
                                                 dep_target,
@@ skipping 287 matching lines @@
   # Set up the dependency links.  Targets that have no dependencies are treated
   # as dependent on root_node.
   root_node = DependencyGraphNode(None)
   for target, spec in targets.iteritems():
     target_node = dependency_nodes[target]
     target_build_file = gyp.common.BuildFile(target)
     if not 'dependencies' in spec or len(spec['dependencies']) == 0:
       target_node.dependencies = [root_node]
       root_node.dependents.append(target_node)
     else:
+      # Apply the list filters ('!' and '/') to dependencies list.
+      deps_dict = {}
+      for op in ('', '!', '/'):
+        key = 'dependencies' + op
+        if key in spec and len(spec[key]) > 0:
+          deps_dict[key] = spec[key]
+          del spec[key]  # Remove the key applied.
+      ProcessListFiltersInDict(target, deps_dict)
+      # Write the result back to |spec|.
+      spec['dependencies'] = deps_dict['dependencies']

[Mark Mentovai, 2011/05/03 18:32:35]

1. I don’t want to set spec['dependencies'] at all if it wasn’t originally set.

2. Why only dependencies and not all of dependency_sections? You seem to have
accounted for all dependency_sections above.

3. We don’t remove sources! and sources/ from the tree in the other case. We
should be consistent. Perhaps the filter-process routines themselves should be
responsible for deleting the ! and / things. Even better, maybe they should just
save them but rename them so that they won’t be processed on a further round.

[Yuki Shiino, 2011/05/04 10:52:11]

I've changed the way, but I explain what I thought before, just FYI.

On 2011/05/03 18:32:35, Mark Mentovai wrote:
This 'else' clause runs only when spec['dependencies'] has originally been set.
It seems right.
ProcessListFiltersInDict() removes sources! and sources/ from the tree, if I
understand correctly.  The function makes the 'sources_excluded' key and stores
excluded values, but there seems no other values saved.

+
       dependencies = spec['dependencies']
       for index in xrange(0, len(dependencies)):
         try:
           dependency = dependencies[index]
           dependency_node = dependency_nodes[dependency]
           target_node.dependencies.append(dependency_node)
           dependency_node.dependents.append(target_node)
         except KeyError, e:
           gyp.common.ExceptionAppend(e,
                                      'while trying to load target %s' % target)
@@ skipping 445 matching lines @@
   """Process regular expression and exclusion-based filters on lists.
 
   An exclusion list is in a dict key named with a trailing "!", like
   "sources!".  Every item in such a list is removed from the associated
   main list, which in this example, would be "sources".  Removed items are
   placed into a "sources_excluded" list in the dict.
 
   Regular expression (regex) filters are contained in dict keys named with a
   trailing "/", such as "sources/" to operate on the "sources" list.  Regex
   filters in a dict take the form:
-    'sources/': [ ['exclude', '_(linux|mac|win)\\.cc$'] ],
+    'sources/': [ ['exclude', '_(linux|mac|win)\\.cc$'],
                   ['include', '_mac\\.cc$'] ],
   The first filter says to exclude all files ending in _linux.cc, _mac.cc, and
   _win.cc.  The second filter then includes all files ending in _mac.cc that
   are now or were once in the "sources" list.  Items matching an "exclude"
   filter are subject to the same processing as would occur if they were listed
   by name in an exclusion list (ending in "!").  Items matching an "include"
   filter are brought back into the main list if previously excluded by an
   exclusion list or exclusion regex filter.  Subsequent matching "exclude"
   patterns can still cause items to be excluded after matching an "include".
   """
@@ skipping 409 matching lines @@
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |data| for now because the generator needs a list of
   # build files that came in.  In the future, maybe it should just accept
   # a list, and not the whole data dict.
   return [flat_list, targets, data]