Include the source file for this class if it isn't in this source
776377
public void addInclude(String strClassName, ClassProject.CodeType codeType)
    {
        try   {
            m_recClassInfo.getField(ClassInfo.CLASS_NAME).setString(strClassName);
            m_recClassInfo.setKeyArea(ClassInfo.CLASS_NAME_KEY);
            if ((m_recClassInfo.seek("=")) && (strClassName != null) && (strClassName.length() > 0))
            {   // If the based record class is in another file, include it!
                String strPackage = m_recClassInfo.getPackageName(codeType);
                this.addPackage(strPackage);
            }
            else if ((strClassName.indexOf("java.") != -1) || (strClassName.indexOf("javax.") != -1)) // If a java class is explicitly included, add it!
                this.addPackage(strClassName);
            else if ((strClassName.indexOf("com.") == 0) || (strClassName.indexOf("org.") == 0)) // If a java class is explicitly included, add it!
                this.addPackage(strClassName);
        } catch (DBException ex)   {
            ex.printStackTrace();
        }
    }
236871
function onInclude(file, parent, lineno) {
  var p, list, config, err;

  file = resolve(file);

  // load into a separate configuration
  config = new Configuration(this.options, this);

  p = config._parent;

  while(p) {
    list = [p.getFile()].concat(Object.keys(p._includes));
    if(~list.indexOf(file)) {
      err = new ConfigError(
        lineno,
        util.format(
          'circular include reference %s <=> %s', file, p._include),
        this._file);
    }
    // have to emit on the root configuration
    if(err && !p._parent) {
      return p.emit('error', err);
    // no circular reference detected
    // should be ok to load
    }else{
      p._includes[file] = true;
    }
    p = p._parent;
  }

  // current file to be included
  this._include = file;

  try {
    // have to read synchronously to support
    // how redis deals with includes, not a big deal
    // as configuration loading is at server start up
    config.load(file);

    // we should have loaded ok, keep track of the include
    //this._includes[file] = true;

  }catch(e) {
    return this.emit('error', e);
  }
}
589902
def _import(klass):
        ''''''
        mod = __import__(klass.rpartition('.')[0])
        for segment in klass.split('.')[1:-1]:
            mod = getattr(mod, segment)

        # Alright, now check the file associated with it. Note that clases
        # defined in __main__ don't have a __file__ attribute
        if klass not in BaseJob._loaded:
            BaseJob._loaded[klass] = time.time()
        if hasattr(mod, '__file__'):
            try:
                mtime = os.stat(mod.__file__).st_mtime
                if BaseJob._loaded[klass] < mtime:
                    mod = reload_module(mod)
            except OSError:
                logger.warn('Could not check modification time of %s',
                    mod.__file__)

        return getattr(mod, klass.rpartition('.')[2])
678848
function includedFile(fileName) {
            var relativePath = fileName.substring(appDir.length + 1);
            var result = false;
            for (var i = 0; i < onlyIncludeList.length; i++) {
                var prefix = onlyIncludeList[i];
                if (relativePath.indexOf(prefix) === 0) {
                    result = true;
                    break;
                }
            }
            return result;
        }
634577
def include_file(self, path, include_dirs = []):
        
        if self.include_includes:
            if self.debug: print("------------------                   Including a file: %s"%path)
            inc_dirs = include_dirs if include_dirs else self.include_dirs

            parser = LEMSFileParser(self, inc_dirs, self.include_includes)
            if os.access(path, os.F_OK):
                if not path in self.included_files:
                    parser.parse(open(path).read()) 
                    self.included_files.append(path)
                    return
                else:
                    if self.debug: print("Already included: %s"%path)
                    return
            else:
                for inc_dir in inc_dirs:
                    new_path = (inc_dir + '/' + path)
                    if os.access(new_path, os.F_OK):
                        if not new_path in self.included_files:
                            parser.parse(open(new_path).read())
                            self.included_files.append(new_path)
                            return
                        else:
                            if self.debug: print("Already included: %s"%path)
                            return
            msg = 'Unable to open ' + path
            if self.fail_on_missing_includes:
                raise Exception(msg)
            elif self.debug: 
                print(msg)
470578
def add_debugged_source_file(self, debugged_source_file):
    """"""
    # TODO(cais): Should the key include a host name, for certain distributed
    #   cases?
    key = debugged_source_file.file_path
    self._source_file_host[key] = debugged_source_file.host
    self._source_file_last_modified[key] = debugged_source_file.last_modified
    self._source_file_bytes[key] = debugged_source_file.bytes
    self._source_file_content[key] = debugged_source_file.lines
