Cmd.java

package org.objectweb.common;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import org.objectweb.util.monolog.api.BasicLevel;

public class Cmd {

    private static final String COMPILER_CLASS_NAME = "com.sun.tools.javac.Main";
    private static final String RMICOMPILER_CLASS_NAME = "sun.rmi.rmic.Main";

    private Vector mCmd = new Vector();

    private String[] mEnv = null;

    private boolean tryToInvoke = false;

    public Cmd(String cmd, boolean invoke) {
        mCmd.addElement(cmd);
        tryToInvoke = invoke;
    }

    public Cmd(String cmd) {
        this(cmd, false);
    }

    public Cmd(String cmd, String[] env, boolean invoke) {
        mCmd.addElement(cmd);
        mEnv = env;
        tryToInvoke = invoke;
    }

    public void addArgument(String arg) {
        mCmd.addElement(arg);
    }

    public void addArguments(List args) {
        for (Iterator it = args.iterator(); it.hasNext();) {
            mCmd.addElement(it.next());
        }
    }

    public boolean run() {

        if (tryToInvoke && (((String) mCmd.get(0)).endsWith("javac"))) {
            // Bug #100587 fixed to work around a limitation on Windows
            return compile();
        }
        if (tryToInvoke && (((String) mCmd.get(0)).endsWith("rmic"))) {
            return rmicompile();
        }

        RunnableStreamListener out, err;
        Process proc = null;
        boolean val = true;
        try {
            String[] cmd = new String[mCmd.size()];
            mCmd.copyInto(cmd);
            proc = Runtime.getRuntime().exec(cmd, mEnv);
        } catch (IOException e) {
            TraceCore.logger.log(BasicLevel.ERROR, "exception", e);
            return (false);
        }
        out = new RunnableStreamListener(new BufferedReader(new InputStreamReader(proc.getInputStream())), System.out);
        new Thread(out, "stdout listener for " + this.toString()).start();
        err = new RunnableStreamListener(new BufferedReader(new InputStreamReader(proc.getErrorStream())), System.err);
        new Thread(err, "stderr listener for " + this.toString()).start();
        try {
            val = proc.waitFor() == 0;
        } catch (InterruptedException e) {
            TraceCore.logger.log(BasicLevel.ERROR, "exception", e);
            val = false;
        }

        return (val);
    }

    private boolean compile() {
        // first arg should not be added because it's the name of the command
        String[] args = new String[mCmd.size() - 1];
        for (int i = 0; i < mCmd.size() - 1; i++) {
            args[i] = (String) mCmd.get(i + 1);
        }

        try {
            // Use reflection
            Class c = Class.forName(COMPILER_CLASS_NAME);
            Object compiler = c.newInstance();
            java.lang.reflect.Method compile = c.getMethod("compile", new Class[] {(new String[] {}).getClass()});
            int result = ((Integer) compile.invoke(compiler, new Object[] {args})).intValue();
            return (result == 0);
        } catch (Exception e) {
            TraceCore.logger.log(BasicLevel.ERROR, "exception", e);
            return false;
        }
    }

    private boolean rmicompile() {
        // first arg should not be added because it's the name of the command
        String[] args = new String[mCmd.size() - 1];
        for (int i = 0; i < mCmd.size() - 1; i++) {
            args[i] = (String) mCmd.get(i + 1);
        }

        try {
            // Use reflection
            Class c = Class.forName(RMICOMPILER_CLASS_NAME);
            Object compiler = c.newInstance();
            java.lang.reflect.Method compile = c.getMethod("compile", new Class[] {(new String[] {}).getClass()});
            int result = ((Integer) compile.invoke(compiler, new Object[] {args})).intValue();
            return (result == 0);
        } catch (Exception e) {
            TraceCore.logger.log(BasicLevel.ERROR, "exception", e);
            return false;
        }
    }


    public String toString() {
        StringBuffer buf = new StringBuffer();
        Enumeration e = mCmd.elements();
        while (e.hasMoreElements()) {
            String arg = (String) e.nextElement();
            if (arg == null) {
                arg = "null";
            }
            for (int i = 0; i < arg.length(); i++) {
                if (Character.isWhitespace(arg.charAt(i))) {
                    arg = "\"" + arg + "\"";
                    break;
                }
            }
            buf.append(arg);
            buf.append(' ');
        }
        return buf.toString().trim();
    }

}

class RunnableStreamListener implements Runnable {

    BufferedReader in_;

    PrintStream stream_;

    RunnableStreamListener(BufferedReader in, PrintStream stream) {
        in_ = in;
        stream_ = stream;
    }

    public void run() {
        String line;
        try {
            while ((line = in_.readLine()) != null) {
                stream_.println(line);
            }
        } catch (IOException e) {
            stream_.println(e.toString());
        }
    }
}

---