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
  • 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:
    • 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