Quadcap Embeddable Server

com/quadcap/http/servlets/jsp/JavaCompiler.java

Go to the documentation of this file.

package com.quadcap.http.servlets.jsp;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import java.util.Properties;

import javax.servlet.ServletContext;

import com.quadcap.http.server22.WebApplication;

import com.quadcap.io.IO;

import com.quadcap.util.Debug;

/**
 * Compile java to class files using the configured compiler options.
 *
 * @author Stan Bailes
 */
public class JavaCompiler {
    File                        root;
    String                      compileCmd;
    String                      contextClassPath        = "";
    Properties                  defaultProps;

    public JavaCompiler() {}
    
    public void init(ServletContext context, File root,
                     String compileCmd, Properties defaultProps) {
        this.root = root;
        this.compileCmd = compileCmd;
        this.defaultProps = defaultProps;
        if (context instanceof WebApplication) {
            WebApplication app = (WebApplication)context;
            contextClassPath = app.getContextClassPath();
        }
    }

    private Thread copyOutput(final OutputStream os,
                              final InputStream is) {
        return new Thread() {
            public void run() {
                int c;
                try {
                    IO.copyStream(is, os);
                } catch (IOException e) {
                }
            }
        };
    }

    String getCompileCommand(Properties props) {
        StringBuffer sb = new StringBuffer();
        StringBuffer nb = new StringBuffer();
        int state = 0;
        for (int i = 0; i < compileCmd.length(); i++) {
            char c = compileCmd.charAt(i);
            switch (state) {
            case 0:
                if (c == '%') {
                    state = 1;
                    nb.setLength(0);
                } else {
                    sb.append(c);
                }
                break;
            case 1:
                if (c == '%') {
                    sb.append(c);
                    state = 0;
                } else {
                    nb.append(c);
                    state = 2;
                }
                break;
            case 2:
                if (c == '%') {
                    sb.append(props.getProperty(nb.toString()));
                    state = 0;
                } else {
                    nb.append(c);
                }
            }
        }
        return sb.toString();
    }

    public boolean doCompile(String cmd, OutputStream out)
        throws IOException
    {
        Process p = Runtime.getRuntime().exec(cmd);
        Thread errthread = copyOutput(out, p.getErrorStream());
        Thread outthread = copyOutput(out, p.getInputStream());
        errthread.start();
        outthread.start();
        int res = -1;
        try { res = p.waitFor(); } catch (Throwable t) {}
        try { errthread.join(); } catch (Throwable t) {}
        try { outthread.join(); } catch (Throwable t) {}
        return res == 0;
    }

    public void compile(File javaFile, File classFile)
        throws IOException, ClassNotFoundException, JspException
    {
        Properties cprops = new Properties(defaultProps);
        cprops.put("source", javaFile.getPath());
        cprops.put("repository", root.getPath());
        cprops.put("context.classpath", contextClassPath);
        String cmd = getCompileCommand(cprops);
        if (Trace.level() > 2) {
            Debug.println("COMPILE: " + cmd);
        }
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        boolean ok = doCompile(cmd, bos);
        if (Trace.level() > 3) {
            Debug.println("COMPILE OUTPUT: " + bos.toString());
        }
        if (!ok) {
            throw new JspException("compile failed: " + bos.toString());
        }
        if (!classFile.exists()) {
            throw new ClassNotFoundException("No class file generated by compile: " +
                                             bos.toString());
        }
    }

    //#ifdef DEBUG
    public static void main(String args[]) {
        String cmd = "./jikes -classpath %java.class.path%;%repository%;%java.home%/lib/rt.jar -d %repository% +D +E -nowarn %source%";
        Properties props = System.getProperties();
        try {
            JavaCompiler jc = new JavaCompiler();
            jc.init(null, new File("./repository"), cmd, props);
            File j = new File("./repository/__jsp/login.java");
            File c = new File("./repository/__jsp/login.class");
            jc.compile(j, c);
        } catch (Throwable tt) {
            tt.printStackTrace(System.err);
        }
    }
    //#endif
}