src/org/apache/axis/components/compiler/Jikes.java - axis-axis1-java - Git at Google

 /*
  * Copyright 2001-2004 The Apache Software Foundation.
  *
  * Licensed 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.axis.components.compiler;

 import org.apache.axis.components.logger.LogFactory;
 import org.apache.axis.utils.Messages;
 import org.apache.commons.logging.Log;

 import java.io.BufferedInputStream;
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.StringTokenizer;

 /**
  * This class wraps IBM's <i>Jikes</i> Java compiler
  * NOTE: inspired by the Apache Jasper implementation.
  * @author <a href="mailto:dims@yahoo.com">Davanum Srinivas</a>
  * @author <a href="mailto:stefano@apache.org">Stefano Mazzocchi</a>
  * @since 2.0
  */

 public class Jikes extends AbstractCompiler
 {
     protected static Log log =
             LogFactory.getLog(Jikes.class.getName());

     static final int OUTPUT_BUFFER_SIZE = 1024;
     static final int BUFFER_SIZE = 512;

     private class StreamPumper extends Thread {

         private BufferedInputStream stream;
         private boolean endOfStream = false;
         private boolean stopSignal  = false;
         private int SLEEP_TIME = 5;
         private OutputStream out;

         public StreamPumper(BufferedInputStream is, OutputStream out) {
             this.stream = is;
             this.out = out;
         }

         public void pumpStream() throws IOException {
             byte[] buf = new byte[BUFFER_SIZE];
             if (!endOfStream) {
                 int bytesRead = stream.read(buf, 0, BUFFER_SIZE);

                 if (bytesRead > 0) {
                     out.write(buf, 0, bytesRead);
                 } else if (bytesRead == -1) {
                     endOfStream = true;
                 }
             }
         }

         public void run() {
             try {
                 while (!endOfStream) {
                     pumpStream();
                     sleep(SLEEP_TIME);
                 }
             } catch (Exception e) {
                // getLogger().warn("Jikes.run()", e);
             }
         }
     }

     /**
      * Copy arguments to a string array
      *
      * @param arguments The compiler arguments
      * @return A string array containing compilation arguments
      */
     protected String[] toStringArray(List arguments) {
         int i;

         for (i = 0; i < arguments.size(); i++) {
             String arg = (String) arguments.get(i);
             if (arg.equals("-sourcepath")) {
                 // Remove -sourcepath option. Jikes does not understand that.
                 arguments.remove(i);
                 arguments.remove(i);
                 break;
             }
         }

         String[] args = new String[arguments.size() + fileList.size()];
         for (i = 0; i < arguments.size(); i++) {
             args[i] = (String) arguments.get(i);
         }

         for (int j=0; j < fileList.size(); i++,j++) {
             args[i] = (String)fileList.get(j);
         }

         return args;
     }

     /**
      * Execute the compiler
      */
     public boolean compile() throws IOException {

         List args = new ArrayList();
         // command line name
         args.add("jikes");
         // indicate Emacs output mode must be used
         args.add("+E");
         // avoid warnings
         // Option nowarn with one hyphen only
         args.add("-nowarn");

         int exitValue;
         ByteArrayOutputStream tmpErr = new ByteArrayOutputStream(OUTPUT_BUFFER_SIZE);

         try {
             Process p = Runtime.getRuntime().exec(toStringArray(fillArguments(args)));

             BufferedInputStream compilerErr = new BufferedInputStream(p.getErrorStream());

             StreamPumper errPumper = new StreamPumper(compilerErr, tmpErr);

             errPumper.start();

             p.waitFor();
             exitValue = p.exitValue();

             // Wait until the complete error stream has been read
             errPumper.join();
             compilerErr.close();

             p.destroy();

             tmpErr.close();
             this.errors = new ByteArrayInputStream(tmpErr.toByteArray());

         } catch (InterruptedException somethingHappened) {
             log.debug("Jikes.compile():SomethingHappened", somethingHappened);
             return false;
         }

         // Jikes returns 0 even when there are some types of errors.
         // Check if any error output as well
         // Return should be OK when both exitValue and
         // tmpErr.size() are 0 ?!
         return ((exitValue == 0) && (tmpErr.size() == 0));
     }

     /**
      * Parse the compiler error stream to produce a list of
      * <code>CompilerError</code>s
      *
      * @param input The error stream
      * @return The list of compiler error messages
      * @exception IOException If an error occurs during message collection
      */
     protected List parseStream(BufferedReader input) throws IOException {
         List errors = null;
         String line = null;
         StringBuffer buffer = null;

         while (true) {
             // cleanup the buffer
             buffer = new StringBuffer(); // this is faster than clearing it

             // first line is not space-starting
             if (line == null) line = input.readLine();
             if (line == null) return errors;
             log.debug(line);
             buffer.append(line);

             // all other space-starting lines are one error
             while (true) {
                 line = input.readLine();
                 // EOF
                 if (line == null)
                     break;
                 // Continuation of previous error starts with ' '
                 if (line.length() > 0 && line.charAt(0) != ' ')
                     break;
                 log.debug(line);
                 buffer.append('\n');
                 buffer.append(line);
             }

             // if error is found create the vector
             if (errors == null) errors = new ArrayList();

             // add the error bean
             errors.add(parseError(buffer.toString()));
         }
     }

     /**
      * Parse an individual compiler error message
      *
      * @param error The error text
      * @return A mssaged <code>CompilerError</code>
      */
     private CompilerError parseError(String error) {
         StringTokenizer tokens = new StringTokenizer(error, ":");
         String file = tokens.nextToken();
         if (file.length() == 1) file = new StringBuffer(file).append(":").append(tokens.nextToken()).toString();
         StringBuffer message = new StringBuffer();
         String type = "";
         int startline = 0;
         int startcolumn = 0;
         int endline = 0;
         int endcolumn = 0;

         try {
             startline = Integer.parseInt(tokens.nextToken());
             startcolumn = Integer.parseInt(tokens.nextToken());
             endline = Integer.parseInt(tokens.nextToken());
             endcolumn = Integer.parseInt(tokens.nextToken());
         } catch (Exception e) {
             // FIXME: VG: This is not needed anymore?
             message.append(Messages.getMessage("compilerFail00"));
             type="error";
             log.error(Messages.getMessage("compilerFail00"), e);
         }

         if ("".equals(message)) {
             type = tokens.nextToken().trim().toLowerCase();
             message.append(tokens.nextToken("\n").substring(1).trim());

             while (tokens.hasMoreTokens())
                 message.append("\n").append(tokens.nextToken());
         }

         return new CompilerError(file, type.equals("error"), startline, startcolumn, endline, endcolumn, message.toString());
     }

     public String toString() {
         return Messages.getMessage("ibmJikes");
     }
 }
	/*
	* Copyright 2001-2004 The Apache Software Foundation.
	*
	* Licensed 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.axis.components.compiler;

	import org.apache.axis.components.logger.LogFactory;
	import org.apache.axis.utils.Messages;
	import org.apache.commons.logging.Log;

	import java.io.BufferedInputStream;
	import java.io.BufferedReader;
	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.StringTokenizer;

	/**
	* This class wraps IBM's <i>Jikes</i> Java compiler
	* NOTE: inspired by the Apache Jasper implementation.
	* @author <a href="mailto:dims@yahoo.com">Davanum Srinivas</a>
	* @author <a href="mailto:stefano@apache.org">Stefano Mazzocchi</a>
	* @since 2.0
	*/

	public class Jikes extends AbstractCompiler
	{
	protected static Log log =
	LogFactory.getLog(Jikes.class.getName());

	static final int OUTPUT_BUFFER_SIZE = 1024;
	static final int BUFFER_SIZE = 512;

	private class StreamPumper extends Thread {

	private BufferedInputStream stream;
	private boolean endOfStream = false;
	private boolean stopSignal = false;
	private int SLEEP_TIME = 5;
	private OutputStream out;

	public StreamPumper(BufferedInputStream is, OutputStream out) {
	this.stream = is;
	this.out = out;
	}

	public void pumpStream() throws IOException {
	byte[] buf = new byte[BUFFER_SIZE];
	if (!endOfStream) {
	int bytesRead = stream.read(buf, 0, BUFFER_SIZE);

	if (bytesRead > 0) {
	out.write(buf, 0, bytesRead);
	} else if (bytesRead == -1) {
	endOfStream = true;
	}
	}
	}

	public void run() {
	try {
	while (!endOfStream) {
	pumpStream();
	sleep(SLEEP_TIME);
	}
	} catch (Exception e) {
	// getLogger().warn("Jikes.run()", e);
	}
	}
	}

	/**
	* Copy arguments to a string array
	*
	* @param arguments The compiler arguments
	* @return A string array containing compilation arguments
	*/
	protected String[] toStringArray(List arguments) {
	int i;

	for (i = 0; i < arguments.size(); i++) {
	String arg = (String) arguments.get(i);
	if (arg.equals("-sourcepath")) {
	// Remove -sourcepath option. Jikes does not understand that.
	arguments.remove(i);
	arguments.remove(i);
	break;
	}
	}

	String[] args = new String[arguments.size() + fileList.size()];
	for (i = 0; i < arguments.size(); i++) {
	args[i] = (String) arguments.get(i);
	}

	for (int j=0; j < fileList.size(); i++,j++) {
	args[i] = (String)fileList.get(j);
	}

	return args;
	}

	/**
	* Execute the compiler
	*/
	public boolean compile() throws IOException {

	List args = new ArrayList();
	// command line name
	args.add("jikes");
	// indicate Emacs output mode must be used
	args.add("+E");
	// avoid warnings
	// Option nowarn with one hyphen only
	args.add("-nowarn");

	int exitValue;
	ByteArrayOutputStream tmpErr = new ByteArrayOutputStream(OUTPUT_BUFFER_SIZE);

	try {
	Process p = Runtime.getRuntime().exec(toStringArray(fillArguments(args)));

	BufferedInputStream compilerErr = new BufferedInputStream(p.getErrorStream());

	StreamPumper errPumper = new StreamPumper(compilerErr, tmpErr);

	errPumper.start();

	p.waitFor();
	exitValue = p.exitValue();

	// Wait until the complete error stream has been read
	errPumper.join();
	compilerErr.close();

	p.destroy();

	tmpErr.close();
	this.errors = new ByteArrayInputStream(tmpErr.toByteArray());

	} catch (InterruptedException somethingHappened) {
	log.debug("Jikes.compile():SomethingHappened", somethingHappened);
	return false;
	}

	// Jikes returns 0 even when there are some types of errors.
	// Check if any error output as well
	// Return should be OK when both exitValue and
	// tmpErr.size() are 0 ?!
	return ((exitValue == 0) && (tmpErr.size() == 0));
	}

	/**
	* Parse the compiler error stream to produce a list of
	* <code>CompilerError</code>s
	*
	* @param input The error stream
	* @return The list of compiler error messages
	* @exception IOException If an error occurs during message collection
	*/
	protected List parseStream(BufferedReader input) throws IOException {
	List errors = null;
	String line = null;
	StringBuffer buffer = null;

	while (true) {
	// cleanup the buffer
	buffer = new StringBuffer(); // this is faster than clearing it

	// first line is not space-starting
	if (line == null) line = input.readLine();
	if (line == null) return errors;
	log.debug(line);
	buffer.append(line);

	// all other space-starting lines are one error
	while (true) {
	line = input.readLine();
	// EOF
	if (line == null)
	break;
	// Continuation of previous error starts with ' '
	if (line.length() > 0 && line.charAt(0) != ' ')
	break;
	log.debug(line);
	buffer.append('\n');
	buffer.append(line);
	}

	// if error is found create the vector
	if (errors == null) errors = new ArrayList();

	// add the error bean
	errors.add(parseError(buffer.toString()));
	}
	}

	/**
	* Parse an individual compiler error message
	*
	* @param error The error text
	* @return A mssaged <code>CompilerError</code>
	*/
	private CompilerError parseError(String error) {
	StringTokenizer tokens = new StringTokenizer(error, ":");
	String file = tokens.nextToken();
	if (file.length() == 1) file = new StringBuffer(file).append(":").append(tokens.nextToken()).toString();
	StringBuffer message = new StringBuffer();
	String type = "";
	int startline = 0;
	int startcolumn = 0;
	int endline = 0;
	int endcolumn = 0;

	try {
	startline = Integer.parseInt(tokens.nextToken());
	startcolumn = Integer.parseInt(tokens.nextToken());
	endline = Integer.parseInt(tokens.nextToken());
	endcolumn = Integer.parseInt(tokens.nextToken());
	} catch (Exception e) {
	// FIXME: VG: This is not needed anymore?
	message.append(Messages.getMessage("compilerFail00"));
	type="error";
	log.error(Messages.getMessage("compilerFail00"), e);
	}

	if ("".equals(message)) {
	type = tokens.nextToken().trim().toLowerCase();
	message.append(tokens.nextToken("\n").substring(1).trim());

	while (tokens.hasMoreTokens())
	message.append("\n").append(tokens.nextToken());
	}

	return new CompilerError(file, type.equals("error"), startline, startcolumn, endline, endcolumn, message.toString());
	}

	public String toString() {
	return Messages.getMessage("ibmJikes");
	}
	}