Java CompilerConfiguration.setScriptBaseClass方法代码示例

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
/**
 * performs groovy substitutions with this as delegate and inherited bindings
 */
protected String substitute(String before) {
    if (before.indexOf("${") == -1)
        return before;
    // escape all $ not followed by curly braces on same line
    before = before.replaceAll("\\$(?!\\{)", "\\\\\\$");
    // escape all regex -> ${~
    before = before.replaceAll("\\$\\{~", "\\\\\\$\\{~");
    // escape all escaped newlines
    before = before.replaceAll("\\\\n", "\\\\\\\\\\n");
    before = before.replaceAll("\\\\r", "\\\\\\\\\\r");
    // escape all escaped quotes
    before = before.replaceAll("\\\"", "\\\\\"");

    CompilerConfiguration compilerCfg = new CompilerConfiguration();
    compilerCfg.setScriptBaseClass(DelegatingScript.class.getName());
    GroovyShell shell = new GroovyShell(TestCaseScript.class.getClassLoader(), getBinding(), compilerCfg);
    DelegatingScript script = (DelegatingScript) shell.parse("return \"\"\"" + before + "\"\"\"");
    script.setDelegate(TestCaseScript.this);
    // restore escaped \$ to $ for comparison
    return script.run().toString().replaceAll("\\\\$", "\\$");
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
/**
 * Standalone execution for Designer and Gradle.
 */
public void run() {
    startExecution();

    CompilerConfiguration compilerConfig = new CompilerConfiguration(System.getProperties());
    compilerConfig.setScriptBaseClass(TestCaseScript.class.getName());
    Binding binding = new Binding();
    binding.setVariable("testCaseRun", this);

    ClassLoader classLoader = this.getClass().getClassLoader();
    GroovyShell shell = new GroovyShell(classLoader, binding, compilerConfig);
    shell.setProperty("out", getLog());
    setupContextClassLoader(shell);
    try {
        shell.run(new GroovyCodeSource(getTestCase().file()), new String[0]);
        finishExecution(null);
    }
    catch (IOException ex) {
        throw new RuntimeException(ex.getMessage(), ex);
    }
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
/**
 * Returns the builder object for creating new output variable value.
 */
protected void runScript(String mapperScript, Slurper slurper, Builder builder)
        throws ActivityException, TransformerException {

    CompilerConfiguration compilerConfig = new CompilerConfiguration();
    compilerConfig.setScriptBaseClass(CrossmapScript.class.getName());

    Binding binding = new Binding();
    binding.setVariable("runtimeContext", getRuntimeContext());
    binding.setVariable(slurper.getName(), slurper.getInput());
    binding.setVariable(builder.getName(), builder);
    GroovyShell shell = new GroovyShell(getPackage().getCloudClassLoader(), binding, compilerConfig);
    Script gScript = shell.parse(mapperScript);
    // gScript.setProperty("out", getRuntimeContext().get);
    gScript.run();
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
/**
 * Runs a Groovy DSL script and returns the value returned by the script.
 * @param scriptReader For reading the script text
 * @param expectedType The expected type of the return value
 * @param parameters Parameters used by the script, null or empty if the script doesn't need any
 * @param <T> The expected type of the return value
 * @return The return value of the script, not null
 */
private static <T> T runGroovyDslScript(Reader scriptReader, Class<T> expectedType, Map<String, Object> parameters) {
  Map<String, Object> timeoutArgs = ImmutableMap.<String, Object>of("value", 2);
  ASTTransformationCustomizer customizer = new ASTTransformationCustomizer(timeoutArgs, TimedInterrupt.class);
  CompilerConfiguration config = new CompilerConfiguration();
  config.addCompilationCustomizers(customizer);
  config.setScriptBaseClass(SimulationScript.class.getName());
  Map<String, Object> bindingMap = parameters == null ? Collections.<String, Object>emptyMap() : parameters;
  //copy map to ensure that binding is mutable (for use in registerAliases)
  Binding binding = new Binding(Maps.newHashMap(bindingMap));
  registerAliases(binding);
  GroovyShell shell = new GroovyShell(binding, config);
  Script script = shell.parse(scriptReader);
  Object scriptOutput = script.run();
  if (scriptOutput == null) {
    throw new IllegalArgumentException("Script " + scriptReader + " didn't return an object");
  }
  if (expectedType.isInstance(scriptOutput)) {
    return expectedType.cast(scriptOutput);
  } else {
    throw new IllegalArgumentException("Script '" + scriptReader + "' didn't create an object of the expected type. " +
        "expected type: " + expectedType.getName() + ", " +
        "actual type: " + scriptOutput.getClass().getName() + ", " +
        "actual value: " + scriptOutput);
  }
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
protected void ensureInitializedOrReloaded() {
    if (groovyClassLoader == null) {
        compilerConfiguration = new CompilerConfiguration(getCompilerConfigurationFactory().getCompilerConfiguration());
        if (getScriptBaseClass() != null) {
            compilerConfiguration.setScriptBaseClass(getScriptBaseClass());
        }

        groovyClassLoader = AccessController.doPrivileged((PrivilegedAction<GroovyClassLoader>)
                () -> new GroovyClassLoader(getParentClassLoaderFactory().getClassLoader(), compilerConfiguration));
        if (!scriptCache.isEmpty()) {
            // de-serialized: need to re-generate all previously compiled scripts (this can cause a hick-up...):
            for (ScriptCacheElement element : scriptCache.keySet()) {
                element.setScriptClass(compileScript(element.getBaseClass(), element.getScriptSource(), element.getScriptName()));
            }
        }
    }
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
private ImmutableList<BaseListener> buildClasses() {
	List<BaseListener> listeners = new ArrayList<>();
	CompilerConfiguration compiler = new CompilerConfiguration();
	compiler.setScriptBaseClass(BaseListener.class.getName());
	GroovyClassLoader loader = new GroovyClassLoader(this.getClass().getClassLoader(), compiler);
	paths.forEach(path -> {
		try {
			final Class clazz = loader.parseClass(path.toFile());
			BaseListener listener = (BaseListener) clazz.newInstance();
			listener.run();
			listener.init();
			listeners.add(listener);
		} catch (Exception e) {
			log.error("Error building or initializing groovy script " + path, e);
		}
	});
	return ImmutableList.copyOf(listeners);
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
@Override
public void loadByPath(Path path) throws Throwable {
	String id;
	if (Files.isDirectory(path)) {
		id = path.getFileName().toString();
		path = path.resolve("plugin.groovy");
	} else {
		if(path.getFileName().toString().equals("plugin.groovy"))
			id = path.getParent().getFileName().toString();
		else {
			id = path.getFileName().toString();
			id = id.substring(0, id.length() - 7);
		}
	}
	System.setProperty("groovy.grape.report.downloads", "true");
	CompilerConfiguration compilerConfiguration = new CompilerConfiguration();
	compilerConfiguration.setSourceEncoding("UTF-8");
	compilerConfiguration.setScriptBaseClass("info.deskchan.groovy_support.GroovyPlugin");
	compilerConfiguration.setClasspath(path.getParent().toString());
	GroovyShell groovyShell = new GroovyShell(compilerConfiguration);
	Script script = groovyShell.parse(path.toFile());
	GroovyPlugin plugin = (GroovyPlugin) script;
	plugin.setPluginDirPath(path.getParent());
	PluginConfig config = new PluginConfig("Groovy");
	path = path.getParent().resolve("manifest.json");
	config.appendFromJson(path);
	PluginManager.getInstance().initializePlugin(id, plugin, config);
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
private CompilerConfiguration createCompiler() throws AppException {
    CompilerConfiguration cc = new CompilerConfiguration();
    cc.setScriptBaseClass(ParsedScript.class.getName());
    Set<String> services = hostServices.getAvailableServices();
    for (String name : services) {
        PreHost pre = hostServices.getAvailablePreService(name).create();
        pre.configureCompiler(cc);
    }
    return cc;
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
public void run() {
    startExecution();
    try {
        if (testCase.getAsset().isFormat(Asset.POSTMAN)) {
            String runnerClass = NODE_PACKAGE + ".TestRunner";
            Package pkg = PackageCache.getPackage(testCase.getPackage());
            Class<?> testRunnerClass = CompiledJavaCache.getResourceClass(runnerClass, getClass().getClassLoader(), pkg);
            Object runner = testRunnerClass.newInstance();
            Method runMethod = testRunnerClass.getMethod("run", TestCase.class);
            runMethod.invoke(runner, testCase);
            finishExecution(null);
        }
        else {
            String groovyScript = testCase.getText();
            CompilerConfiguration compilerConfig = new CompilerConfiguration();
            compilerConfig.setScriptBaseClass(TestCaseScript.class.getName());

            Binding binding = new Binding();
            binding.setVariable("testCaseRun", this);

            ClassLoader classLoader = this.getClass().getClassLoader();
            Package testPkg = PackageCache.getPackage(testCase.getPackage());
            if (testPkg != null)
                classLoader = testPkg.getCloudClassLoader();

            GroovyShell shell = new GroovyShell(classLoader, binding, compilerConfig);
            Script gScript = shell.parse(groovyScript);
            gScript.setProperty("out", log);
            gScript.run();
            finishExecution(null);
        }
    }
    catch (Throwable ex) {
        finishExecution(ex);
    }
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
public void initialize(Reader resource) throws URISyntaxException, IOException {
    logger.info("Initializing from reader: " + resource);
    if (resource == null) {
        throw new NullPointerException("resource not found");
    }
    CompilerConfiguration cc = new CompilerConfiguration();
    cc.setScriptBaseClass(DelegatingScript.class.getName());
    GroovyShell shell = new GroovyShell(cc);
    DelegatingScript script = (DelegatingScript) shell.parse(resource);
    script.setDelegate(this);
    script.run();
    logger.info("Games available after initialization: " + games.keySet());
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
private static StandAloneScenarioScript runScript(File scriptFile) throws IOException {
  CompilerConfiguration config = new CompilerConfiguration();
  config.setScriptBaseClass(StandAloneScenarioScript.class.getName());
  GroovyShell shell = new GroovyShell(config);
  StandAloneScenarioScript script;

  try (Reader reader = new BufferedReader(new FileReader(scriptFile))) {
    script = (StandAloneScenarioScript) shell.parse(reader, scriptFile.getAbsolutePath());
  }
  Binding binding = new Binding();
  SimulationUtils.registerAliases(binding);
  script.setBinding(binding);
  script.run();
  return script;
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
/**
 * Gets the parameters.
 * 
 * @return the parameters, keyed by name
 */
@Override
@SuppressWarnings("unchecked")
public Map<String, Object> getParameters() {
  CompilerConfiguration config = new CompilerConfiguration();
  config.setScriptBaseClass(SimulationScript.class.getName());
  GroovyShell shell = new GroovyShell(config);
  Script script = shell.parse(new StringReader(_script));
  script.run();
  return script.getBinding().getVariables();
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
private static StandAloneScenarioScript createScript(String scriptText) {
  CompilerConfiguration config = new CompilerConfiguration();
  config.setScriptBaseClass(StandAloneScenarioScript.class.getName());
  GroovyShell shell = new GroovyShell(config);
  StandAloneScenarioScript script = (StandAloneScenarioScript) shell.parse(scriptText);
  Binding binding = new Binding();
  SimulationUtils.registerAliases(binding);
  script.setBinding(binding);
  script.run();
  return script;
}
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
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);
    }
 

import org.codehaus.groovy.control.CompilerConfiguration; //导入方法依赖的package包/类
public void testScriptWithDerivedBaseClass() throws Exception {
    Binding context = new Binding();
    CompilerConfiguration config = new CompilerConfiguration();
    config.setScriptBaseClass(DerivedScript.class.getName());
    GroovyShell shell = new GroovyShell(context, config);
    Object result = shell.evaluate("x = 'abc'; doSomething(cheese)");
    assertEquals("I like Cheddar", result);
    assertEquals("abc", context.getVariable("x"));
}