Package org.codehaus.plexus.compiler.javac

Class JavacCompiler

    • Field Detail

      • WARNING_PREFIXES

        private static final java.lang.String[] WARNING_PREFIXES

      • NOTE_PREFIXES

        private static final java.lang.String[] NOTE_PREFIXES

      • MISC_PREFIXES

        private static final java.lang.String[] MISC_PREFIXES

      • LOCK

        private static final java.lang.Object LOCK

      • javacClass

        private volatile java.lang.Class<?> javacClass

      • javacClasses

        private final java.util.Deque<java.lang.Class<?>> javacClasses

      • JAVA_MAJOR_AND_MINOR_VERSION_PATTERN

        private static final java.util.regex.Pattern JAVA_MAJOR_AND_MINOR_VERSION_PATTERN

      • VERSION_PER_EXECUTABLE

        private static final java.util.Map<java.lang.String,​java.lang.String> VERSION_PER_EXECUTABLE
        Cache of javac version per executable (never invalidated)

      • STACK_TRACE_FIRST_LINE

        private static final java.util.regex.Pattern STACK_TRACE_FIRST_LINE

      • STACK_TRACE_OTHER_LINE

        private static final java.util.regex.Pattern STACK_TRACE_OTHER_LINE

      • JAVAC_OR_JVM_ERROR

        private static final java.util.regex.Pattern JAVAC_OR_JVM_ERROR

    • Constructor Detail

      • JavacCompiler

        public JavacCompiler()

    • Method Detail

      • extractMajorAndMinorVersion

        static java.lang.String extractMajorAndMinorVersion​(java.lang.String text)

      • hasJavaxToolProvider

        protected static boolean hasJavaxToolProvider()
        Returns:
        true if the current context class loader has access to javax.tools.ToolProvider

      • createCommandLine

        public java.lang.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 java.lang.String[] buildCompilerArguments​(CompilerConfiguration config,
                                                        java.lang.String[] sourceFiles,
                                                        java.lang.String javacVersion)

      • compileOutOfProcess

        protected CompilerResult compileOutOfProcess​(CompilerConfiguration config,
                                             java.lang.String executable,
                                             java.lang.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​(java.lang.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

      • parseModernStream

        static java.util.List<CompilerMessage> parseModernStream​(int exitCode,
                                                         java.io.BufferedReader input)
                                                  throws java.io.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:
        java.io.IOException

      • isMisc

        private static boolean isMisc​(java.lang.String line)

      • isNote

        private static boolean isNote​(java.lang.String line)

      • startsWithPrefix

        private static boolean startsWithPrefix​(java.lang.String line,
                                        java.lang.String[] prefixes)

      • parseModernError

        static CompilerMessage parseModernError​(int exitCode,
                                        java.lang.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 java.lang.String getWarnPrefix​(java.lang.String msg)

      • createFileWithArguments

        private java.io.File createFileWithArguments​(java.lang.String[] args,
                                             java.lang.String outputDirectory)
                                      throws java.io.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:
        java.io.IOException

      • getJavacExecutable

        protected java.lang.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 java.lang.String getJavacExecutable()
                                            throws java.io.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:
        java.io.IOException - if not found

      • releaseJavaccClass

        private void releaseJavaccClass​(java.lang.Class<?> javaccClass,
                                CompilerConfiguration compilerConfiguration)

      • getJavacClass

        private java.lang.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.