Can you write javac in java Language

Question

Hi,
is it possible to write java compiler in java language.

Answer 1

Here's a compiler written in Java, it is part of an IDE I wrote:
Compiler.java: import java.io.*;
* Wrap up javac.
* The class exists to supply a single method - to compile a file
* and report status along with error/success messages
* Compilation (by javac) is carried out asynchronously using a
* background Thread. Status and any error messages are passed back to
* the calling object through a callback method.
public class Compiler implements Runnable
    * Constructor.
    * @param owner the <TT>JavacTool</TT> that has created this Compiler
   public Compiler( CompilerListener owner )
      myOwner = owner;
   private CompilerListener myOwner;
    * Compile a file using javac.
    * This method will compile a Java source file and report both the
    * status of the operation and any error strings produced.
    * The method kicks off a separate Thread that actually carries out
    * the compilation. Upon completion a the JavacTool is called back with
    * a CompilerStatus object.
    * @param filename   the name of a file which <I>must</I> be in the same directory
    * as the JavacTool was run from.  this tool does not have tha capability
    * of working across multiple directories.
   public void compile( String fileToCompile )
      filename = fileToCompile;
      new Thread( this ).start();
   private String filename;
    * The method run by the separate Thread.
    * It runs once for each filename passed to the Compiler object.
    * It creates a new OS process to run "javac filename" externally
    * and captures the error output from the real compiler into
    * a String so that it can be returned to the calling code via
    * a callback method (very similar in principle to an event)
   public void run()
      CompilerStatus returnValue = new CompilerStatus();
      returnValue.outputString = new String();
      try
         Runtime r = Runtime.getRuntime();
         Process p = r.exec( "javac " + filename );
         InputStream is = p.getErrorStream();
         BufferedReader rdr = new BufferedReader( new InputStreamReader( is ) );
         String line = rdr.readLine();
         while( line != null )
           returnValue.outputString += (line + "\n");
           line = rdr.readLine();
         p.waitFor();
         returnValue.exitValue = p.exitValue();
         if( returnValue.exitValue == 0 )
           returnValue.outputString = "Compilation successful\n\nNo errors\n";
      catch( Exception e )
        e.printStackTrace();
      myOwner.compileComplete( returnValue );
} CompilerStatus.java: public class CompilerStatus
   public int exitValue;
   public String outputString;
}JavacTool.java: import java.util.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
* The main class in the application
* Provides the screen presence for the controllers and the output view
public class JavacTool extends JTextArea implements CompilerListener
    * Constructor for the tool
    * @param list A java.util.Vector containing the list of files for compilation
    * or null if none entered.
   public JavacTool( JTextArea jTextArea )
      // View    
      outputWindow = jTextArea;     
      outputWindow.setFont( new Font( "Monospaced", Font.PLAIN, 12 ) ); 
      outputWindow.setText( "TBJava IDE: -ready to compile" );   
      // Get it going!
      // Must create a Compiler object and provide it with a link
      // so that it can call this object back when it has completed
      theCompiler = new Compiler( this );
      // set the size and the visibility
      setSize( 500, 250 );
      setVisible( true );
     public void Compile( String fileToCompile )
            // Infrom user that something is happening
               filename = fileToCompile;
               outputWindow.setBackground( Color.white );
               outputWindow.setText( "Compiling " + filename );
               setCursor( new Cursor( Cursor.WAIT_CURSOR ) );
               theCompiler.compile( fileToCompile );
            // When compilation is complete, the Compiler
            // object will callback on the method compileComplete
            // The Compiler runs its own Thread so this method
            // will complete immediately and the outputWindow
            // update can occur.
   private String filename;                                             // the filename as a String
   private JTextArea outputWindow;                                   // the window containing the messages                         
   private Compiler theCompiler;                                        // the compiler
    * Method called by the Compiler when it has completed
    * @param status A CompilerStatus object that contains
    *    the exit value from the compiler
    *    (indicating success or failure) value == 0 => OK and value != 0 => error
    *    and an appropriate text message
   public void compileComplete( CompilerStatus status )
      setCursor( new Cursor( Cursor.DEFAULT_CURSOR ) );
      if( status.exitValue == 0 )
         outputWindow.setBackground( new Color( 0.85F, 1.0F, 0.85F ) );
                                     // pale green
      else
         outputWindow.setBackground( new Color( 1.0F, 0.85F, 0.85F ) );
                                     // pale red
      outputWindow.setText( status.outputString );
}This is taken straight from my IDE; you'll have to adapt it slightly to make it into a seperate application