Java Javac类代码示例

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
private void compileJavaVersionChecker() {
    PhetBuildUtils.antEcho( antTaskRunner, "Compiling java version checker for " + project.getName() + ".", getClass() );

    Javac javac = new Javac();
    javac.setIncludeantruntime( false );//see #2431, should not include full classpath if running from IDE
    javac.setSource( BuildToolsConstants.BOOTSTRAP_JAVA_VERSION );//Java version checker must be compiled in lowest language version
    javac.setTarget( BuildToolsConstants.BOOTSTRAP_JAVA_VERSION );//so it can run in lowest language version jvms
    javac.setClasspath( new Path( antTaskRunner.getProject(), new File( project.getTrunk(), BuildToolsPaths.JNLP_JAR ).getAbsolutePath() ) );
    javac.setSrcdir( new Path( antTaskRunner.getProject(), new File( project.getTrunk(), BuildToolsPaths.JAVA_COMMON + "/java-version-checker/src" ).getAbsolutePath() ) );
    javac.setDestdir( project.getClassesDirectory() );
    javac.setDebugLevel( "lines,source" );
    javac.setDebug( true );

    //if this fails, you may need to add Oracles's tools.jar to your working copy (ignored from svn for legal reasons)
    //see trunk/build-tools/contrib/sun-tools/readme.txt
    antTaskRunner.runTask( javac );

    PhetBuildUtils.antEcho( antTaskRunner, "Finished compiling java version checker for " + project.getName() + ".", getClass() );
}
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
@Override
public void setJavac(Javac attributes) {
        if (attributes.getTarget() == null) {
                attributes.setTarget("1.5");
        }
        if (attributes.getSource() == null) {
                attributes.setSource("1.5");
        }
        super.setJavac(attributes);
}
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
/**
 * Set the Javac instance which contains the configured compilation
 * attributes.
 *
 * @param attributes a configured Javac task.
 */
@Override
public void setJavac(final Javac attributes) {
    this.attributes = attributes;
    src = attributes.getSrcdir();
    destDir = attributes.getDestdir();
    encoding = attributes.getEncoding();
    debug = attributes.getDebug();
    optimize = attributes.getOptimize();
    deprecation = attributes.getDeprecation();
    depend = attributes.getDepend();
    verbose = attributes.getVerbose();
    target = attributes.getTarget();
    release = attributes.getRelease();
    bootclasspath = attributes.getBootclasspath();
    extdirs = attributes.getExtdirs();
    compileList = attributes.getFileList();
    compileClasspath = attributes.getClasspath();
    modulepath = attributes.getModulepath();
    upgrademodulepath = attributes.getUpgrademodulepath();
    compileSourcepath = attributes.getSourcepath();
    moduleSourcepath = attributes.getModulesourcepath();
    project = attributes.getProject();
    location = attributes.getLocation();
    includeAntRuntime = attributes.getIncludeantruntime();
    includeJavaRuntime = attributes.getIncludejavaruntime();
    memoryInitialSize = attributes.getMemoryInitialSize();
    memoryMaximumSize = attributes.getMemoryMaximumSize();
    if (moduleSourcepath != null && src == null && compileSourcepath == null) {
        //Compatibility to prevent NPE from Jikes, Jvc, Kjc
        compileSourcepath = new Path(getProject());
    }
}
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
/**
 * 设置需要的classpath.
 */
