Java6: How to compile java using JavaCompiler class

Question

Hi all,
Using JavaCompiler, we can run the java program thru programmaticaly using run() method.
Could anyone please tell me how to compile a java program using JavaCompailer class? Or calling run() itself will compile java file?
Thanks
Shagil

Answer 1

import spoon.support.input.SpoonInputStream;
import com.sun.tools.javac.code.Symbol.ClassSymbol;
import com.sun.tools.javac.comp.Attr;
import com.sun.tools.javac.comp.AttrContext;
import com.sun.tools.javac.comp.Enter;
import com.sun.tools.javac.comp.Env;
import com.sun.tools.javac.comp.Todo;
import com.sun.tools.javac.tree.Tree;
import com.sun.tools.javac.tree.Tree.ClassDef;
import com.sun.tools.javac.tree.Tree.TopLevel;
import com.sun.tools.javac.util.Abort;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.ListBuffer;
import com.sun.tools.javac.util.Log;
import com.sun.tools.javac.util.Name;
* The Spoon compiler (uses javac).
public class SpoonCompiler extends com.sun.tools.javac.main.JavaCompiler {
     Attr attr;
     Enter enter;
     boolean hasBeenUsed = false;
     Log log;
     Todo todo;
     public SpoonCompiler(Context arg0) {
          super(arg0);
          enter = Enter.instance(arg0);
          todo = Todo.instance(arg0);
          log = Log.instance(arg0);
          attr = Attr.instance(arg0);
          sourceOutput=true;
      * Main method: compile a list of files, return all compiled classes
      * @param filenames
      *            The names of all files to be compiled.
     @SuppressWarnings("unused")
     public List<Tree> parseAndAttribute(List<SpoonInputStream> filenames)
               throws Throwable {
          // as a JavaCompiler can only be used once, throw an exception if
          // it has been used before.
          assert !hasBeenUsed : "attempt to reuse JavaCompiler";
          hasBeenUsed = true;
          long msec = System.currentTimeMillis();
          ListBuffer<ClassSymbol> classes = new ListBuffer<ClassSymbol>();
          try {
               // parse all files
               ListBuffer<Tree> trees = new ListBuffer<Tree>();
               for (List<SpoonInputStream> l = filenames; l.nonEmpty(); l = l.tail) {
                    trees.append(parse(l.head.getFileName(),l.head.getStream()));
               // enter symbols for all files
               List<Tree> roots = trees.toList();
               if (errorCount() == 0)
                    enter.main(roots);
               // If generating source, remember the classes declared in
               // the original compilation units listed on the command line.
               List<ClassDef> rootClasses = null;
               if (sourceOutput || stubOutput) {
                    ListBuffer<ClassDef> cdefs = new ListBuffer<ClassDef>();
                    for (List<Tree> l = roots; l.nonEmpty(); l = l.tail) {
                         for (List<Tree> defs = ((TopLevel) l.head).defs; defs
                                   .nonEmpty(); defs = defs.tail) {
                              if (defs.head instanceof ClassDef)
                                   cdefs.append((ClassDef) defs.head);
                    rootClasses = cdefs.toList();
               while (todo.nonEmpty()) {
                    Env<AttrContext> env = todo.next();
                    // save tree prior to rewriting
                    Tree untranslated = env.tree;
                    // attribution phase
                    if (verbose)
                         printVerbose("checking.attribution", env.enclClass.sym);
                    Name prev = log.useSource(env.enclClass.sym.sourcefile);
                    attr.attribClass(env.tree.pos, env.enclClass.sym);
               return trees.toList();
          } catch (Abort ex) {
               ex.printStackTrace();
          if (verbose)
               printVerbose("total", Long.toString(System.currentTimeMillis()
                         - msec));
          int errCount = errorCount();
          if (errCount == 1)
               printerCount("error", errCount);
          else
               printerCount("error.plural", errCount);
          if (log.nwarnings == 1)
               printerCount("warn", log.nwarnings);
          else
               printerCount("warn.plural", log.nwarnings);
          return null;
     private void printerCount(String str, int val) {
          System.err.println(str + " - " + val);
     private void printVerbose(String arg0, Object obj) {
          System.out.println(arg0 + " - " + obj.toString());
--- NEW FILE: CtBuilder.java ---
package spoon.support.builder;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import java.util.TreeSet;
import spoon.query.Query;
import spoon.query.TypeFilter;
import spoon.reflect.CtFactory;
import spoon.reflect.code.BinaryOperatorKind;
import spoon.reflect.code.CtAbstractInvocation;
import spoon.reflect.code.CtArrayAccess;
import spoon.reflect.code.CtAssert;
import spoon.reflect.code.CtAssignment;
import spoon.reflect.code.CtBinaryOperator;
[...1760 lines suppressed...]
            var.setSimpleName(tree.sym.name.toString());
            var.setModifiers(getModifiers(tree.mods.flags));
            enter(var, tree);
            scan(tree.init);
            exit(var, tree);
    @Override
    public void visitWhileLoop(WhileLoop tree) {
        CtWhile whileLoop = new CtWhileImpl();
        enter(whileLoop, tree);
        builderContext.loopParameter = 1;
        scan(tree.cond);
        builderContext.loopParameter = 0;
        scan(tree.body);
        exit(whileLoop, tree);
}