protected  void addCurrentCompilerArgs(Commandline cmd) 
{
        cmd.addArguments(getJavac().getCurrentCompilerArgs());
}

Adds the command line arguments specific to the current implementation.

 protected  void addExtdirsToClasspath(Path classpath) 
{
        classpath.addExtdirs(extdirs);
}

Add extdirs to classpath

 protected boolean assumeJava11() 
{
        return "javac1.1".equals(attributes.getCompilerVersion());
}

Shall we assume JDK 1.1 command line switches?

 protected boolean assumeJava12() 
{
        return "javac1.2".equals(attributes.getCompilerVersion())
            || ("classic".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_2))
            || ("extJavac".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_2));
}

Shall we assume JDK 1.2 command line switches?

 protected boolean assumeJava13() 
{
        return "javac1.3".equals(attributes.getCompilerVersion())
            || ("classic".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_3))
            || ("modern".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_3))
            || ("extJavac".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_3));
}

Shall we assume JDK 1.3 command line switches?

 protected boolean assumeJava14() 
{
        return "javac1.4".equals(attributes.getCompilerVersion())
            || ("classic".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_4))
            || ("modern".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_4))
            || ("extJavac".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_4));
}

Shall we assume JDK 1.4 command line switches?

 protected boolean assumeJava15() 
{
        return "javac1.5".equals(attributes.getCompilerVersion())
            || ("classic".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5))
            || ("modern".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5))
            || ("extJavac".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_5));
}

Shall we assume JDK 1.5 command line switches?

 protected boolean assumeJava16() 
{
        return "javac1.6".equals(attributes.getCompilerVersion())
            || ("classic".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6))
            || ("modern".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6))
            || ("extJavac".equals(attributes.getCompilerVersion())
                && JavaEnvUtils.isJavaVersion(JavaEnvUtils.JAVA_1_6));
}

Shall we assume JDK 1.6 command line switches?

 protected int executeExternalCompile(String[] args,
    int firstFileName) 
{
        return executeExternalCompile(args, firstFileName, true);
}

