| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 1999 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The names "Xalan" and "Apache Software Foundation" must |
| * not be used to endorse or promote products derived from this |
| * software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation and was |
| * originally based on software copyright (c) 1999, Lotus |
| * Development Corporation., http://www.lotus.com. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| * |
| * $Id$ |
| */ |
| |
| package org.apache.xml.utils.synthetic; |
| |
| import java.io.IOException; |
| |
| /** |
| * <meta name="usage" content="internal"/> |
| * This class supports invoking Java compilation from within |
| * a Java program. Recent versions of the Java environment have |
| * provided such an API (in tools.jar). But that isn't available |
| * on all platforms, and a fallback to the command line may be needed |
| * (though this too may not always be available, eg. for security |
| * reasons). |
| * <p> |
| * There's an additional complication in some environments -- |
| * such as Microsoft's VJ++ -- where the classpath as seen in |
| * the System Properties may not be the one the user expects. |
| * The code here is parameterized to try to deal with that. |
| */ |
| public class JavaUtils |
| { |
| // One-time flag for whether we could dynamically load compiler API |
| private static boolean cantLoadCompiler=false; |
| |
| // Debug flag - generates debug stuff if true. |
| private static boolean debug = false; |
| |
| /** Control whether compilation occurs with the -g option |
| * (debugging information included in generated classfile). |
| * This is an attribute, rather than a parameter on the compile |
| * method, largely because it tends to be an all-or-nothing decision; |
| * generally you're either doing program development and want it, |
| * or running in production mode and don't. But that may not match |
| * the needs of future users... |
| * <p> |
| * TODO: Consider whether debug should be a parameter. |
| * |
| * @param boolean newDebug True to request debugging data, |
| * false to request optimized output. (It's uncommon to |
| * want both or neither!) |
| */ |
| public static void setDebug(boolean newDebug) |
| { |
| debug=newDebug; |
| } |
| |
| /** Try to compile a .java file on disk. This will first attempt to |
| * use the sun.java.tools.javac() method, then (if that is unavailable) |
| * fall back upon shelling out to a command line and running javac |
| * there. |
| * <p> |
| * NOTE: This must be _compiled_ with sun.java.tools.* (tools.jar) |
| * available. We could change that to use reflection instead, if we |
| * accept some overhead... minor compared to the cost of running the |
| * compiler! |
| * <p> |
| * This has complications on some platforms. For example, under |
| * Microsoft Visual Java ++ (at least, as installed on my test system), |
| * I found that I had to specify paths to both javac and xerces.jar |
| * rather than counting on the shell's path and classpath having |
| * been set to reach these. For that reason I've parameterized this |
| * method with a few system properties, so you can adapt it to your |
| * own system's needs without modifying the code: |
| * <dl> |
| * <dt>org.apache.xml.utils.synthetic.javac |
| * <dd>Command line issued to invoke the compiler. Defaults to "javac", |
| * which should work in most systems. In VJ++, try setting it to |
| * "cmd /c %JAVA_HOME%\\bin\javac.exe" |
| * <dt>org.apache.xml.utils.synthetic.moreclasspath |
| * <dd>Additional classpath, to be prepended to the one retrieved from |
| * java.class.path. Defaults to "" (empty). In VJ++, try setting it to |
| * point to your copy of xerces.jar, which may not be found otherwise. |
| * TODO: Reconsider prepend versus append! |
| * </dl> |
| * |
| * @param String fileName Which .java file to compile. Note that this may |
| * be relative to the "current directory". |
| * @param String classPath Additional places to look for classes that |
| * this .java file depends upon. Becomes the javac command's |
| * -classpath parameter value. |
| * @return boolean True iff compilation succeeded. |
| */ |
| public static boolean JDKcompile(String fileName, String classPath) |
| { |
| String moreClassPath= |
| System.getProperty("org.apache.xml.utils.synthetic.moreclasspath","") |
| .trim(); |
| if(moreClassPath.length()>0) |
| classPath=moreClassPath+';'+classPath; |
| |
| if (debug) |
| { |
| System.err.println ("JavaEngine: Compiling " + fileName); |
| System.err.println ("JavaEngine: Classpath is " + classPath); |
| } |
| |
| String code_option = debug ? "-g" : "-O"; |
| |
| // Start by trying Sun's compiler API |
| if(!cantLoadCompiler) |
| { |
| String args[] = { |
| code_option, |
| "-classpath", classPath, |
| fileName |
| }; |
| |
| // try |
| // { |
| // return new sun.tools.javac.Main(System.err, "javac").compile(args); |
| // } |
| // catch (Throwable th) |
| // { |
| // System.err.println("INFORMATIONAL: Unable to load Java compiler API (eg tools.jar)."); |
| // System.err.println("\tSwitching to command-line invocation."); |
| // cantLoadCompiler=true; |
| // } |
| } |
| |
| // FALLTHRU: |
| // Can't load javac() method; try shelling out to the command |
| // line and invoking it via exec(). |
| String javac_command= |
| System.getProperty("org.apache.xml.utils.synthetic.javac","javac"); |
| String args[] = { |
| javac_command, |
| code_option, |
| "-classpath", classPath, |
| fileName |
| }; |
| try |
| { |
| Process p=java.lang.Runtime.getRuntime().exec(args); |
| int compileOK=waitHardFor(p); // pause for debugging... |
| return compileOK==0; //0 == no error reported |
| } |
| catch(IOException e) |
| { |
| System.err.println("ERROR: IO exception during exec(javac)."); |
| } |
| catch(SecurityException e) |
| { |
| System.err.println("ERROR: Unable to create subprocess to exec(javac)."); |
| } |
| |
| // FALLTHRU: All attempts failed. |
| return false; |
| } |
| |
| /** Subroutine: Like p.waitFor, but discards the InterruptedException |
| * and goes right back into a wait. I don't want to report compiler |
| * success or failure until it really has succeeded or failed... I think. |
| * @param Process p to be waited for |
| * @return the exitValue() of the process. |
| */ |
| static int waitHardFor(java.lang.Process p) |
| { |
| boolean done=false; |
| while(!done) |
| try |
| { |
| p.waitFor(); |
| done=true; |
| } |
| catch(InterruptedException e) |
| { |
| System.err.println("(Compiler process wait interrupted and resumed)"); |
| } |
| int ev=p.exitValue(); // Pause for debugging... |
| return ev; |
| } |
| |
| } |
