Get the decls of the module.
340645
def c_member_funcs(self, for_struct=False):
        """"""
        decls = [
            '{} *{};'.format(self._c_type_name(name), name)
            for name, dummy_args in self.funcs
        ]
        if for_struct:
            return decls
        return [self._c_mod_decl()] + decls
976780
def declalltypes(self):
        """"""
        for f in self.body:
            if (hasattr(f, '_ctype')
                    and f._ctype._storage == Storages.TYPEDEF):
                yield f
1041992
def _get_defaults(modules):
    
    default = os.path.join(os.path.dirname(__file__),
                           'defaults/%s.yaml' % (modules))
    return yaml.safe_load(open(default))
234387
def get_modules(self, type_name):
        '''
        '''
        modules = []
        for module in self:
            if module.__class__.__name__ == type_name:
                modules.append(module)
        return modules
411597
public Collection<String> getSelectedModules() {

        List<String> result = Lists.newArrayList();
        for (Map.Entry<String, CheckBox> entry : m_moduleCheckboxes.entrySet()) {
            if (entry.getValue().getValue().booleanValue()) {
                result.add(entry.getKey());
            }
        }
        return result;
    }
879586
def get_dependencies_from_decl(decl, recursive=True):
    
    result = []
    if isinstance(decl, typedef.typedef_t) or \
            isinstance(decl, variable.variable_t):
        return [dependency_info_t(decl, decl.decl_type)]
    if isinstance(decl, namespace.namespace_t):
        if recursive:
            for d in decl.declarations:
                result.extend(get_dependencies_from_decl(d))
        return result
    if isinstance(decl, calldef.calldef_t):
        if decl.return_type:
            result.append(
                dependency_info_t(decl, decl.return_type, hint="return type"))
        for arg in decl.arguments:
            result.append(dependency_info_t(decl, arg.decl_type))
        for exc in decl.exceptions:
            result.append(dependency_info_t(decl, exc, hint="exception"))
        return result
    if isinstance(decl, class_declaration.class_t):
        for base in decl.bases:
            result.append(
                dependency_info_t(
                    decl,
                    base.related_class,
                    base.access_type,
                    "base class"))
        if recursive:
            for access_type in class_declaration.ACCESS_TYPES.ALL:
                result.extend(
                    __find_out_member_dependencies(
                        decl.get_members(access_type), access_type))
        return result
    return result
372613
def str_deps(self):
        """"""
        lines = []
        app = lines.append

        app("Dependencies of node %s:" % str(self))
        for i, dep in enumerate(self.deps):
            app("%d) %s, status=%s" % (i, dep.info, str(dep.status)))

        return "\n".join(lines)
108289
public Set<ModuleModel> getReferencedModules() {
		Set<ModuleModel> set = new HashSet<>();
		set.addAll(exportedModules);
		set.addAll(importedModules);
		return set;
	}
360288
def get_imports(project, pydefined):
    """"""
    pymodule = pydefined.get_module()
    module = module_imports.ModuleImports(project, pymodule)
    if pymodule == pydefined:
        return [stmt.import_info for stmt in module.imports]
    return module.get_used_imports(pydefined)
1177849
def get_modules(self, name):
        """"""
        result = []
        for module in self.names:
            if name in self.names[module]:
                result.append(module)
        return result
306960
function getModuleDefinitions(modules) {
      return modules.split(',').map(function(md) {
        var split = md.split(':'), name, path, type;
        name = split[0];
        path = './' + name.toLowerCase();
        if (name === 'Locales') {
          type = 'locales';
        } else if (moduleIsPolyfill(name)) {
          type = 'polyfill';
        } else {
          type = 'module';
        }
        return {
          name: name,
          path: path,
          type: type,
          namespace: split[1]
        };
      });
    }
832463
def get_defaults(self):
        """"""
        # dont need 'required' to determine the default
        options = [copy.copy(opt) for opt in self._options]
        for opt in options:
            try:
                del opt.kwargs['required']
            except KeyError:
                pass
        parser = self.build_parser(options, permissive=True, add_help=False)
        parsed, _ = parser.parse_known_args([])
        return vars(parsed)
14863
function (moduleName) {
            var moduleNames = Utils.unalias(S, Utils.normalizeModNamesWithAlias(S, [moduleName]));
            if (Utils.attachModsRecursively(moduleNames, S)) {
                return Utils.getModules(S, moduleNames)[1];
            }
            return undefined;
        }
316528
def _get_all_decendents(self, cls):
        """"""
        decendents = {}
        for sc in cls.__sub_classes__:
            decendents[sc.__name__] = sc
            decendents.update(self._get_all_decendents(sc))
        return decendents
977254
def get_params(self):
        
        assert self.binded and self.params_initialized
        self._curr_module._params_dirty = self._params_dirty
        params = self._curr_module.get_params()
        self._params_dirty = False
        return params
939094
def get_module_constant(module, symbol, default=-1, paths=None):
    """"""

    try:
        f, path, (suffix, mode, kind) = find_module(module, paths)
    except ImportError:
        # Module doesn't exist
        return None

    try:
        if kind == PY_COMPILED:
            f.read(8)  # skip magic & date
            code = marshal.load(f)
        elif kind == PY_FROZEN:
            code = imp.get_frozen_object(module)
        elif kind == PY_SOURCE:
            code = compile(f.read(), path, 'exec')
        else:
            # Not something we can parse; we'll have to import it.  :(
            if module not in sys.modules:
                imp.load_module(module, f, path, (suffix, mode, kind))
            return getattr(sys.modules[module], symbol, None)

    finally:
        if f:
            f.close()

    return extract_constant(code, symbol, default)
748124
def split(self, decl_string):
        """"""
        assert self.has_pattern(decl_string)
        return self.name(decl_string), self.args(decl_string)