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:
-      dependencies = spec['dependencies']
+      deps_dict = {}
+      for op in ('', '!', '/'):
+        key = 'dependencies' + op
+        if key in spec and len(spec[key]) > 0:
+          deps_dict[key] = spec[key]
+      ProcessListFiltersInDict(target, deps_dict)
+
+      dependencies = deps_dict['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)
           raise
@@ skipping 444 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 389 matching lines @@
                                         build_file)
 
   # Move everything that can go into a "configurations" section into one.
   for target in flat_list:
     target_dict = targets[target]
     SetUpConfigurations(target, target_dict)
 
   # Apply exclude (!) and regex (/) list filters.
   for target in flat_list:
     target_dict = targets[target]
     ProcessListFiltersInDict(target, target_dict)

[Mark Mentovai, 2011/04/26 19:12:24]

This will process the filters on dependencies again (although at this point GYP
won’t use them for dependencies). That seems wrong.

[Yuki Shiino, 2011/04/27 08:45:37]

Done.
I changed the code to remove '!' and '/' keys in BuildDependencyList().

 
   # Make sure that the rules make sense, and build up rule_sources lists as
   # needed.  Not all generators will need to use the rule_sources lists, but
   # some may, and it seems best to build the list in a common spot.
   # Also validate actions and run_as elements in targets.
   for target in flat_list:
     target_dict = targets[target]
     build_file = gyp.common.BuildFile(target)
     ValidateRulesInTarget(target, target_dict, extra_sources_for_rules)
     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]