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, mac kernel extensions, windows drivers 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",
              "mac_kernel_extension",
              "windows_driver",
          ):
              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, mac kernel extensions, windows drivers 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" , "mac_kernel_extension" , "windows_driver" , ) : 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