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 752 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 346 matching lines @@
 
   # Build a dict to access each target's subdict by qualified name.
   targets = BuildTargetsDict(data)
 
   # Fully qualify all dependency links.
   QualifyDependencies(targets)
 
   # Expand dependencies specified as build_file:*.
   ExpandWildcardDependencies(targets, data)
 
+  # Apply exclude (!) and regex (/) list filters only for dependency_sections.
+  for target_name, target_dict in targets.iteritems():
+    tmp_dict = {}
+    for key_base in dependency_sections:
+      for op in ('', '!', '/'):
+        key = key_base + op
+        if key in target_dict:
+          tmp_dict[key] = target_dict[key]
+          del target_dict[key]
+    ProcessListFiltersInDict(target_name, tmp_dict)
+    # Write the results back to |target_dict|.
+    for key in tmp_dict:
+      target_dict[key] = tmp_dict[key]
+
   if circular_check:
     # Make sure that any targets in a.gyp don't contain dependencies in other
     # .gyp files that further depend on a.gyp.
     VerifyNoGYPFileCircularDependencies(targets)
 
   [dependency_nodes, flat_list] = BuildDependencyList(targets)
 
   # Check that no two targets in the same directory have the same name.
   VerifyNoCollidingTargets(flat_list)
-  
 
   # Handle dependent settings of various types.
   for settings_type in ['all_dependent_settings',
                         'direct_dependent_settings',
                         'link_settings']:
     DoDependentSettings(settings_type, flat_list, targets, dependency_nodes)
 
     # Take out the dependent settings now that they've been published to all
     # of the targets that require them.
     for target in flat_list:
@@ skipping 33 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]