Retrieves the appropriate dependency parse.
        Must be one of:
            - basic
            - alternative
            - collapsedCCProcessed
            - collapsed
            - enhanced
            - enhancedPlusPlus
188014
def depparse(self, mode="enhancedPlusPlus"):
        
        assert mode in [
            "basic",
            "alternative",
            "collapsedCCProcessed",
            "collapsed",
            "enhanced",
            "enhancedPlusPlus", ], "Invalid mode"
        dep_pb = getattr(self.pb, mode + "Dependencies")
        if dep_pb is None:
            raise AttributeError("No dependencies for mode: " + mode)
        else:
            tree = AnnotatedDependencyParseTree(dep_pb)
            tree.sentence = self
            return tree
792518
def get_parser_class():
    
    global distro
    if distro == 'Linux':
        Parser = parser.LinuxParser
        if not os.path.exists(Parser.get_command()[0]):
            Parser = parser.UnixIPParser
    elif distro in ['Darwin', 'MacOSX']:
        Parser = parser.MacOSXParser
    elif distro == 'Windows':
        # For some strange reason, Windows will always be win32, see:
        # https://stackoverflow.com/a/2145582/405682
        Parser = parser.WindowsParser
    else:
        Parser = parser.NullParser
        Log.error("Unknown distro type '%s'." % distro)
    Log.debug("Distro detected as '%s'" % distro)
    Log.debug("Using '%s'" % Parser)

    return Parser
183310
@Requires({
    "sourceDependencyLoader != null",
    "type != null"
  })
  @Ensures({
    "importNames != null",
    "rootLineNumberIterator != null"
  })
  @SuppressWarnings("unchecked")
  protected void fetchSourceDependency() throws IOException {
    String fileName = type.getName().getBinaryName()
        + JavaUtils.SOURCE_DEPENDENCY_EXTENSION;
    InputStream in =
        sourceDependencyLoader.getResourceAsStream(fileName);
    if (in == null) {
      throw new FileNotFoundException();
    }
    ObjectInputStream oin = new ObjectInputStream(in);
    try {
      importNames = (Set<String>) oin.readObject();
      rootLineNumberIterator = ((List<Long>) oin.readObject()).iterator();
    } catch (ClassNotFoundException e) {
      throw new IOException(e);
    }
    oin.close();
  }
253631
def get_dependency_type(_type):
        
        if _type == DependencyTypes.AFTER:
            return 'after'
        elif _type == DependencyTypes.AFTER_ANY:
            return 'afterany'
        elif _type == DependencyTypes.AFTER_CORR:
            return 'aftercorr'
        elif _type == DependencyTypes.AFTER_NOT_OK:
            return 'afternotok'
        elif _type == DependencyTypes.AFTER_OK:
            return 'afterok'
        else:
            return None
1093693
def get_dependency_element(self, symbol):
        """"""
        for depend in self.dependencies:
            if "." in depend:
                #We know the module name and the executable name, easy
                if depend.split(".")[1] == symbol.lower():
                    found = self.parent.get_executable(depend)
                    break
            else:
                #We only have the name of an executable or interface, we have to search
                #the whole module for the element.
                fullname = "{}.{}".format(depend, symbol)
                if self.parent.get_executable(fullname) is not None:
                    found = self.parent.get_executable(fullname)
                    break
                if self.parent.get_interface(fullname) is not None:
                    found = self.parent.get_interface(fullname)
                    break
        else:
            return None

        return found
1254396
def _locate(self, name):
        
        if name == None:
            raise Exception("Dependency name cannot be null")
        if self._references == None:
            raise Exception("References shall be set")
        
        return self._dependencies.get(name)
1161004
private Map<String, Map<String, Set<String>>> getDependencies(Context context,
                                                                  Collection<JavaFileObject> explicitJFOs,
                                                                  boolean cp) {
        Map<String, Map<String, Set<String>>> result = new HashMap<>();

        for (CompletionNode cnode : getDependencyNodes(context, explicitJFOs, true)) {

            String fqDep = cnode.getClassSymbol().outermostClass().flatname.toString();
            String depPkg = Util.pkgNameOfClassName(fqDep);

            Map<String, Set<String>> depsForThisClass = result.get(depPkg);
            if (depsForThisClass == null) {
                result.put(depPkg, depsForThisClass = new HashMap<>());
            }

            Set<String> fqDeps = depsForThisClass.get(fqDep);
            if (fqDeps == null) {
                depsForThisClass.put(fqDep, fqDeps = new HashSet<>());
            }

            for (Node<?,?> depNode : getAllDependencies(cnode)) {
                CompletionNode cDepNode = (CompletionNode) depNode;
                // Symbol is not regarded to depend on itself.
                if (cDepNode == cnode) {
                    continue;
                }
                // Skip anonymous classes
                if (cDepNode.getClassSymbol().fullname == null) {
                    continue;
                }
                if (isSymbolRelevant(cp, cDepNode.getClassSymbol())) {
                    fqDeps.add(cDepNode.getClassSymbol().outermostClass().flatname.toString());
                }
            }

            // The completion dependency graph is not transitively closed for inheritance relations.
            // For sjavac's purposes however, a class depends on it's super super type, so below we
            // make sure that we include super types.
            for (ClassSymbol cs : allSupertypes(cnode.getClassSymbol())) {
                if (isSymbolRelevant(cp, cs)) {
                    fqDeps.add(cs.outermostClass().flatname.toString());
                }
            }

        }
        return result;
    }
