Package org.codehaus.plexus.compiler.javac

Class JavacCompiler

java.lang.Object

org.codehaus.plexus.compiler.AbstractCompiler

org.codehaus.plexus.compiler.javac.JavacCompiler

All Implemented Interfaces:

Compiler

@Named("javac")
@Singleton
public class JavacCompiler
extends AbstractCompiler

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static enum	JavacCompiler.JavaVersion	Represents a particular Java version (through their according version prefixes)

Field Summary

Fields

Modifier and Type	Field	Description
private InProcessCompiler	inProcessCompiler
private static final Pattern	JAVA_MAJOR_AND_MINOR_VERSION_PATTERN
private static final String	JAVAC_CLASSNAME
private static final Pattern	JAVAC_OR_JVM_ERROR
private Class<?>	javacClass
private final Deque<Class<?>>	javacClasses
private static final Object	LOCK
private static final String[]	MISC_PREFIXES
private static final String[]	NOTE_PREFIXES
private static final Pattern	STACK_TRACE_FIRST_LINE
private static final Pattern	STACK_TRACE_OTHER_LINE
private static final Map<String,String>	VERSION_PER_EXECUTABLE	Cache of javac version per executable (never invalidated)
private static final String[]	WARNING_PREFIXES

Fields inherited from class org.codehaus.plexus.compiler.AbstractCompiler

EOL, PS

Fields inherited from interface org.codehaus.plexus.compiler.Compiler

ROLE

Constructor Summary

Constructors

Constructor	Description
JavacCompiler()

Method Summary

Modifier and Type	Method	Description
static String[]	buildCompilerArguments(CompilerConfiguration config, String[] sourceFiles, String javacVersion)
(package private) CompilerResult	compileInProcess(String[] args, CompilerConfiguration config)	Compile the java sources in the current JVM, without calling an external executable, using com.sun.tools.javac.Main class
private static CompilerResult	compileInProcess0(Class<?> javacClass, String[] args)	Helper method for compileInProcess()
protected CompilerResult	compileInProcessWithProperClassloader(Class<?> javacClass, String[] args)
protected CompilerResult	compileOutOfProcess(CompilerConfiguration config, String executable, String[] args)	Compile the java sources in a external process, calling an external executable, like javac.
String[]	createCommandLine(CompilerConfiguration config)	Create the command line that would be executed using this configuration.
private File	createFileWithArguments(String[] args, String outputDirectory)	put args into a temp file to be referenced using the @ option in javac command line
protected Class<?>	createJavacClass()	Helper method for create Javac class
(package private) static String	extractMajorAndMinorVersion(String text)
String	getCompilerId()
private String	getInProcessJavacVersion()
private Class<?>	getJavacClass(CompilerConfiguration compilerConfiguration)	Find the main class of JavaC.
private static String	getJavacExecutable()	Get the path of the javac tool executable: try to find it depending the OS or the java.home system property or the JAVA_HOME environment variable.
protected String	getJavacExecutable(CompilerConfiguration config)	Get the path of the javac tool executable to use.
private String	getOutOfProcessJavacVersion(String executable)
private static String	getWarnPrefix(String msg)
protected static boolean	hasJavaxToolProvider()
protected InProcessCompiler	inProcessCompiler()
private static boolean	isMisc(String line)
private static boolean	isNote(String line)
(package private) static CompilerMessage	parseModernError(int exitCode, String error)	Construct a CompilerMessage object from a line of the compiler output
(package private) static List<CompilerMessage>	parseModernStream(int exitCode, BufferedReader input)	Parse the output from the compiler into a list of CompilerMessage objects
CompilerResult	performCompile(CompilerConfiguration config)	Performs the compilation of the project.
private void	releaseJavaccClass(Class<?> javaccClass, CompilerConfiguration compilerConfiguration)
private static boolean	startsWithPrefix(String line, String[] prefixes)

Methods inherited from class org.codehaus.plexus.compiler.AbstractCompiler

canUpdateTarget, getCompilerOutputStyle, getInputFileEnding, getLog, getLogger, getOutputFile, getOutputFileEnding, getPathString, getSourceFiles, getSourceFilesForSourceRoot, logCompiling, makeClassName

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.codehaus.plexus.compiler.Compiler

supportsIncrementalCompilation

Field Details

WARNING_PREFIXES

private static final String[] WARNING_PREFIXES

NOTE_PREFIXES

private static final String[] NOTE_PREFIXES

MISC_PREFIXES

private static final String[] MISC_PREFIXES

LOCK

private static final Object LOCK

JAVAC_CLASSNAME

private static final String JAVAC_CLASSNAME

See Also:

• Constant Field Values

javacClass

private volatile Class<?> javacClass

javacClasses

private final Deque<Class<?>> javacClasses

JAVA_MAJOR_AND_MINOR_VERSION_PATTERN

private static final Pattern JAVA_MAJOR_AND_MINOR_VERSION_PATTERN

VERSION_PER_EXECUTABLE

private static final Map<String,String> VERSION_PER_EXECUTABLE

Cache of javac version per executable (never invalidated)

inProcessCompiler

@Inject
private InProcessCompiler inProcessCompiler

STACK_TRACE_FIRST_LINE

private static final Pattern STACK_TRACE_FIRST_LINE

STACK_TRACE_OTHER_LINE