public static void setClassPath(Project p, Javac javac, ClassGenerator cg)
{
	Set paths = new HashSet();
	parseClassPath(cg.getClassLoader(), paths);
	Class[] arr = cg.getClassPaths();
	for (int i = 0; i < arr.length; i++)
	{
		parseClassPath(arr[i].getClassLoader(), paths);
	}
	ClassPathFilter filter = (ClassPathFilter) cg.getExtParam(ANT_CLASSPATH_FILTER);
	Iterator itr = paths.iterator();
	Path path = null;
	while (itr.hasNext())
	{
		String tmp = (String) itr.next();
		if (filter != null && !filter.isValid(tmp))
		{
			continue;
		}
		if (path == null)
		{
			path = new Path(p, tmp);
		}
		else
		{
			path.add(new Path(p, tmp));
		}
	}
	if (path != null)
	{
		javac.setClasspath(path);
		if (ClassGenerator.COMPILE_LOG_TYPE > COMPILE_LOG_TYPE_DEBUG)
		{
			log.info("Added classpath:" + path);
		}
	}
}
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
private void compileJava() {
    if ( useJavaVersionChecker ) {
        compileJavaVersionChecker();
    }

    File[] src = project.getAllJavaSourceRoots();
    File[] classpath = project.getAllJarFiles();

    // trace out all of the dependency information, since this can be very helpful in debugging the build process
    for ( PhetProject dependency : project.getAllDependencies() ) {
        System.out.println( "dependency: " + dependency.getName() );
        for ( File sourceRoot : dependency.getSourceRoots() ) {
            System.out.println( "\tsource path: " + sourceRoot.getAbsolutePath() );
        }
        for ( File jarFile : dependency.getJarFiles() ) {
            System.out.println( "\tclass path: " + jarFile.getAbsolutePath() );
        }
    }

    PhetBuildUtils.antEcho( antTaskRunner, "Compiling " + project.getName() + ".", getClass() );

    Javac javac = new Javac();
    javac.setIncludeantruntime( false );//see #2431, should not include full classpath if running from IDE
    javac.setSource( project.getJavaSourceVersion() );
    javac.setTarget( project.getJavaTargetVersion() );
    javac.setSrcdir( new Path( antTaskRunner.getProject(), toClasspathString( src ) ) );
    javac.setDestdir( project.getClassesDirectory() );

    //This block enables compilation of mixed java-scala sources by pointing the java compiler at the compiled scala source
    // see http://www.codecommit.com/blog/scala/joint-compilation-of-scala-and-java-sources
    if ( project.containsScalaSource() ) {
        ArrayList<File> all = new ArrayList<File>( Arrays.asList( classpath ) );
        all.add( project.getClassesDirectory() );
        classpath = all.toArray( new File[all.size()] );
    }

    javac.setClasspath( new Path( antTaskRunner.getProject(), project.getClasspath() ) );

    //"lines,source" appears to be necessary to get line number debug info
    javac.setDebugLevel( "lines,source" );
    javac.setDebug( true );

    antTaskRunner.runTask( javac );

    PhetBuildUtils.antEcho( antTaskRunner, "Finished compiling " + project.getName() + ".", getClass() );
}
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
private void compile() {
    Javac j = new Javac();
    j.setProject(getProject());
    j.setTaskName("compile");

    j.setSrcdir(new Path(getProject(), sources_path));

    File tmp;
    if (classes_path != null) {
        tmp = getProject().resolveFile(classes_path);
        if (!tmp.exists()) {
            if (!tmp.mkdir())
                throw new BuildException("Could not create temporary folder " + tmp.getAbsolutePath());
        }
    } else {
        // Generate temporary folder
        java.nio.file.Path p = mktemp();
        temporary.add(p);
        tmp = p.toFile();
        classes_path = tmp.getAbsolutePath();
    }

    j.setDestdir(tmp);
    // See "Setting Java Compiler Options" in User Guide
    j.setDebug(true);
    if (jckit.version == JC.V212) {
        j.setTarget("1.1");
        j.setSource("1.1");
        // Always set debug to disable "contains local variables,
        // but not local variable table." messages
        j.setDebug(true);
    } else if (jckit.version == JC.V221) {
        j.setTarget("1.2");
        j.setSource("1.2");
    } else {
        j.setTarget("1.5");
        j.setSource("1.5");
    }
    j.setIncludeantruntime(false);
    j.createCompilerArg().setValue("-Xlint");
    j.createCompilerArg().setValue("-Xlint:-options");
    j.createCompilerArg().setValue("-Xlint:-serial");

    j.setFailonerror(true);
    j.setFork(true);

    // set classpath
    Path cp = j.createClasspath();
    String api = null;
    if (jckit.version == JC.V3) {
        api = Paths.get(jckit.path, "lib", "api_classic.jar").toAbsolutePath().toString();
    } else if (jckit.version == JC.V212) { // V2.1.X
        api = Paths.get(jckit.path, "lib", "api21.jar").toAbsolutePath().toString();
    } else { // V2.2.X
        api = Paths.get(jckit.path, "lib", "api.jar").toAbsolutePath().toString();
    }
    cp.append(new Path(getProject(), api));
    for (JCImport i : raw_imports) {
        // Support import clauses with only jar or exp values
        if (i.jar != null) {
            cp.append(new Path(getProject(), i.jar));
        }
    }
    j.execute();
}
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
/**
 * Add the configured nested javac task if present to initiate joint compilation.
 */
