Do we have any nested includes we need to process?
517188
def load_includes(self, env, silent, key):
        """"""
        includes = self.get("DYNACONF_INCLUDE", [])
        includes.extend(ensure_a_list(self.get("INCLUDES_FOR_DYNACONF")))
        if includes:
            self.logger.debug("Processing includes %s", includes)
            self.load_file(path=includes, env=env, silent=silent, key=key)
56191
def prepare_include(ctx, include, output):
    """"""
    click.echo('chemdataextractor.dict.prepare_include')
    for i, line in enumerate(include):
        print('IN%s' % i)
        for tokens in _make_tokens(line.strip()):
            output.write(u' '.join(tokens))
            output.write(u'\n')
220870
private boolean includes(String identifier) {
    if (includes.isEmpty()) return !exclude(identifier);

    String includeMatch = null;
    String excludeMatch = null;
    for (String rule = identifier; rule != null; rule = enclosing(rule)) {
      if (excludes.contains(rule)) {
        excludeMatch = rule;
      }
      if (includes.contains(rule)) {
        includeMatch = rule;
      }
    }
    if (excludeMatch != null) {
      usedExcludes.add(excludeMatch);
      return false;
    }
    if (includeMatch != null) {
      usedIncludes.add(includeMatch);
      return true;
    }
    return false;
  }
1174727
@Override
    public void include(Readable in, String source) throws IOException
    {
        if (cursor != end)
        {
            release();
        }
        if (includeStack == null)
        {
            includeStack = new ArrayDeque<>();
        }
        includeStack.push(includeLevel);
        includeLevel = new IncludeLevel(in, source);
    }
512318
def build_includes():
    
    print("Running scripts in _include:")
    cwd = os.getcwd()
    os.chdir('_include')
    pyfiles = glob.glob('*.py')
    for fn in pyfiles:
        if not fn.startswith('_'):
            print(' {}'.format(fn))
            subprocess.check_output(['python', fn])
    os.chdir(cwd)
116471
function reduceIncludes(includes) {
	return includes.reduce((res, el) => {
		if (
			!res.length ||
			!res[res.length - 1].actualNode.contains(el.actualNode)
		) {
			res.push(el);
		}
		return res;
	}, []);
}
882638
def render_include_tree(self):
        
        if self.is_derived():
            env = self.get_build_env()
            if env:
                for s in self.sources:
                    scanner = self.get_source_scanner(s)
                    if scanner:
                        path = self.get_build_scanner_path(scanner)
                    else:
                        path = None
                    def f(node, env=env, scanner=scanner, path=path):
                        return node.get_found_includes(env, scanner, path)
                    return SCons.Util.render_tree(s, f, 1)
        else:
            return None
944842
def require_nested(dir = 0)
      dir = caller_locations(dir + 1, 1)[0].path.sub(/\.rb$/, '') if dir.is_a?(Integer)
      Dir["#{dir}/*.rb"].each { |file| require_dependency file }
    end
336255
def __setIncludes(self, schema):
        
        for schemaLocation, val in schema.includes.items(): 
            if self._includes.has_key(schemaLocation):
                schema.addIncludeSchema(schemaLocation, self._imports[schemaLocation])
351132
public void _include(IncludeBuilderBase includes) {
        if (includes == null) {
            return;
        }

        if (includes.documentsToInclude != null) {
            for (String doc : includes.documentsToInclude) {
                documentIncludes.add(doc);
            }
        }

        _includeCounters(includes.alias, includes.countersToIncludeBySourcePath);
    }
