extscript-core-root/extscript-core/src/main_old/java/org/apache/myfaces/extensions/scripting/loaders/java/compiler/JavacCompiler.java - myfaces-scripting - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.myfaces.extensions.scripting.loaders.java.compiler;

 import org.apache.myfaces.extensions.scripting.api.CompilationException;
 import org.apache.myfaces.extensions.scripting.api.CompilationResult;
 import org.apache.myfaces.extensions.scripting.api.CompilerConst;
 import org.apache.myfaces.extensions.scripting.api.ScriptingConst;
 import org.apache.myfaces.extensions.scripting.core.util.ClassLoaderUtils;
 import org.apache.myfaces.extensions.scripting.core.util.ClassUtils;
 import org.apache.myfaces.extensions.scripting.core.util.FileUtils;
 import org.apache.myfaces.extensions.scripting.core.util.WeavingContext;

 import java.io.File;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 import java.util.logging.Level;
 import java.util.logging.Logger;

 /**
  * <p>A compiler implementation that utilizes some internal classes that enable you to
  * compile Java source code using the javac compiler being provided by your JDK. However,
  * note that this only works if you're using a Sun JDK up to the version 1.5 (as of Java 6
  * you should use the JSR-199 API).</p>
  * <p/>
  * <p>This class loads some internal classes from $JAVA_HOME$/lib/tools.jar so be sure to
  * either include this JAR file in your classpath at startup or set the JAVA_HOME property
  * accordingly so that it points to a valid JDK home directory (it doesn't work if you're
  * just using a JRE!)</p>
  */
 public class JavacCompiler implements org.apache.myfaces.extensions.scripting.api.Compiler {

     /**
      * The logger instance for this class.
      */
     private static final Logger _logger = Logger.getLogger(JavacCompiler.class.getName());

     /**
      * The class name of the javac compiler. Note that this class
      * is only available if you're using a Sun JDK.
      */
     private static final String JAVAC_MAIN = "com.sun.tools.javac.Main";

     /**
      * The class reference to the internal Javac compiler.
      */
     private Class _compilerClass;

     // ------------------------------------------ Constructors

     /**
      * <p>Creates a new Javac compiler by searching for the required JAR file '$JAVA_HOME$/lib/tools.jar'
      * automatically. Note that the user has to specify the JAVA_HOME property in this case.</p>
      */
     public JavacCompiler() {
         this(null);
     }

     /**
      * <p>Creates a new Javac compiler by searching for internal classes in the given JAR file.</p>
      *
      * @param toolsJar the location of the JAR file '$JAVA_HOME$/lib/tools.jar' or <code>null</code>
      *                 if you want it to be searched for automatically
      */
     public JavacCompiler(URL toolsJar) {
         ClassLoader classLoader;

         try {
             classLoader = createJavacAwareClassLoader(toolsJar);
         } catch (MalformedURLException ex) {
             throw new IllegalStateException("An error occured while trying to load the Javac compiler class.", ex);
         }

         try {
             this._compilerClass = classLoader.loadClass(JAVAC_MAIN);
         } catch (ClassNotFoundException ex) {
             throw new IllegalStateException("The Javac compiler class '" + JAVAC_MAIN + "' couldn't be found even though" +
                     "the required JAR file '$JAVA_HOME$/lib/tools.jar' has been put on the classpath. Are you sure that " +
                     "you're using a valid Sun JDK?");
         }
     }

     // ------------------------------------------ Compiler methods

     /**
      * <p>Compiles the given file and creates an according class file in the given target path.</p>
      *
      * @param sourcePath the path to the source directory
      * @param targetPath the path to the target directory
      * @return the compilation result, i.e. as of now only the compiler output
      */
     public CompilationResult compile(File sourcePath, File targetPath, ClassLoader loader) throws CompilationException {
         FileUtils.assertPath(targetPath);

         try {
             StringWriter compilerOutput = new StringWriter();
             // Invoke the Javac compiler
             Method compile = _compilerClass.getMethod("compile", new Class[]{String[].class, PrintWriter.class});
             Object[] compilerArguments = new Object[]{buildCompilerArgumentsWhitelisted(sourcePath, targetPath, loader), new PrintWriter(compilerOutput)};
             logCommandLine(compilerArguments);

             Integer returnCode = (Integer) compile.invoke(null, compilerArguments);

             CompilationResult result = new CompilationResult(compilerOutput.toString());
             if (returnCode == null || returnCode.intValue() != 0) {
                 result.registerError(new CompilationResult.CompilationMessage(-1,
                         "Executing the javac compiler failed. The return code is '" + returnCode + "'." + compilerOutput.toString()));
             }
             WeavingContext.setCompilationResult(ScriptingConst.ENGINE_TYPE_JSF_JAVA, result);
             return result;
         } catch (NoSuchMethodException ex) {
             throw new CompilationException("The Javac compiler class '" + _compilerClass + "' doesn't provide the method " +
                     "compile(String, PrintWriter). Are you sure that you're using a valid Sun JDK?", ex);
         } catch (InvocationTargetException ex) {
             throw new CompilationException("An error occured while invoking the compile(String, PrintWriter) method of the " +
                     "Javac compiler class '" + _compilerClass + "'. Are you sure that you're using a valid Sun JDK?", ex);
         } catch (IllegalAccessException ex) {
             throw new CompilationException("An error occured while invoking the compile(String, PrintWriter) method of the " +
                     "Javac compiler class '" + _compilerClass + "'. Are you sure that you're using a valid Sun JDK?", ex);
         }

     }

     /**
      * <p>Compiles the given file and creates an according class file in the given target path.</p>
      *
      * @param sourcePath the path to the source directory
      * @param targetPath the path to the target directory
      * @param file       the relative file name of the class you want to compile
      * @return the compilation result, i.e. as of now only the compiler output
      */
     public CompilationResult compile(File sourcePath, File targetPath, File file, ClassLoader loader) throws CompilationException {
         // The destination directory must already exist as javac will not create the destination directory.
         FileUtils.assertPath(targetPath);

         try {
             StringWriter compilerOutput = new StringWriter();

             // Invoke the Javac compiler
             Method compile = _compilerClass.getMethod("compile", new Class[]{String[].class, PrintWriter.class});
             if (!targetPath.exists()) {
                 if (!targetPath.mkdirs()) {
                     throw new IllegalStateException("It wasn't possible to create the target " +
                             "directory for the compiler ['" + targetPath.getAbsolutePath() + "'].");
                 }
             }

             //TODO make a whitelist check here
             Object[] compilerArguments = new Object[]{buildCompilerArguments(sourcePath, targetPath, file.getAbsolutePath(), loader), new PrintWriter(compilerOutput)};
             logCommandLine(compilerArguments);

             Integer returnCode = (Integer) compile.invoke(null,
                     compilerArguments);

             CompilationResult result = new CompilationResult(compilerOutput.toString());
             if (returnCode == null || returnCode != 0) {
                 result.registerError(new CompilationResult.CompilationMessage(-1,
                         "Executing the javac compiler failed. The return code is '" + returnCode + "'." + compilerOutput.toString()));
             }
             WeavingContext.setCompilationResult(ScriptingConst.ENGINE_TYPE_JSF_JAVA, result);
             return result;
         } catch (NoSuchMethodException ex) {
             throw new IllegalStateException("The Javac compiler class '" + _compilerClass + "' doesn't provide the method " +
                     "compile(String, PrintWriter). Are you sure that you're using a valid Sun JDK?", ex);
         } catch (InvocationTargetException ex) {
             throw new IllegalStateException("An error occured while invoking the compile(String, PrintWriter) method of the " +
                     "Javac compiler class '" + _compilerClass + "'. Are you sure that you're using a valid Sun JDK?", ex);
         } catch (IllegalAccessException ex) {
             throw new IllegalStateException("An error occured while invoking the compile(String, PrintWriter) method of the " +
                     "Javac compiler class '" + _compilerClass + "'. Are you sure that you're using a valid Sun JDK?", ex);
         }
     }

     private void logCommandLine(Object[] compilerArguments) {
         if (_logger.isLoggable(Level.FINE)) {
             StringBuilder commandLine = new StringBuilder();
             commandLine.append("javac ");
             for (String compilerArgument : (String[]) compilerArguments[0]) {
                 commandLine.append(compilerArgument);
                 commandLine.append(" ");
             }
             _logger.log(Level.FINE, commandLine.toString());
         }
         if (_logger.isLoggable(Level.INFO)) {
             _logger.info("[EXT-SCRIPTING] compiling java");
         }

     }

     // ------------------------------------------ Utility methods

     /**
      * <p/>
      * Creates the arguments for the compiler, i.e. builds up an array of arguments
      * that one would pass to the javac compiler to compile a full path instead of a single file
      *
      * @param sourcePath the path to the source directory
      * @param targetPath the path to the target directory
      * @return an array of arguments that you have to pass to the Javac compiler
      */
     protected String[] buildCompilerArgumentsWhitelisted(File sourcePath, File targetPath, ClassLoader loader) {
         List<File> sourceFiles = FileUtils.fetchSourceFiles(WeavingContext.getConfiguration().getWhitelistedSourceDirs(ScriptingConst.ENGINE_TYPE_JSF_JAVA), "*.java");

         List arguments = getDefaultArguments(sourcePath, targetPath, loader);

         // Append the source file that is to be compiled. Note that the user specifies only a relative file location.
         for (File sourceFile : sourceFiles) {
             arguments.add(sourceFile.getAbsolutePath());
         }
         return (String[]) argumentsToArray(arguments);
     }

     private Object[] argumentsToArray(List arguments) {
         return arguments.toArray(new String[arguments.size()]);
     }

     /**
      * <p/>
      * Creates the arguments for the compiler, i.e. builds up an array of arguments
      * that one would pass to the javac compiler to compile a full path instead of a single file
      *
      * @param sourcePath the path to the source directory
      * @param targetPath the path to the target directory
      * @return an array of arguments that you have to pass to the Javac compiler
      */
     protected String[] buildCompilerArguments(File sourcePath, File targetPath, ClassLoader loader) {
         List<File> sourceFiles = FileUtils.fetchSourceFiles(sourcePath, "*.java");

         List arguments = getDefaultArguments(sourcePath, targetPath, loader);

         // Append the source file that is to be compiled. Note that the user specifies only a relative file location.
         for (File sourceFile : sourceFiles) {
             arguments.add(sourceFile.getAbsolutePath());
         }
         return (String[]) argumentsToArray(arguments);
     }

     /**
      * <p>Creates the arguments for the compiler, i.e. it builds an array of arguments that one would pass to
      * the Javac compiler on the command line.</p>
      *
      * @param sourcePath the path to the source directory
      * @param targetPath the path to the target directory
      * @param loader     the classpath holder for the compiler
      * @param file       the relative file name of the class you want to compile
      * @return an array of arguments that you have to pass to the Javac compiler
      */
     protected String[] buildCompilerArguments(File sourcePath, File targetPath, String file, ClassLoader loader) {
         List arguments = getDefaultArguments(sourcePath, targetPath, loader);

         // Append the source file that is to be compiled. Note that the user specifies only a relative file location.
         arguments.add(new File(sourcePath, file).getAbsolutePath());

         return (String[]) argumentsToArray(arguments);
     }

     /**
      * <p>
      * Determination of the default arguments
      * which have to be the same over all
      * different compilation strategies
      * </p>
      *
      * @param sourcePath the path to the source directory
      * @param targetPath the path to the target directory
      * @param loader     the classloader holding the classpath
      * @return
      */
     private List getDefaultArguments(File sourcePath, File targetPath, ClassLoader loader) {
         List arguments = new ArrayList();

         // Set both the source code path to search for class or interface
         // definitions and the destination directory for class files.
         arguments.add(CompilerConst.JC_SOURCEPATH);
         arguments.add(sourcePath.getAbsolutePath());
         arguments.add(CompilerConst.JC_TARGET_PATH);
         arguments.add(targetPath.getAbsolutePath());
         arguments.add(CompilerConst.JC_CLASSPATH);
         arguments.add(ClassLoaderUtils.buildClasspath(loader));

         // Enable verbose output.
         arguments.add(CompilerConst.JC_VERBOSE);

         // Generate all debugging information, including local variables.
         arguments.add(CompilerConst.JC_DEBUG);
         return arguments;
     }

     /**
      * <p>Returns a possibly newly created classloader that you can use in order to load the
      * Javac compiler class. Usually the user would have to put the JAR file
      * '$JAVA_HOME$/lib/tools.jar' on the classpath but this method recognizes this on its own
      * and loads the JAR file if necessary. However, it's not guaranteed that the Javac compiler
      * class is available (e.g. if one is providing a wrong tools.jar file that doesn't contain
      * the required classes).</p>
      *
      * @param toolsJar the location of the JAR file '$JAVA_HOME$/lib/tools.jar' or <code>null</code>
      *                 if you want it to be searched for automatically
      * @return a classloader that you can use in order to load the Javac compiler class
      * @throws MalformedURLException if an error occurred while constructing the URL
      */
     private static ClassLoader createJavacAwareClassLoader(URL toolsJar) throws MalformedURLException {
         // If the user has already included the tools.jar in the classpath we don't have
         // to create a custom class loader as the class is already available.
         if (ClassUtils.isPresent(JAVAC_MAIN)) {
             if (_logger.isLoggable(Level.FINE)) {
                 _logger.log(Level.FINE, "Seemingly the required JAR file '$JAVA_HOME$/lib/tools.jar' has already been "
                         + "put on the classpath as the class '" + JAVAC_MAIN + "' is present. So there's no "
                         + "need to create a custom classloader for the Javac compiler.");
             }

             return ClassUtils.getContextClassLoader();
         } else {
             // The compiler isn't available in the current classpath, but the user could have specified the tools.jar file.
             if (toolsJar == null) {
                 String javaHome = System.getProperty("java.home");
                 if (javaHome.toLowerCase(Locale.getDefault()).endsWith(File.separator + "jre")) {
                     // Note that even if the user has installed a valid JDK the $JAVA_HOME$ property might reference
                     // the JRE, e.g. '/usr/lib/jvm/java-6-sun-1.6.0.16/jre'. However, in this case we just have to
                     // remove the last four characters (i.e. the '/jre').
                     javaHome = javaHome.substring(0, javaHome.length() - 4);
                 }

                 // If the user hasn't specified the URL to the tools.jar file, we'll try to find it on our own.
                 File toolsJarFile = new File(javaHome, "lib" + File.separatorChar + "tools.jar");
                 if (toolsJarFile.exists()) {
                     if (_logger.isLoggable(Level.FINE)) {
                         _logger.log(Level.FINE,
                                 "The required JAR file '$JAVA_HOME$/lib/tools.jar' has been found ['" + toolsJarFile.getAbsolutePath()
                                         + "']. A custom URL classloader will be created for the Javac compiler.");
                     }

                     return new URLClassLoader(
                             new URL[]{toolsJarFile.toURI().toURL()}, ClassUtils.getContextClassLoader());
                 } else {
                     throw new IllegalStateException("The Javac compiler class '" + JAVAC_MAIN + "' and the required JAR file " +
                             "'$JAVA_HOME$/lib/tools.jar' couldn't be found. Are you sure that you're using a valid Sun JDK? " +
                             "[$JAVA_HOME$: '" + System.getProperty("java.home") + "']");
                 }
             } else {
                 if (_logger.isLoggable(Level.FINE)) {
                     _logger.log(Level.FINE, "The user has specified the required JAR file '$JAVA_HOME$/lib/tools.jar' ['"
                             + toolsJar.toExternalForm() + "']. A custom URL classloader will be created for the Javac compiler.");
                 }

                 return new URLClassLoader(new URL[]{toolsJar}, ClassUtils.getContextClassLoader());
             }
         }
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/
	package org.apache.myfaces.extensions.scripting.loaders.java.compiler;

	import org.apache.myfaces.extensions.scripting.api.CompilationException;
	import org.apache.myfaces.extensions.scripting.api.CompilationResult;
	import org.apache.myfaces.extensions.scripting.api.CompilerConst;
	import org.apache.myfaces.extensions.scripting.api.ScriptingConst;
	import org.apache.myfaces.extensions.scripting.core.util.ClassLoaderUtils;
	import org.apache.myfaces.extensions.scripting.core.util.ClassUtils;
	import org.apache.myfaces.extensions.scripting.core.util.FileUtils;
	import org.apache.myfaces.extensions.scripting.core.util.WeavingContext;

	import java.io.File;
	import java.io.PrintWriter;
	import java.io.StringWriter;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.net.MalformedURLException;
	import java.net.URL;
	import java.net.URLClassLoader;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Locale;
	import java.util.logging.Level;
	import java.util.logging.Logger;

	/**
	* <p>A compiler implementation that utilizes some internal classes that enable you to
	* compile Java source code using the javac compiler being provided by your JDK. However,
	* note that this only works if you're using a Sun JDK up to the version 1.5 (as of Java 6
	* you should use the JSR-199 API).</p>
	* <p/>
	* <p>This class loads some internal classes from $JAVA_HOME$/lib/tools.jar so be sure to
	* either include this JAR file in your classpath at startup or set the JAVA_HOME property
	* accordingly so that it points to a valid JDK home directory (it doesn't work if you're
	* just using a JRE!)</p>
	*/
	public class JavacCompiler implements org.apache.myfaces.extensions.scripting.api.Compiler {

	/**
	* The logger instance for this class.
	*/
	private static final Logger _logger = Logger.getLogger(JavacCompiler.class.getName());

	/**
	* The class name of the javac compiler. Note that this class
	* is only available if you're using a Sun JDK.
	*/
	private static final String JAVAC_MAIN = "com.sun.tools.javac.Main";

	/**
	* The class reference to the internal Javac compiler.
	*/
	private Class _compilerClass;

	// ------------------------------------------ Constructors

	/**
	* <p>Creates a new Javac compiler by searching for the required JAR file '$JAVA_HOME$/lib/tools.jar'
	* automatically. Note that the user has to specify the JAVA_HOME property in this case.</p>
	*/
	public JavacCompiler() {
	this(null);
	}

	/**
	* <p>Creates a new Javac compiler by searching for internal classes in the given JAR file.</p>
	*
	* @param toolsJar the location of the JAR file '$JAVA_HOME$/lib/tools.jar' or <code>null</code>
	* if you want it to be searched for automatically
	*/
	public JavacCompiler(URL toolsJar) {
	ClassLoader classLoader;

	try {
	classLoader = createJavacAwareClassLoader(toolsJar);
	} catch (MalformedURLException ex) {
	throw new IllegalStateException("An error occured while trying to load the Javac compiler class.", ex);
	}

	try {
	this._compilerClass = classLoader.loadClass(JAVAC_MAIN);
	} catch (ClassNotFoundException ex) {
	throw new IllegalStateException("The Javac compiler class '" + JAVAC_MAIN + "' couldn't be found even though" +
	"the required JAR file '$JAVA_HOME$/lib/tools.jar' has been put on the classpath. Are you sure that " +
	"you're using a valid Sun JDK?");
	}
	}

	// ------------------------------------------ Compiler methods

	/**
	* <p>Compiles the given file and creates an according class file in the given target path.</p>
	*
	* @param sourcePath the path to the source directory
	* @param targetPath the path to the target directory
	* @return the compilation result, i.e. as of now only the compiler output
	*/
	public CompilationResult compile(File sourcePath, File targetPath, ClassLoader loader) throws CompilationException {
	FileUtils.assertPath(targetPath);

	try {
	StringWriter compilerOutput = new StringWriter();
	// Invoke the Javac compiler
	Method compile = _compilerClass.getMethod("compile", new Class[]{String[].class, PrintWriter.class});
	Object[] compilerArguments = new Object[]{buildCompilerArgumentsWhitelisted(sourcePath, targetPath, loader), new PrintWriter(compilerOutput)};
	logCommandLine(compilerArguments);

	Integer returnCode = (Integer) compile.invoke(null, compilerArguments);

	CompilationResult result = new CompilationResult(compilerOutput.toString());
	if (returnCode == null \|\| returnCode.intValue() != 0) {
	result.registerError(new CompilationResult.CompilationMessage(-1,
	"Executing the javac compiler failed. The return code is '" + returnCode + "'." + compilerOutput.toString()));
	}
	WeavingContext.setCompilationResult(ScriptingConst.ENGINE_TYPE_JSF_JAVA, result);
	return result;
	} catch (NoSuchMethodException ex) {
	throw new CompilationException("The Javac compiler class '" + _compilerClass + "' doesn't provide the method " +
	"compile(String, PrintWriter). Are you sure that you're using a valid Sun JDK?", ex);
	} catch (InvocationTargetException ex) {
	throw new CompilationException("An error occured while invoking the compile(String, PrintWriter) method of the " +
	"Javac compiler class '" + _compilerClass + "'. Are you sure that you're using a valid Sun JDK?", ex);
	} catch (IllegalAccessException ex) {
	throw new CompilationException("An error occured while invoking the compile(String, PrintWriter) method of the " +
	"Javac compiler class '" + _compilerClass + "'. Are you sure that you're using a valid Sun JDK?", ex);
	}

	}

	/**
	* <p>Compiles the given file and creates an according class file in the given target path.</p>
	*
	* @param sourcePath the path to the source directory
	* @param targetPath the path to the target directory
	* @param file the relative file name of the class you want to compile
	* @return the compilation result, i.e. as of now only the compiler output
	*/
	public CompilationResult compile(File sourcePath, File targetPath, File file, ClassLoader loader) throws CompilationException {
	// The destination directory must already exist as javac will not create the destination directory.
	FileUtils.assertPath(targetPath);

	try {
	StringWriter compilerOutput = new StringWriter();

	// Invoke the Javac compiler
	Method compile = _compilerClass.getMethod("compile", new Class[]{String[].class, PrintWriter.class});
	if (!targetPath.exists()) {
	if (!targetPath.mkdirs()) {
	throw new IllegalStateException("It wasn't possible to create the target " +
	"directory for the compiler ['" + targetPath.getAbsolutePath() + "'].");
	}
	}

	//TODO make a whitelist check here
	Object[] compilerArguments = new Object[]{buildCompilerArguments(sourcePath, targetPath, file.getAbsolutePath(), loader), new PrintWriter(compilerOutput)};
	logCommandLine(compilerArguments);

	Integer returnCode = (Integer) compile.invoke(null,
	compilerArguments);

	CompilationResult result = new CompilationResult(compilerOutput.toString());
	if (returnCode == null \|\| returnCode != 0) {
	result.registerError(new CompilationResult.CompilationMessage(-1,
	"Executing the javac compiler failed. The return code is '" + returnCode + "'." + compilerOutput.toString()));
	}
	WeavingContext.setCompilationResult(ScriptingConst.ENGINE_TYPE_JSF_JAVA, result);
	return result;
	} catch (NoSuchMethodException ex) {
	throw new IllegalStateException("The Javac compiler class '" + _compilerClass + "' doesn't provide the method " +
	"compile(String, PrintWriter). Are you sure that you're using a valid Sun JDK?", ex);
	} catch (InvocationTargetException ex) {
	throw new IllegalStateException("An error occured while invoking the compile(String, PrintWriter) method of the " +
	"Javac compiler class '" + _compilerClass + "'. Are you sure that you're using a valid Sun JDK?", ex);
	} catch (IllegalAccessException ex) {
	throw new IllegalStateException("An error occured while invoking the compile(String, PrintWriter) method of the " +
	"Javac compiler class '" + _compilerClass + "'. Are you sure that you're using a valid Sun JDK?", ex);
	}
	}

	private void logCommandLine(Object[] compilerArguments) {
	if (_logger.isLoggable(Level.FINE)) {
	StringBuilder commandLine = new StringBuilder();
	commandLine.append("javac ");
	for (String compilerArgument : (String[]) compilerArguments[0]) {
	commandLine.append(compilerArgument);
	commandLine.append(" ");
	}
	_logger.log(Level.FINE, commandLine.toString());
	}
	if (_logger.isLoggable(Level.INFO)) {
	_logger.info("[EXT-SCRIPTING] compiling java");
	}

	}

	// ------------------------------------------ Utility methods

	/**
	* <p/>
	* Creates the arguments for the compiler, i.e. builds up an array of arguments
	* that one would pass to the javac compiler to compile a full path instead of a single file
	*
	* @param sourcePath the path to the source directory
	* @param targetPath the path to the target directory
	* @return an array of arguments that you have to pass to the Javac compiler
	*/
	protected String[] buildCompilerArgumentsWhitelisted(File sourcePath, File targetPath, ClassLoader loader) {
	List<File> sourceFiles = FileUtils.fetchSourceFiles(WeavingContext.getConfiguration().getWhitelistedSourceDirs(ScriptingConst.ENGINE_TYPE_JSF_JAVA), "*.java");

	List arguments = getDefaultArguments(sourcePath, targetPath, loader);

	// Append the source file that is to be compiled. Note that the user specifies only a relative file location.
	for (File sourceFile : sourceFiles) {
	arguments.add(sourceFile.getAbsolutePath());
	}
	return (String[]) argumentsToArray(arguments);
	}

	private Object[] argumentsToArray(List arguments) {
	return arguments.toArray(new String[arguments.size()]);
	}

	/**
	* <p/>
	* Creates the arguments for the compiler, i.e. builds up an array of arguments
	* that one would pass to the javac compiler to compile a full path instead of a single file
	*
	* @param sourcePath the path to the source directory
	* @param targetPath the path to the target directory
	* @return an array of arguments that you have to pass to the Javac compiler
	*/
	protected String[] buildCompilerArguments(File sourcePath, File targetPath, ClassLoader loader) {
	List<File> sourceFiles = FileUtils.fetchSourceFiles(sourcePath, "*.java");

	List arguments = getDefaultArguments(sourcePath, targetPath, loader);

	// Append the source file that is to be compiled. Note that the user specifies only a relative file location.
	for (File sourceFile : sourceFiles) {
	arguments.add(sourceFile.getAbsolutePath());
	}
	return (String[]) argumentsToArray(arguments);
	}

	/**
	* <p>Creates the arguments for the compiler, i.e. it builds an array of arguments that one would pass to
	* the Javac compiler on the command line.</p>
	*
	* @param sourcePath the path to the source directory
	* @param targetPath the path to the target directory
	* @param loader the classpath holder for the compiler
	* @param file the relative file name of the class you want to compile
	* @return an array of arguments that you have to pass to the Javac compiler
	*/
	protected String[] buildCompilerArguments(File sourcePath, File targetPath, String file, ClassLoader loader) {
	List arguments = getDefaultArguments(sourcePath, targetPath, loader);

	// Append the source file that is to be compiled. Note that the user specifies only a relative file location.
	arguments.add(new File(sourcePath, file).getAbsolutePath());

	return (String[]) argumentsToArray(arguments);
	}

	/**
	* <p>
	* Determination of the default arguments
	* which have to be the same over all
	* different compilation strategies
	* </p>
	*
	* @param sourcePath the path to the source directory
	* @param targetPath the path to the target directory
	* @param loader the classloader holding the classpath
	* @return
	*/
	private List getDefaultArguments(File sourcePath, File targetPath, ClassLoader loader) {
	List arguments = new ArrayList();

	// Set both the source code path to search for class or interface
	// definitions and the destination directory for class files.
	arguments.add(CompilerConst.JC_SOURCEPATH);
	arguments.add(sourcePath.getAbsolutePath());
	arguments.add(CompilerConst.JC_TARGET_PATH);
	arguments.add(targetPath.getAbsolutePath());
	arguments.add(CompilerConst.JC_CLASSPATH);
	arguments.add(ClassLoaderUtils.buildClasspath(loader));

	// Enable verbose output.
	arguments.add(CompilerConst.JC_VERBOSE);

	// Generate all debugging information, including local variables.
	arguments.add(CompilerConst.JC_DEBUG);
	return arguments;
	}

	/**
	* <p>Returns a possibly newly created classloader that you can use in order to load the
	* Javac compiler class. Usually the user would have to put the JAR file
	* '$JAVA_HOME$/lib/tools.jar' on the classpath but this method recognizes this on its own
	* and loads the JAR file if necessary. However, it's not guaranteed that the Javac compiler
	* class is available (e.g. if one is providing a wrong tools.jar file that doesn't contain
	* the required classes).</p>
	*
	* @param toolsJar the location of the JAR file '$JAVA_HOME$/lib/tools.jar' or <code>null</code>
	* if you want it to be searched for automatically
	* @return a classloader that you can use in order to load the Javac compiler class
	* @throws MalformedURLException if an error occurred while constructing the URL
	*/
	private static ClassLoader createJavacAwareClassLoader(URL toolsJar) throws MalformedURLException {
	// If the user has already included the tools.jar in the classpath we don't have
	// to create a custom class loader as the class is already available.
	if (ClassUtils.isPresent(JAVAC_MAIN)) {
	if (_logger.isLoggable(Level.FINE)) {
	_logger.log(Level.FINE, "Seemingly the required JAR file '$JAVA_HOME$/lib/tools.jar' has already been "
	+ "put on the classpath as the class '" + JAVAC_MAIN + "' is present. So there's no "
	+ "need to create a custom classloader for the Javac compiler.");
	}

	return ClassUtils.getContextClassLoader();
	} else {
	// The compiler isn't available in the current classpath, but the user could have specified the tools.jar file.
	if (toolsJar == null) {
	String javaHome = System.getProperty("java.home");
	if (javaHome.toLowerCase(Locale.getDefault()).endsWith(File.separator + "jre")) {
	// Note that even if the user has installed a valid JDK the $JAVA_HOME$ property might reference
	// the JRE, e.g. '/usr/lib/jvm/java-6-sun-1.6.0.16/jre'. However, in this case we just have to
	// remove the last four characters (i.e. the '/jre').
	javaHome = javaHome.substring(0, javaHome.length() - 4);
	}

	// If the user hasn't specified the URL to the tools.jar file, we'll try to find it on our own.
	File toolsJarFile = new File(javaHome, "lib" + File.separatorChar + "tools.jar");
	if (toolsJarFile.exists()) {
	if (_logger.isLoggable(Level.FINE)) {
	_logger.log(Level.FINE,
	"The required JAR file '$JAVA_HOME$/lib/tools.jar' has been found ['" + toolsJarFile.getAbsolutePath()
	+ "']. A custom URL classloader will be created for the Javac compiler.");
	}

	return new URLClassLoader(
	new URL[]{toolsJarFile.toURI().toURL()}, ClassUtils.getContextClassLoader());
	} else {
	throw new IllegalStateException("The Javac compiler class '" + JAVAC_MAIN + "' and the required JAR file " +
	"'$JAVA_HOME$/lib/tools.jar' couldn't be found. Are you sure that you're using a valid Sun JDK? " +
	"[$JAVA_HOME$: '" + System.getProperty("java.home") + "']");
	}
	} else {
	if (_logger.isLoggable(Level.FINE)) {
	_logger.log(Level.FINE, "The user has specified the required JAR file '$JAVA_HOME$/lib/tools.jar' ['"
	+ toolsJar.toExternalForm() + "']. A custom URL classloader will be created for the Javac compiler.");
	}

	return new URLClassLoader(new URL[]{toolsJar}, ClassUtils.getContextClassLoader());
	}
	}
	}

	}