330437
def dependency(lib = nil)
      lib ? require(lib) : yield
    rescue LoadError, NameError => e
      self.load_error = e
    end
225435
public String getDeptype() {
    if (Dependency_Type.featOkTst && ((Dependency_Type)jcasType).casFeat_deptype == null)
      jcasType.jcas.throwFeatMissing("deptype", "com.digitalpebble.rasp.Dependency");
    return jcasType.ll_cas.ll_getStringValue(addr, ((Dependency_Type)jcasType).casFeatCode_deptype);}
244564
function lookForExternalDependenciesRES( _def, resources, depFile ) {
  if ( !_def ) return;
  try {
    const def = convertExternalDependencyDefinition( _def );
    for ( const dep of Object.keys( def ) ) {
      if ( def[ dep ] === "" ) {
        // `res: { "bob/foo.png": "" }` is equivalent to
        // `res: { "bob/foo.png": "bob/foo.png" }`
        def[ dep ] = dep;
      }
      const
      srcDep = Project.srcOrLibPath( `mod/${dep}` ) ||
        Project.srcOrLibPath( dep );
      if ( !srcDep ) {
        Fatal.fire(
          `Unable to find dependency file "${dep}" nor "mod/${dep}"!`,
          depFile.getAbsoluteFilePath()
        );
      }
      resources[ srcDep ] = Project.wwwPath( def[ dep ] );
    }
  } catch ( ex ) {
    Fatal.fire(
      `Unable to parse RES dependencies: ${JSON.stringify(_def)}!\n${ex}`,
      depFile
    );
  }
}
63156
private static Collection<String> parseRequires(String code, boolean addClosureBase) {
    ErrorManager errorManager = new LoggerErrorManager(logger);
    JsFileParser parser = new JsFileParser(errorManager);
    DependencyInfo deps =
        parser.parseFile("<unknown path>", "<unknown path>", code);
    List<String> requires = new ArrayList<>();
    if (addClosureBase) {
      requires.add(CLOSURE_BASE_PROVIDE);
    }
    requires.addAll(deps.getRequiredSymbols());
    errorManager.generateReport();
    return requires;
  }
260269
def GetParserProp(self, prop):
        
        ret = libxml2mod.xmlTextReaderGetParserProp(self._o, prop)
        return ret
1146155
def relaxNGNewDocParserCtxt(self):
        
        ret = libxml2mod.xmlRelaxNGNewDocParserCtxt(self._o)
        if ret is None:raise parserError('xmlRelaxNGNewDocParserCtxt() failed')
        __tmp = relaxNgParserCtxt(_obj=ret)
        return __tmp
221693
def GetArtifactParserDependencies(rdf_artifact):
  
  deps = set()
  processors = parser.Parser.GetClassesByArtifact(rdf_artifact.name)
  for p in processors:
    deps.update(p.knowledgebase_dependencies)
  return deps
963404
def _get_api_dependencies_of(name, version='', force=False):
    ''''''
    m, d = _get_metadap_dap(name, version=version)
    # We need the dependencies to install the dap,
    # if the dap is unsupported, raise an exception here
    if not force and not _is_supported_here(d):
        raise DapiLocalError(
            '{0} is not supported on this platform (use --force to suppress this check).'.
            format(name))
    return d.get('dependencies', [])
803173
def dependency_tree(args = {}, &bl)
      local_args        = Hash[args]
      recursive         = local_args[:recursive]
      retrieve_dev_deps = local_args[:dev_deps]
      matching          = local_args[:matching]
      dependencies      = local_args[:dependencies] || {}
      return dependencies if dependencies.key?(name) && dependencies[name].key?(version)

      dependencies[name]          ||= {}
      dependencies[name][version]   = deps + dev_deps
      args[:dependencies]           = dependencies

      resolved_deps = resolve_tree_deps(args.merge({:deps => deps}),     &bl)
      resolved_dev  = retrieve_dev_deps ? resolve_tree_deps(args.merge({:deps => dev_deps}), &bl) : []

      (resolved_deps + resolved_dev).each { |dep|
        dependencies.merge! dep.dependency_tree(args, &bl)
        args[:dependencies] = dependencies
      } if recursive

      return dependencies
    end
1353365
def parse(self):
        
        try:
            data = json.loads(self.obj.content, object_pairs_hook=OrderedDict)
            if data:
                for package_type in ['default', 'develop']:
                    if package_type in data:
                        for name, meta in data[package_type].items():
                            # skip VCS dependencies
                            if 'version' not in meta:
                                continue
                            specs = meta['version']
                            hashes = meta['hashes']
                            self.obj.dependencies.append(
                                Dependency(
                                    name=name, specs=SpecifierSet(specs),
                                    dependency_type=filetypes.pipfile_lock,
                                    hashes=hashes,
                                    line=''.join([name, specs]),
                                    section=package_type
                                )
                            )
        except ValueError:
            pass