801376
def _process_dependlist(self, dependlist, anexec, isSubroutine, mode="insert"):
        """"""
        for i in range(len(dependlist)):
            #Since we are looping over all the elements and some will
            #be lists of parameters, we need to skip any items that are lists.
            if isinstance(dependlist[i], list):
                continue

            key = dependlist[i].lower()
            if len(dependlist) > i + 1:
                has_params = isinstance(dependlist[i + 1], list)
            else:
                has_params = False

            #Clean the dependency key to make sure we are only considering valid
            #executable symbols.
            cleanmatch = self.RE_DEPCLEAN.match(key + "(")
            if not cleanmatch:
                continue
            else:
                key = cleanmatch.group("key")

            #We need to handle if and do constructs etc. separately
            if key not in ["then", ",", "", "elseif"] and has_params \
               and not "=" in key and not ">" in key:
                if key in ["if", "do"]:
                    self._process_dependlist(dependlist[i + 1], anexec, False, mode)
                else:
                    #This must be valid call to an executable, add it to the list
                    #with its parameters and then process its parameters list
                    #to see if there are more nested executables
                    if mode == "insert":
                        self._add_dependency(key, dependlist, i, isSubroutine, anexec)
                    elif mode == "delete":
                        #Try and find a dependency already in the executable that 
                        #has the same call signature; then remove it.
                        self._remove_dependency(dependlist, i, isSubroutine, anexec)

                    self._process_dependlist(dependlist[i + 1], anexec, False, mode)
103627
def _load_includes(self, tag, ssh=False):
        
        import re
        includes = []
        for child in tag:
            if child.tag == "include" and "path" in child.attrib:
                incl = { "path": child.attrib["path"] }
                if "modules" in child.attrib:
                    incl["modules"] = re.split(",\s*", child.attrib["modules"].lower())
                includes.append(incl)

        if ssh == False:
            self._vardict["includes"] = includes
        else:
            self._vardict["ssh.includes"] = includes
1088258
function getIncludes(ext, exclude) {
    var globs = [];

    modules.forEach(function (module) {

      if (!settings.release) {

        // Not in release mode:
        // Ensure the main module file is included first

        globs.push(module.folder + '/' + module.folder + ext);
        globs.push(module.folder + '/**/*' + ext);
      } else {

        // In release mode:
        // Include the minified version.

        globs.push(module.folder + '/' + module.folder + '.min' + ext);
      }

    });

    var res = gulp.src(globs, {
      read: false,
      cwd: path.resolve(settings.folders.dest)
    });

    if (exclude) {
      res = res.pipe(gfilter('!**/*' + exclude));
//      res = res.pipe(utils.dumpFilePaths());
    }

    return res;
  }
593479
def included_recipes(ast, options = { with_partial_names: true })
      raise_unless_xpath!(ast)

      filter = ["[count(descendant::args_add) = 1]"]

      # If `:with_partial_names` is false then we won't include the string
      # literal portions of any string that has an embedded expression.
      unless options[:with_partial_names]
        filter << "[count(descendant::string_embexpr) = 0]"
      end

      string_desc = '[descendant::args_add/string_literal]/
        descendant::tstring_content'
      included = ast.xpath([
        "//command[ident/@value = 'include_recipe']",
        "//fcall[ident/@value = 'include_recipe']/
         following-sibling::arg_paren",
      ].map do |recipe_include|
        recipe_include + filter.join + string_desc
      end.join(" | "))

      # Hash keyed by recipe name with matched nodes.
      included.inject(Hash.new([])) { |h, i| h[i["value"]] += [i]; h }
    end
618271
protected function includes()
    {
        $moduleInclude = (array) $this->def('include');
        $globalInclude = $this->app['config']->get('module::include');
        $specificInclude = array($this->name.'.php');
        $include = array_merge($moduleInclude, $specificInclude, $globalInclude);
        foreach ($include as $file)
		{
			$path = $this->path.'/'.$file;
			if ($this->app['files']->exists($path)) require $path;
		}
    }
704197
def recursive_include(self, dir, pattern):
        
        full_pattern = os.path.join(dir, '**', pattern)
        found = [f for f in glob(full_pattern, recursive=True)
                 if not os.path.isdir(f)]
        self.extend(found)
        return bool(found)
204309
function(result, child_config, include_name_stack, properties) {

		if (include_name_stack.indexOf(child_config.name) != -1) Lava.t("Infinite include recursion");
		var include = Lava.view_manager.getInclude(this._parent_view, child_config);
		if (Lava.schema.DEBUG && include == null) Lava.t("Include not found: " + child_config.name);

		include_name_stack.push(child_config.name);
		this._createChildren(result, include, include_name_stack, properties);
		include_name_stack.pop();

	}