Java CompilerConfiguration.DEFAULT属性代码示例

private GroovyCodeBlockCompiler() {

        CompilerConfiguration conf = new CompilerConfiguration(CompilerConfiguration.DEFAULT);

        ImportCustomizer imports = new ImportCustomizer();
        imports.addStarImports("org.voltdb");
        imports.addImports(
                "org.voltdb.groovy.TableBuilder",
                "org.voltdb.groovy.Tuplerator",
                "org.voltdb.VoltProcedure.VoltAbortException"
                 );
        imports.addStaticStars("org.voltdb.VoltProcedure","org.voltdb.VoltType");

        conf.addCompilationCustomizers(imports);
        // conf.getOptimizationOptions().put("int", false);
        // conf.getOptimizationOptions().put("indy", true);
        conf.setScriptBaseClass(DelegatingScript.class.getName());

        File groovyOut = createGroovyOutDirectory();

        List<String> classPath = conf.getClasspath();
        classPath.add(groovyOut.getAbsolutePath());
        conf.setClasspathList(classPath);

        conf.setTargetDirectory(groovyOut);

        gcl = new GroovyClassLoader(Thread.currentThread().getContextClassLoader(), conf);
    }
 

@Override
protected CompilerConfiguration getCompilerConfiguration() {
    CompilerConfiguration configuration = new CompilerConfiguration(CompilerConfiguration.DEFAULT);
    configuration.setPluginFactory(new Antlr4PluginFactory());

    return configuration;
}
 

/**
 * creates a GroovyClassLoader.
 *
 * @param parent                    the parent class loader
 * @param config                    the compiler configuration
 * @param useConfigurationClasspath determines if the configurations classpath should be added
 */
public GroovyClassLoader(ClassLoader parent, CompilerConfiguration config, boolean useConfigurationClasspath) {
    super(EMPTY_URL_ARRAY, parent);
    if (config == null) config = CompilerConfiguration.DEFAULT;
    this.config = config;
    if (useConfigurationClasspath) {
        for (String path : config.getClasspath()) {
            this.addClasspath(path);
        }
    }

    initSourceEncoding(config);
}
 

private Class doParseClass(GroovyCodeSource codeSource) {
	validate(codeSource);
	Class answer; // Was neither already loaded nor compiling, so compile and add to cache.
	CompilerConfiguration config = CompilerConfiguration.DEFAULT;
	
	CompilationUnit unit = createCompilationUnit(config, codeSource.getCodeSource());
	
	SourceUnit su = null;
	if (codeSource.getFile() == null) {
		su = unit.addSource(codeSource.getName(), codeSource.getScriptText());
	}
	else {
		su = unit.addSource(codeSource.getFile());
	}
	
	MyClassCollector collector = createMyCollector(unit, su);
	
	unit.setClassgenCallback(collector);
	int goalPhase = Phases.CLASS_GENERATION;
	if (config != null && config.getTargetDirectory() != null)
		goalPhase = Phases.OUTPUT;
	unit.compile(goalPhase);
	@SuppressWarnings("unchecked")
	List<Class<?>> classList = (List<Class<?>>) collector.getLoadedClasses();
	answer = classList.get(0);
	String mainClass = su.getAST().getMainClassName();
	for (Object o : collector.getLoadedClasses()) {
		Class clazz = (Class) o;
		String clazzName = clazz.getName();
		definePackage(clazzName);
		setClassCacheEntry(clazz);
		if (clazzName.equals(mainClass))
			answer = clazz;
	}
	synchronized (classBytes) {
		this.classBytes.put(resolveName(answer.getName()) + ".class", collector.code);
	}
	return answer;
}
 

private synchronized void createClassLoader() {
    final CompilerConfiguration conf = new CompilerConfiguration(CompilerConfiguration.DEFAULT);
    conf.addCompilationCustomizers(this.importGroovyCustomizer.create());

    // ConfigurationCustomizerProvider is treated separately
    groovyCustomizers.stream().filter(cp -> !(cp instanceof ConfigurationGroovyCustomizer))
            .forEach(p -> conf.addCompilationCustomizers(p.create()));

    groovyCustomizers.stream().filter(cp -> cp instanceof ConfigurationGroovyCustomizer).findFirst()
            .ifPresent(cp -> ((ConfigurationGroovyCustomizer) cp).applyCustomization(conf));

    this.loader = new GremlinGroovyClassLoader(getParentLoader(), conf);
}
 

protected CompilerConfiguration prepareCompilerConfiguration() {
    return new CompilerConfiguration(CompilerConfiguration.DEFAULT);
}
 

@Override
protected CompilerConfiguration getCompilerConfiguration() {
    return CompilerConfiguration.DEFAULT;
}
 

public GroovyShell(ClassLoader parent, Binding binding) {
    this(parent, binding, CompilerConfiguration.DEFAULT);
}