Check for circular dependencies between .gyp files....

pylib/gyp/input.py

 #!/usr/bin/python
 
 # Copyright (c) 2009 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.
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
@@ skipping 1286 matching lines @@
   # If there's anything left unvisited, there must be a circular dependency
   # (cycle).  If you need to figure out what's wrong, look for elements of
   # targets that are not in flat_list.
   if len(flat_list) != len(targets):
     raise DependencyGraphNode.CircularException, \
         'Some targets not reachable, cycle in dependency graph detected'
 
   return [dependency_nodes, flat_list]
 
 
+def VerifyNoGYPFileCircularDependencies(targets):
+  # Create a DependencyGraphNode for each gyp file containing a target.  Put
+  # it into a dict for easy access.
+  dependency_nodes = {}
+  for target in targets.iterkeys():
+    build_file = gyp.common.BuildFile(target)
+    if not build_file in dependency_nodes:
+      dependency_nodes[build_file] = DependencyGraphNode(build_file)
+
+  # Set up the dependency links.
+  for target, spec in targets.iteritems():
+    build_file = gyp.common.BuildFile(target)
+    build_file_node = dependency_nodes[build_file]
+    target_dependencies = spec.get('dependencies', [])
+    for dependency in target_dependencies:
+      try:
+        dependency_build_file = gyp.common.BuildFile(dependency)
+        if dependency_build_file == build_file:
+          # A .gyp file is allowed to refer back to itself.
+          continue
+        dependency_node = dependency_nodes[dependency_build_file]
+        if dependency_node not in build_file_node.dependencies:
+          build_file_node.dependencies.append(dependency_node)
+          dependency_node.dependents.append(build_file_node)
+      except KeyError, e:
+        gyp.common.ExceptionAppend(
+            e, 'while computing dependencies of .gyp file %s' % build_file)
+        raise
+
+  # Files that have no dependencies are treated as dependent on root_node.
+  root_node = DependencyGraphNode(None)
+  for build_file_node in dependency_nodes.itervalues():
+    if len(build_file_node.dependencies) == 0:
+      build_file_node.dependencies.append(root_node)
+      root_node.dependents.append(build_file_node)
+
+  flat_list = root_node.FlattenToList()
+
+  # If there's anything left unvisited, there must be a circular dependency
+  # (cycle).
+  if len(flat_list) != len(dependency_nodes):
+    bad_files = []
+    for file in dependency_nodes.iterkeys():
+      if not file in flat_list:
+        bad_files.append(file)
+    raise DependencyGraphNode.CircularException, \
+        'Some files not reachable, cycle in .gyp file dependency graph ' + \
+        'detected involving some or all of: ' + \
+        ' '.join(bad_files)
+
+
 def DoDependentSettings(key, flat_list, targets, dependency_nodes):
   # key should be one of all_dependent_settings, direct_dependent_settings,
   # or link_settings.
 
   for target in flat_list:
     target_dict = targets[target]
     build_file = gyp.common.BuildFile(target)
 
     if key == 'all_dependent_settings':
       dependencies = dependency_nodes[target].DeepDependencies()
@@ skipping 642 matching lines @@
   for index in xrange(0, len(the_list)):
     item = the_list[index]
     if isinstance(item, int):
       the_list[index] = str(item)
     elif isinstance(item, dict):
       TurnIntIntoStrInDict(item)
     elif isinstance(item, list):
       TurnIntIntoStrInList(item)
 
 
-def Load(build_files, variables, includes, depth, generator_input_info, check):
+def Load(build_files, variables, includes, depth, generator_input_info, check,
+         circular_check):
   # Set up path_sections and non_configuration_keys with the default data plus
   # the generator-specifc data.
   global path_sections
   path_sections = base_path_sections[:]
   path_sections.extend(generator_input_info['path_sections'])
 
   global non_configuration_keys
   non_configuration_keys = base_non_configuration_keys[:]
   non_configuration_keys.extend(generator_input_info['non_configuration_keys'])
 
@@ skipping 35 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)
 
+  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)
 
   # 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.
@@ skipping 34 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]