parameters: (self, targets, include_shared_libraries,
                                  dependencies=None, initial=True)
return_statement: return dependencies
docstring: Returns an OrderedSet of dependency targets that are linked
      into this target.
  
      This function has a split personality, depending on the setting of
      |initial|.  Outside callers should always leave |initial| at its default
      setting.
  
      When adding a target to the list of dependencies, this function will
      recurse into itself with |initial| set to False, to collect dependencies
      that are linked into the linkable target for which the list is being built.
  
      If |include_shared_libraries| is False, the resulting dependencies will not
      include shared_library targets that are linked into this target.
docstring_summary: Returns an OrderedSet of dependency targets that are linked
      into this target.
docstring_tokens: Returns an OrderedSet of dependency targets that are linked into this target .
function: def _LinkDependenciesInternal(self, targets, include_shared_libraries,
                                  dependencies=None, initial=True):
      """Returns an OrderedSet of dependency targets that are linked
      into this target.
  
      This function has a split personality, depending on the setting of
      |initial|.  Outside callers should always leave |initial| at its default
      setting.
  
      When adding a target to the list of dependencies, this function will
      recurse into itself with |initial| set to False, to collect dependencies
      that are linked into the linkable target for which the list is being built.
  
      If |include_shared_libraries| is False, the resulting dependencies will not
      include shared_library targets that are linked into this target.
      """
      if dependencies is None:
        # Using a list to get ordered output and a set to do fast "is it
        # already added" checks.
        dependencies = OrderedSet()
  
      # Check for None, corresponding to the root node.
      if self.ref is None:
        return dependencies
  
      # It's kind of sucky that |targets| has to be passed into this function,
      # but that's presently the easiest way to access the target dicts so that
      # this function can find target types.
  
      if 'target_name' not in targets[self.ref]:
        raise GypError("Missing 'target_name' field in target.")
  
      if 'type' not in targets[self.ref]:
        raise GypError("Missing 'type' field in target %s" %
                       targets[self.ref]['target_name'])
  
      target_type = targets[self.ref]['type']
  
      is_linkable = target_type in linkable_types
  
      if initial and not is_linkable:
        # If this is the first target being examined and it's not linkable,
        # return an empty list of link dependencies, because the link
        # dependencies are intended to apply to the target itself (initial is
        # True) and this target won't be linked.
        return dependencies
  
      # Don't traverse 'none' targets if explicitly excluded.
      if (target_type == 'none' and
          not targets[self.ref].get('dependencies_traverse', True)):
        dependencies.add(self.ref)
        return dependencies
  
      # Executables and loadable modules are already fully and finally linked.
      # Nothing else can be a link dependency of them, there can only be
      # dependencies in the sense that a dependent target might run an
      # executable or load the loadable_module.
      if not initial and target_type in ('executable', 'loadable_module'):
        return dependencies
  
      # Shared libraries are already fully linked.  They should only be included
      # in |dependencies| when adjusting static library dependencies (in order to
      # link against the shared_library's import lib), but should not be included
      # in |dependencies| when propagating link_settings.
      # The |include_shared_libraries| flag controls which of these two cases we
      # are handling.
      if (not initial and target_type == 'shared_library' and
          not include_shared_libraries):
        return dependencies
  
      # The target is linkable, add it to the list of link dependencies.
      if self.ref not in dependencies:
        dependencies.add(self.ref)
        if initial or not is_linkable:
          # If this is a subsequent target and it's linkable, don't look any
          # further for linkable dependencies, as they'll already be linked into
          # this target linkable.  Always look at dependencies of the initial
          # target, and always look at dependencies of non-linkables.
          for dependency in self.dependencies:
            dependency._LinkDependenciesInternal(targets,
                                                 include_shared_libraries,
                                                 dependencies, False)
  
      return dependencies
function_tokens: def _LinkDependenciesInternal ( self , targets , include_shared_libraries , dependencies = None , initial = True ) : if dependencies is None : # Using a list to get ordered output and a set to do fast "is it # already added" checks. dependencies = OrderedSet ( ) # Check for None, corresponding to the root node. if self . ref is None : return dependencies # It's kind of sucky that |targets| has to be passed into this function, # but that's presently the easiest way to access the target dicts so that # this function can find target types. if 'target_name' not in targets [ self . ref ] : raise GypError ( "Missing 'target_name' field in target." ) if 'type' not in targets [ self . ref ] : raise GypError ( "Missing 'type' field in target %s" % targets [ self . ref ] [ 'target_name' ] ) target_type = targets [ self . ref ] [ 'type' ] is_linkable = target_type in linkable_types if initial and not is_linkable : # If this is the first target being examined and it's not linkable, # return an empty list of link dependencies, because the link # dependencies are intended to apply to the target itself (initial is # True) and this target won't be linked. return dependencies # Don't traverse 'none' targets if explicitly excluded. if ( target_type == 'none' and not targets [ self . ref ] . get ( 'dependencies_traverse' , True ) ) : dependencies . add ( self . ref ) return dependencies # Executables and loadable modules are already fully and finally linked. # Nothing else can be a link dependency of them, there can only be # dependencies in the sense that a dependent target might run an # executable or load the loadable_module. if not initial and target_type in ( 'executable' , 'loadable_module' ) : return dependencies # Shared libraries are already fully linked.  They should only be included # in |dependencies| when adjusting static library dependencies (in order to # link against the shared_library's import lib), but should not be included # in |dependencies| when propagating link_settings. # The |include_shared_libraries| flag controls which of these two cases we # are handling. if ( not initial and target_type == 'shared_library' and not include_shared_libraries ) : return dependencies # The target is linkable, add it to the list of link dependencies. if self . ref not in dependencies : dependencies . add ( self . ref ) if initial or not is_linkable : # If this is a subsequent target and it's linkable, don't look any # further for linkable dependencies, as they'll already be linked into # this target linkable.  Always look at dependencies of the initial # target, and always look at dependencies of non-linkables. for dependency in self . dependencies : dependency . _LinkDependenciesInternal ( targets , include_shared_libraries , dependencies , False ) return dependencies