public void addConfiguredJavac(final Javac javac) {
    this.javac = javac;
    jointCompilation = true;
}
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
/**
     * Compile generated code.
     *
     * @param outdir
     */
    private void compile(String outdir) throws Exception {
        String cp = null;
        try {
            BufferedReader br = new BufferedReader(
                    new FileReader(System.getProperty("basedir", ".") + "/target/cp.txt"));
            cp = br.readLine();
        } catch (Exception e) {
            // Don't care
        }
        if (cp == null) {
            cp = "";
        }

        //using the ant javac task for compilation
        Javac javaCompiler = new Javac();
        Project codeGenProject = new Project();
        Target compileTarget = new Target();

        compileTarget.setName(COMPILE_TARGET_NAME);
        compileTarget.addTask(javaCompiler);
        codeGenProject.addTarget(compileTarget);
        codeGenProject.setSystemProperties();
        javaCompiler.setProject(codeGenProject);
        javaCompiler.setIncludejavaruntime(true);
        javaCompiler.setIncludeantruntime(true);

        /*
          This harmless looking setFork is actually very important. unless the compiler is
          forked it wont work!
        */
        javaCompiler.setFork(true);

        //Create classpath - The generated output directories also become part of the classpath
        //reason for this is that some codegenerators(XMLBeans) produce compiled classes as part of
        //generated artifacts
        String classdir = outdir + "/classes";
        File outputLocationFile = new File(classdir);
        outputLocationFile.mkdir();
        Path classPath = new Path(codeGenProject, classdir);
        classPath.add(new Path(codeGenProject, TEST_CLASSES_DIR));
        classPath.addExisting(classPath.concatSystemClasspath(), false);
        for (int i = 0; i < moduleNames.length; i++) {
            classPath.add(new Path(codeGenProject,
                                   MODULE_PATH_PREFIX + moduleNames[i] + CLASSES_DIR));
        }
        classPath.add(new Path(codeGenProject, cp));

        javaCompiler.setClasspath(classPath);

        //set sourcePath - The generated output directories also become part of the sourcepath
        Path sourcePath = new Path(codeGenProject, outdir);
        sourcePath.setLocation(outputLocationFile);
        javaCompiler.setSrcdir(sourcePath);

        //output the classes into the output dir as well
        javaCompiler.setDestdir(outputLocationFile);
        javaCompiler.setDebug(true);
        javaCompiler.setVerbose(true);
        javaCompiler.execute();
//        codeGenProject.executeTarget(COMPILE_TARGET_NAME);
    }
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
/** @param outputLocation  */
private void compile(String outputLocation) {
    String cp = null;
    try {
        BufferedReader br = new BufferedReader(
                new FileReader(System.getProperty("basedir", ".") + "/target/cp.txt"));
        cp = br.readLine();
    } catch (Exception e) {
        // Don't care
    }
    if (cp == null) {
        cp = "";
    }

    //using the ant javac task for compilation
    Javac javaCompiler = new Javac();
    Project codeGenProject = new Project();
    Target compileTarget = new Target();

    compileTarget.setName(COMPILE_TARGET_NAME);
    compileTarget.addTask(javaCompiler);
    codeGenProject.addTarget(compileTarget);
    codeGenProject.setSystemProperties();
    javaCompiler.setProject(codeGenProject);
    javaCompiler.setIncludejavaruntime(true);
    javaCompiler.setIncludeantruntime(true);

    /*
      This harmless looking setFork is actually very important. unless the compiler is
      forked it wont work!
    */
    javaCompiler.setFork(true);

    //Create classpath - The generated output directories also become part of the classpath
    //reason for this is that some codegenerators(XMLBeans) produce compiled classes as part of
    //generated artifacts
    File outputLocationFile = new File(outputLocation);
    Path classPath = new Path(codeGenProject, outputLocation);
    classPath.addExisting(classPath.concatSystemClasspath(), false);
    for (int i = 0; i < moduleNames.length; i++) {
        classPath.add(new Path(codeGenProject,
                               MODULE_PATH_PREFIX + moduleNames[i] + CLASSES_DIR));
    }

    classPath.add(new Path(codeGenProject, cp));

    javaCompiler.setClasspath(classPath);

    //set sourcePath - The generated output directories also become part of the sourcepath
    Path sourcePath = new Path(codeGenProject, outputLocation);
    sourcePath.setLocation(outputLocationFile);
    javaCompiler.setSrcdir(sourcePath);

    //output the classes into the output dir as well
    javaCompiler.setDestdir(outputLocationFile);
    javaCompiler.setVerbose(true);
    javaCompiler.execute();

}
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
/**
 * Sets the compiler attributes, which are stored in the Javac task.
 * @param attributes the compiler attributes
 */
void setJavac(Javac attributes);
 

import org.apache.tools.ant.taskdefs.Javac; //导入依赖的package包/类
/**
 * Get the Javac task instance associated with this compiler adapter
 *
 * @return the configured Javac task instance used by this adapter.
 */
public Javac getJavac() {
    return attributes;
}