Do the compile with the specified arguments.

 protected int executeExternalCompile(String[] args,
    int firstFileName,
    boolean quoteFiles) 
{
        String[] commandArray = null;
        File tmpFile = null;
        try {
            /*
             * Many system have been reported to get into trouble with
             * long command lines - no, not only Windows ;-).
             *
             * POSIX seems to define a lower limit of 4k, so use a temporary
             * file if the total length of the command line exceeds this limit.
             */
            if (Commandline.toString(args).length()  > COMMAND_LINE_LIMIT
                && firstFileName  >= 0) {
                PrintWriter out = null;
                try {
                    tmpFile = FILE_UTILS.createTempFile(
                        "files", "", getJavac().getTempdir(), true, true);
                    out = new PrintWriter(new FileWriter(tmpFile));
                    for (int i = firstFileName; i <  args.length; i++) {
                        if (quoteFiles && args[i].indexOf(" ")  > -1) {
                            args[i] = args[i].replace(File.separatorChar, '/");
                            out.println("\"" + args[i] + "\"");
                        } else {
                            out.println(args[i]);
                        }
                    }
                    out.flush();
                    commandArray = new String[firstFileName + 1];
                    System.arraycopy(args, 0, commandArray, 0, firstFileName);
                    commandArray[firstFileName] = "@" + tmpFile;
                } catch (IOException e) {
                    throw new BuildException("Error creating temporary file",
                                             e, location);
                } finally {
                    FileUtils.close(out);
                }
            } else {
                commandArray = args;
            }
            try {
                Execute exe = new Execute(
                                  new LogStreamHandler(attributes,
                                                       Project.MSG_INFO,
                                                       Project.MSG_WARN));
                if (Os.isFamily("openvms")) {
                    //Use the VM launcher instead of shell launcher on VMS
                    //for java
                    exe.setVMLauncher(true);
                }
                exe.setAntRun(project);
                exe.setWorkingDirectory(project.getBaseDir());
                exe.setCommandline(commandArray);
                exe.execute();
                return exe.getExitValue();
            } catch (IOException e) {
                throw new BuildException("Error running " + args[0]
                        + " compiler", e, location);
            }
        } finally {
            if (tmpFile != null) {
                tmpFile.delete();
            }
        }
}

Do the compile with the specified arguments.

 protected Path getBootClassPath() 
{
        Path bp = new Path(project);
        if (bootclasspath != null) {
            bp.append(bootclasspath);
        }
        return bp.concatSystemBootClasspath("ignore");
}

Combines a user specified bootclasspath with the system bootclasspath taking build.sysclasspath into account.

 protected Path getCompileClasspath() 
{
        Path classpath = new Path(project);
        // add dest dir to classpath so that previously compiled and
        // untouched classes are on classpath
        if (destDir != null && getJavac().isIncludeDestClasses()) {
            classpath.setLocation(destDir);
        }
        // Combine the build classpath with the system classpath, in an
        // order determined by the value of build.sysclasspath
        Path cp = compileClasspath;
        if (cp == null) {
            cp = new Path(project);
        }
        if (includeAntRuntime) {
            classpath.addExisting(cp.concatSystemClasspath("last"));
        } else {
            classpath.addExisting(cp.concatSystemClasspath("ignore"));
        }
        if (includeJavaRuntime) {
            classpath.addJavaRuntime();
        }
        return classpath;
}

Builds the compilation classpath.

 public Javac getJavac() 
{
        return attributes;
}

Get the Javac task instance associated with this compiler adapter

 protected String getNoDebugArgument() 
{
        return assumeJava11() ? null : "-g:none";
}

The argument the compiler wants to see if the debug attribute has been set to false.

A return value of null means no argument at all.

 protected Project getProject() 
{
        return project;
}

Get the project this compiler adapter was created in.

 protected  void logAndAddFilesToCompile(Commandline cmd) 
{
        attributes.log("Compilation " + cmd.describeArguments(),
                       Project.MSG_VERBOSE);
        StringBuffer niceSourceList = new StringBuffer("File");
        if (compileList.length != 1) {
            niceSourceList.append("s");
        }
        niceSourceList.append(" to be compiled:");
        niceSourceList.append(StringUtils.LINE_SEP);
        for (int i = 0; i <  compileList.length; i++) {
            String arg = compileList[i].getAbsolutePath();
            cmd.createArgument().setValue(arg);
            niceSourceList.append("    ");
            niceSourceList.append(arg);
            niceSourceList.append(StringUtils.LINE_SEP);
        }
        attributes.log(niceSourceList.toString(), Project.MSG_VERBOSE);
}

Logs the compilation parameters, adds the files to compile and logs the "niceSourceList"

 public  void setJavac(Javac attributes) 
{
    // CheckStyle:ConstantNameCheck ON
    // CheckStyle:VisibilityModifier ON
        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();
        bootclasspath = attributes.getBootclasspath();
        extdirs = attributes.getExtdirs();
        compileList = attributes.getFileList();
        compileClasspath = attributes.getClasspath();
        compileSourcepath = attributes.getSourcepath();
        project = attributes.getProject();
        location = attributes.getLocation();
        includeAntRuntime = attributes.getIncludeantruntime();
        includeJavaRuntime = attributes.getIncludejavaruntime();
        memoryInitialSize = attributes.getMemoryInitialSize();
        memoryMaximumSize = attributes.getMemoryMaximumSize();
}

Set the Javac instance which contains the configured compilation attributes.

 protected Commandline setupJavacCommand() 
{
        return setupJavacCommand(false);
}

Set up the command line.

 protected Commandline setupJavacCommand(boolean debugLevelCheck) 
{
        Commandline cmd = new Commandline();
        setupJavacCommandlineSwitches(cmd, debugLevelCheck);
        logAndAddFilesToCompile(cmd);
        return cmd;
}

Does the command line argument processing for classic and adds the files to compile as well.

 protected Commandline setupJavacCommandlineSwitches(Commandline cmd) 
{
        return setupJavacCommandlineSwitches(cmd, false);
}

Get the command line arguments for the switches.

 protected Commandline setupJavacCommandlineSwitches(Commandline cmd,
    boolean useDebugLevel) 
{
        Path classpath = getCompileClasspath();
        // For -sourcepath, use the "sourcepath" value if present.
        // Otherwise default to the "srcdir" value.
        Path sourcepath = null;
        if (compileSourcepath != null) {
            sourcepath = compileSourcepath;
        } else {
            sourcepath = src;
        }
        String memoryParameterPrefix = assumeJava11() ? "-J-" : "-J-X";
        if (memoryInitialSize != null) {
            if (!attributes.isForkedJavac()) {
                attributes.log("Since fork is false, ignoring "
                               + "memoryInitialSize setting.",
                               Project.MSG_WARN);
            } else {
                cmd.createArgument().setValue(memoryParameterPrefix
                                              + "ms" + memoryInitialSize);
            }
        }
        if (memoryMaximumSize != null) {
            if (!attributes.isForkedJavac()) {
                attributes.log("Since fork is false, ignoring "
                               + "memoryMaximumSize setting.",
                               Project.MSG_WARN);
            } else {
                cmd.createArgument().setValue(memoryParameterPrefix
                                              + "mx" + memoryMaximumSize);
            }
        }
        if (attributes.getNowarn()) {
            cmd.createArgument().setValue("-nowarn");
        }
        if (deprecation) {
            cmd.createArgument().setValue("-deprecation");
        }
        if (destDir != null) {
            cmd.createArgument().setValue("-d");
            cmd.createArgument().setFile(destDir);
        }
        cmd.createArgument().setValue("-classpath");
        // Just add "sourcepath" to classpath ( for JDK1.1 )
        // as well as "bootclasspath" and "extdirs"
        if (assumeJava11()) {
            Path cp = new Path(project);
            Path bp = getBootClassPath();
            if (bp.size()  > 0) {
                cp.append(bp);
            }
            if (extdirs != null) {
                cp.addExtdirs(extdirs);
            }
            cp.append(classpath);
            cp.append(sourcepath);
            cmd.createArgument().setPath(cp);
        } else {
            cmd.createArgument().setPath(classpath);
            // If the buildfile specifies sourcepath="", then don't
            // output any sourcepath.
            if (sourcepath.size()  > 0) {
                cmd.createArgument().setValue("-sourcepath");
                cmd.createArgument().setPath(sourcepath);
            }
            if (target != null) {
                cmd.createArgument().setValue("-target");
                cmd.createArgument().setValue(target);
            }
            Path bp = getBootClassPath();
            if (bp.size()  > 0) {
                cmd.createArgument().setValue("-bootclasspath");
                cmd.createArgument().setPath(bp);
            }
            if (extdirs != null && extdirs.size()  > 0) {
                cmd.createArgument().setValue("-extdirs");
                cmd.createArgument().setPath(extdirs);
            }
        }
        if (encoding != null) {
            cmd.createArgument().setValue("-encoding");
            cmd.createArgument().setValue(encoding);
        }
        if (debug) {
            if (useDebugLevel && !assumeJava11()) {
                String debugLevel = attributes.getDebugLevel();
                if (debugLevel != null) {
                    cmd.createArgument().setValue("-g:" + debugLevel);
                } else {
                    cmd.createArgument().setValue("-g");
                }
            } else {
                cmd.createArgument().setValue("-g");
            }
        } else if (getNoDebugArgument() != null) {
            cmd.createArgument().setValue(getNoDebugArgument());
        }
        if (optimize) {
            cmd.createArgument().setValue("-O");
        }
        if (depend) {
            if (assumeJava11()) {
                cmd.createArgument().setValue("-depend");
            } else if (assumeJava12()) {
                cmd.createArgument().setValue("-Xdepend");
            } else {
                attributes.log("depend attribute is not supported by the "
                               + "modern compiler", Project.MSG_WARN);
            }
        }
        if (verbose) {
            cmd.createArgument().setValue("-verbose");
        }
        addCurrentCompilerArgs(cmd);
        return cmd;
}

Does the command line argument processing common to classic and modern. Doesn't add the files to compile.

 protected Commandline setupModernJavacCommand() 
{
        Commandline cmd = new Commandline();
        setupModernJavacCommandlineSwitches(cmd);
        logAndAddFilesToCompile(cmd);
        return cmd;
}

Does the command line argument processing for modern and adds the files to compile as well.

 protected Commandline setupModernJavacCommandlineSwitches(Commandline cmd) 
{
        setupJavacCommandlineSwitches(cmd, true);
        if (attributes.getSource() != null && !assumeJava13()) {
            cmd.createArgument().setValue("-source");
            String source = attributes.getSource();
            if (source.equals("1.1") || source.equals("1.2")) {
                // support for -source 1.1 and -source 1.2 has been
                // added with JDK 1.4.2 - and isn't present in 1.5.0
                // or 1.6.0 either
                cmd.createArgument().setValue("1.3");
            } else {
                cmd.createArgument().setValue(source);
            }
        } else if ((assumeJava15() || assumeJava16())
                   && attributes.getTarget() != null) {
            String t = attributes.getTarget();
            if (t.equals("1.1") || t.equals("1.2") || t.equals("1.3")
                || t.equals("1.4")) {
                String s = t;
                if (t.equals("1.1")) {
                    // 1.5.0 doesn't support -source 1.1
                    s = "1.2";
                }
                attributes.log("", Project.MSG_WARN);
                attributes.log("          WARNING", Project.MSG_WARN);
                attributes.log("", Project.MSG_WARN);
                attributes.log("The -source switch defaults to 1.5 in JDK 1.5 and 1.6.",
                               Project.MSG_WARN);
                attributes.log("If you specify -target " + t
                               + " you now must also specify -source " + s
                               + ".", Project.MSG_WARN);
                attributes.log("Ant will implicitly add -source " + s
                               + " for you.  Please change your build file.",
                               Project.MSG_WARN);
                cmd.createArgument().setValue("-source");
                cmd.createArgument().setValue(s);
            }
        }
        return cmd;
}

Does the command line argument processing for modern. Doesn't add the files to compile.