janino.net

org.codehaus.janino
Class SimpleCompiler

  extended by org.codehaus.commons.compiler.Cookable
      extended by org.codehaus.janino.SimpleCompiler
All Implemented Interfaces:
ICookable, ISimpleCompiler
Direct Known Subclasses:
ClassBodyEvaluator

public class SimpleCompiler
extends Cookable
implements ISimpleCompiler

To set up a SimpleCompiler object, proceed as described for ISimpleCompiler. Alternatively, a number of "convenience constructors" exist that execute the described steps instantly.


Field Summary
 
Fields inherited from interface org.codehaus.commons.compiler.ICookable
BOOT_CLASS_LOADER, SYSTEM_PROPERTY_SOURCE_DEBUGGING_DIR, SYSTEM_PROPERTY_SOURCE_DEBUGGING_ENABLE
 
Constructor Summary
SimpleCompiler()
           
SimpleCompiler(Scanner scanner,  optionalParentClassLoader)
          Equivalent to SimpleCompiler sc = new SimpleCompiler(); sc.setParentClassLoader(optionalParentClassLoader); sc.cook(scanner);
SimpleCompiler( fileName)
          Equivalent to SimpleCompiler sc = new SimpleCompiler(); sc.cook(fileName);
SimpleCompiler( optionalFileName,  is)
          Equivalent to SimpleCompiler sc = new SimpleCompiler(); sc.cook(optionalFileName, is);
SimpleCompiler( optionalFileName,  in)
          Equivalent to SimpleCompiler sc = new SimpleCompiler(); sc.cook(optionalFileName, in);
 
Method Summary
protected  void assertNotCooked()
           
protected  Java.Type[] classesToTypes(Location location, [] classes)
          Converts an array of es into an array ofJava.Types.
protected  Java.Type classToType(Location location,  clazz)
          Wraps a reflection in a Java.Type object.
protected   compileToClassLoader(Java.CompilationUnit compilationUnit)
          Compile the given compilation unit.
 void cook(Java.CompilationUnit compilationUnit)
          Cooks this compilation unit directly.
 void cook(Scanner scanner)
          Scans, parses and ompiles a given compilation unit from the given scanner.
 void cook( optionalFileName,  r)
          Scans, parses and compiles a given compilation unit from the given .
 boolean equals( o)
          Two SimpleCompilers are regarded equal iff Both are objects of the same class (e.g. both are ScriptEvaluators) Both generated functionally equal classes as seen by
  getClassLoader()
          Returns a object through which the previously compiled classes can be accessed.
 int hashCode()
           
static void main([] args)
           
 void setCompileErrorHandler(ErrorHandler optionalCompileErrorHandler)
          By default, CompileExceptions are thrown on compile errors, but an application my install its own ErrorHandler.
 void setDebuggingInformation(boolean debugSource, boolean debugLines, boolean debugVars)
          Determines what kind of debugging information is included in the generates classes.
 void setParentClassLoader( optionalParentClassLoader)
          The "parent class loader" is used to load referenced classes.
 void setWarningHandler(WarningHandler optionalWarningHandler)
          By default, warnings are discarded, but an application my install a custom WarningHandler.
 
Methods inherited from class org.codehaus.commons.compiler.Cookable
cook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFile, readString
 
Methods inherited from class java.lang.
, , , , , , , ,
 
Methods inherited from interface org.codehaus.commons.compiler.ICookable
cook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFile
 

Constructor Detail

SimpleCompiler

public SimpleCompiler( optionalFileName,
                       in)
               throws ,
                      CompileException
Equivalent to
 SimpleCompiler sc = new SimpleCompiler();
 sc.cook(optionalFileName, in);

Throws:
CompileException
See Also:
SimpleCompiler(), Cookable.cook(String, Reader)

SimpleCompiler

public SimpleCompiler( optionalFileName,
                       is)
               throws ,
                      CompileException
Equivalent to
 SimpleCompiler sc = new SimpleCompiler();
 sc.cook(optionalFileName, is);

Throws:
CompileException
See Also:
SimpleCompiler(), Cookable.cook(String, InputStream)

SimpleCompiler

public SimpleCompiler( fileName)
               throws ,
                      CompileException
Equivalent to
 SimpleCompiler sc = new SimpleCompiler();
 sc.cook(fileName);

Throws:
CompileException
See Also:
SimpleCompiler(), Cookable.cookFile(String)

SimpleCompiler

public SimpleCompiler(Scanner scanner,
                       optionalParentClassLoader)
               throws ,
                      CompileException