private static final Pattern STACK_TRACE_OTHER_LINE

JAVAC_OR_JVM_ERROR

private static final Pattern JAVAC_OR_JVM_ERROR

Constructor Details

JavacCompiler

public JavacCompiler()

Method Details

getCompilerId

public String getCompilerId()

Specified by:

getCompilerId in class AbstractCompiler

getInProcessJavacVersion

private String getInProcessJavacVersion()
                                 throws CompilerException

Throws:

CompilerException

getOutOfProcessJavacVersion

private String getOutOfProcessJavacVersion(String executable)
                                    throws CompilerException

Throws:

CompilerException

extractMajorAndMinorVersion

static String extractMajorAndMinorVersion(String text)

performCompile

public CompilerResult performCompile(CompilerConfiguration config)
                              throws CompilerException

Description copied from interface: Compiler

Performs the compilation of the project. Clients must implement this method.

Specified by:

performCompile in interface Compiler

Overrides:

performCompile in class AbstractCompiler

Parameters:

config - the configuration description of the compilation to perform

Returns:

the result of the compilation returned by the language processor

Throws:

CompilerException

inProcessCompiler

protected InProcessCompiler inProcessCompiler()

hasJavaxToolProvider

protected static boolean hasJavaxToolProvider()

Returns:

true if the current context class loader has access to javax.tools.ToolProvider

createCommandLine

public String[] createCommandLine(CompilerConfiguration config)
                           throws CompilerException

Description copied from interface: Compiler

Create the command line that would be executed using this configuration. If this particular compiler has no concept of a command line then returns null.

Parameters:

config - the CompilerConfiguration describing the compilation

Returns:

an array of Strings that make up the command line, or null if this compiler has no concept of command line

Throws:

CompilerException - if there was an error generating the command line

buildCompilerArguments

public static String[] buildCompilerArguments(CompilerConfiguration config,
 String[] sourceFiles,
 String javacVersion)

compileOutOfProcess

protected CompilerResult compileOutOfProcess(CompilerConfiguration config,
 String executable,
 String[] args)
                                      throws CompilerException

Compile the java sources in a external process, calling an external executable, like javac.

Parameters:

config - compiler configuration

executable - name of the executable to launch

args - arguments for the executable launched

Returns:

a CompilerResult object encapsulating the result of the compilation and any compiler messages

Throws:

CompilerException

compileInProcess

CompilerResult compileInProcess(String[] args,
 CompilerConfiguration config)
                         throws CompilerException

Compile the java sources in the current JVM, without calling an external executable, using com.sun.tools.javac.Main class

Parameters:

args - arguments for the compiler as they would be used in the command line javac

config - compiler configuration

Returns:

a CompilerResult object encapsulating the result of the compilation and any compiler messages

Throws:

CompilerException

compileInProcessWithProperClassloader

protected CompilerResult compileInProcessWithProperClassloader(Class<?> javacClass,
 String[] args)
                                                        throws CompilerException

Throws:

CompilerException

compileInProcess0

private static CompilerResult compileInProcess0(Class<?> javacClass,
 String[] args)
                                         throws CompilerException

Helper method for compileInProcess()

Throws:

CompilerException

parseModernStream

static List<CompilerMessage> parseModernStream(int exitCode,
 BufferedReader input)
                                        throws IOException

Parse the output from the compiler into a list of CompilerMessage objects

Parameters:

exitCode - The exit code of javac.

input - The output of the compiler

Returns:

List of CompilerMessage objects

Throws:

IOException

isMisc

private static boolean isMisc(String line)

isNote

private static boolean isNote(String line)

startsWithPrefix

private static boolean startsWithPrefix(String line,
 String[] prefixes)

parseModernError

static CompilerMessage parseModernError(int exitCode,
 String error)

Construct a CompilerMessage object from a line of the compiler output

Parameters:

exitCode - The exit code from javac.

error - output line from the compiler

Returns:

the CompilerMessage object

getWarnPrefix

private static String getWarnPrefix(String msg)

createFileWithArguments

private File createFileWithArguments(String[] args,
 String outputDirectory)
                              throws IOException

put args into a temp file to be referenced using the @ option in javac command line

Parameters:

args -

Returns:

the temporary file wth the arguments

Throws:

IOException

getJavacExecutable

protected String getJavacExecutable(CompilerConfiguration config)

Get the path of the javac tool executable to use. Either given through explicit configuration or via getJavacExecutable().

Parameters:

config - the configuration

Returns:

the path of the javac tool

getJavacExecutable

private static String getJavacExecutable()
                                  throws IOException

Get the path of the javac tool executable: try to find it depending the OS or the java.home system property or the JAVA_HOME environment variable.

Returns:

the path of the javac tool

Throws:

IOException - if not found

releaseJavaccClass

private void releaseJavaccClass(Class<?> javaccClass,
 CompilerConfiguration compilerConfiguration)

getJavacClass

private Class<?> getJavacClass(CompilerConfiguration compilerConfiguration)
                        throws CompilerException

Find the main class of JavaC. Return the same class for subsequent calls.

Returns:

the non-null class.

Throws:

CompilerException - if the class has not been found.

createJavacClass

protected Class<?> createJavacClass()
                             throws CompilerException

Helper method for create Javac class

Throws:

CompilerException