1177434
private boolean shouldExcludeSourceFile(CompilationUnitTree tree) {
    Pattern excludedPattern = errorProneOptions.getExcludedPattern();
    return excludedPattern != null
        && excludedPattern.matcher(ASTHelpers.getFileName(tree)).matches();
  }
804183
def add_source_override(self, fullname, path, source, is_pkg):
        
        self._finder.add_source_override(fullname, path, source, is_pkg)
921439
private function loadSource(){
		if ($this->args["source"]) {
			$source = $this->localize($this->args["source"]);

			if ($this->args["pecl"]) {
				$this->source = new SourceDir\Pecl($source);
			} elseif ($this->args["git"]) {
				$this->source = new SourceDir\Git($source);
			} elseif (is_file("$source/pharext_package.php")) {
				$this->source = include "$source/pharext_package.php";
			} else {
				$this->source = new SourceDir\Basic($source);
			}

			if (!$this->source instanceof SourceDir) {
				throw new Exception("Unknown source dir $source");
			}

			foreach ($this->source->getPackageInfo() as $key => $val) {
				/* do not override command line arguments */
				if (!isset($this->args->$key)) {
					$this->args->$key = $val;
				}
			}
		}
	}
1228287
public Source loadSource(Package lastPackage, String l, boolean is_generated) {
        Source s = Source.load(lastPackage, l, is_generated);
        lastPackage.addSource(s);
        sources.put(s.name(), s);
        return s;
    }
85135
def included(base = nil, &block)
      if base.nil?
        if instance_variable_defined?(:@_included_block)
          if @_included_block.source_location != block.source_location
            raise MultipleIncludedBlocks
          end
        else
          @_included_block = block
        end
      else
        super
      end
    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;
		}
    }
672033
def find_include_file(self, t):
        
        fname = t[2]
        for d in self.searchpath[t[1]]:
            if d == os.curdir:
                f = fname
            else:
                f = os.path.join(d, fname)
            if os.path.isfile(f):
                return f
        return None
1177183
void compileClass(Source javaSource, Source javaClass,
                    String sourcePath, boolean isMake)
    throws ClassNotFoundException
  {
    try {
      JavaCompilerUtil compiler = JavaCompilerUtil.create(getClassLoader());
      compiler.setClassDir(_classDir);
      compiler.setSourceDir(_sourceDir);
      if (_encoding != null)
        compiler.setEncoding(_encoding);
      compiler.setArgs(_args);
      compiler.setCompileParent(! isMake);
      compiler.setSourceExtension(_sourceExt);
      if (_compiler != null)
        compiler.setCompiler(_compiler);

      //LineMap lineMap = new LineMap(javaFile.getNativePath());
      // The context path is obvious from the browser url
      //lineMap.add(name.replace('.', '/') + _sourceExt, 1, 1);

      // Force this into a relative path so different compilers will work
      String prefix = _sourceDir.getPath();
      String full = javaSource.getPath();

      String source;
      if (full.startsWith(prefix)) {
        source = full.substring(prefix.length());
        if (source.startsWith("/"))
          source = source.substring(1);
      }
      else
        source = javaSource.getPath();

      /*
      if (javaSource.canRead() && javaClass.exists())
        javaClass.remove();
      */
          
      compiler.compileIfModified(source, null);
    } catch (Exception e) {
      //getClassLoader().addDependency(new Depend(javaSource));

      log.log(Level.FINEST, e.toString(), e);

      // Compile errors are wrapped in a special ClassNotFound class
      // so the server can give a nice error message
      throw new CompileClassNotFound(e);
    }
  }
19102
function includedFiles(name){
    let includes=this.getIncludes(this.getFile(name));
    let ret=includes.map(include => {
        let ret = {
            absolute:path.join(name,"../",include.relPath),
            relative:include.relPath,
            match:include.match
        }
        return ret;
    })
    return ret;
}
683935
def include(self, pattern):
        """"""
        found = [f for f in glob(pattern) if not os.path.isdir(f)]
        self.extend(found)
        return bool(found)
1164405
def include(self, node):
        """"""
        result = None
        if isinstance(node, ScalarNode):
            result = Loader.include_file(self.construct_scalar(node))
        else:
            raise RuntimeError("Not supported !include on type %s" % type(node))
        return result