Equivalent to
 SimpleCompiler sc = new SimpleCompiler();
 sc.setParentClassLoader(optionalParentClassLoader);
 sc.cook(scanner);

Throws:
CompileException
See Also:
SimpleCompiler(), setParentClassLoader(ClassLoader), Cookable.cook(Reader)

SimpleCompiler

public SimpleCompiler()
Method Detail

main

public static void main([] args)
                 throws 
Throws:

setParentClassLoader

public void setParentClassLoader( optionalParentClassLoader)
Description copied from interface: ICookable
The "parent class loader" is used to load referenced classes. Useful values are:
System.getSystemClassLoader() The running JVM's class path
Thread.currentThread().getContextClassLoader() or null The class loader effective for the invoking thread
ICookable.BOOT_CLASS_LOADER The running JVM's boot class path
The parent class loader defaults to the current thread's context class loader.

Specified by:
setParentClassLoader in interface ICookable

setDebuggingInformation

public void setDebuggingInformation(boolean debugSource,
                                    boolean debugLines,
                                    boolean debugVars)
Description copied from interface: ICookable
Determines what kind of debugging information is included in the generates classes. The default is typically '-g:none', and '-g:all' if the system property 'org.codehaus.janino.source_debugging.enable' is set to 'true'.

Specified by:
setDebuggingInformation in interface ICookable

cook

public final void cook( optionalFileName,
                        r)
                throws CompileException,
                       
Scans, parses and compiles a given compilation unit from the given . After completion, getClassLoader() returns a that allows for access to the compiled classes.

Specified by:
cook in interface ICookable
Specified by:
cook in class Cookable
Parameters:
optionalFileName - Used when reporting errors and warnings.
Throws:
CompileException
See Also:
ICookable.cook(String, Reader)

cook

public void cook(Scanner scanner)
          throws CompileException,
                 
Scans, parses and ompiles a given compilation unit from the given scanner. After completion, getClassLoader() returns a that allows for access to the compiled classes.

Throws:
CompileException

cook

public void cook(Java.CompilationUnit compilationUnit)
          throws CompileException
Cooks this compilation unit directly.

Throws:
CompileException
See Also:
Cookable.cook(Reader)

getClassLoader

public  getClassLoader()
Description copied from interface: ISimpleCompiler
Returns a object through which the previously compiled classes can be accessed. This can be used for subsequent ISimpleCompilers in order to compile compilation units that use types (e.g. declare derived types) declared in the previous one.

This method must only be called after exactly on of the ICookable.cook(String, java.io.Reader) methods was called.

Specified by:
getClassLoader in interface ISimpleCompiler

equals

public boolean equals( o)
Two SimpleCompilers are regarded equal iff

Overrides:
in class

hashCode

public int hashCode()
Overrides:
in class

setCompileErrorHandler

public void setCompileErrorHandler(ErrorHandler optionalCompileErrorHandler)
Description copied from interface: ICookable
By default, CompileExceptions are thrown on compile errors, but an application my install its own ErrorHandler.

Be aware that a single problem during compilation often causes a bunch of compile errors, so a good ErrorHandler counts errors and throws a CompileException when a limit is reached.

If the given ErrorHandler throws CompileExceptions, then the compilation is terminated and the exception is propagated.

If the given ErrorHandler does not throw CompileExceptions, then the compiler may or may not continue compilation, but must eventually throw a CompileException.

In other words: The ErrorHandler may throw a CompileException or not, but the compiler must definitely throw a CompileException if one or more compile errors have occurred.

Specified by:
setCompileErrorHandler in interface ICookable
Parameters:
optionalCompileErrorHandler - null to restore the default behavior (throwing a CompileException

setWarningHandler

public void setWarningHandler(WarningHandler optionalWarningHandler)
Description copied from interface: ICookable
By default, warnings are discarded, but an application my install a custom WarningHandler.

Specified by:
setWarningHandler in interface ICookable
Parameters:
optionalWarningHandler - null to indicate that no warnings be issued

classToType

protected Java.Type classToType(Location location,
                                 clazz)
Wraps a reflection in a Java.Type object.


classesToTypes

protected Java.Type[] classesToTypes(Location location,
                                     [] classes)
Converts an array of es into an array ofJava.Types.


compileToClassLoader

protected final  compileToClassLoader(Java.CompilationUnit compilationUnit)
                                          throws CompileException
Compile the given compilation unit. (A "compilation unit" is typically the contents of a Java™ source file.)

Parameters:
compilationUnit - The parsed compilation unit
Returns:
The into which the compiled classes were defined
Throws:
CompileException

assertNotCooked

protected void assertNotCooked()
Throws:
- This Cookable is already cooked

janino.net