org.codehaus.janino

Class SimpleCompiler

java.lang.Object

org.codehaus.commons.compiler.Cookable

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

Constructors

Constructor and Description
SimpleCompiler()
SimpleCompiler(Scanner scanner, ClassLoader optionalParentClassLoader) Equivalent to SimpleCompiler sc = new SimpleCompiler(); sc.setParentClassLoader(optionalParentClassLoader); sc.cook(scanner);
SimpleCompiler(String fileName) Equivalent to SimpleCompiler sc = new SimpleCompiler(); sc.cook(fileName);
SimpleCompiler(String optionalFileName, InputStream is) Equivalent to SimpleCompiler sc = new SimpleCompiler(); sc.cook(optionalFileName, is);
SimpleCompiler(String optionalFileName, Reader in) Equivalent to SimpleCompiler sc = new SimpleCompiler(); sc.cook(optionalFileName, in);

Method Summary

Modifier and Type	Method and Description
protected Java.Type[]	classesToTypes(Location location, Class<?>[] classes) Converts an array of Classes into an array ofJava.Types.
protected Java.Type	classToType(Location location, Class<?> clazz) Wraps a reflection Class in a Java.Type object.
protected ClassLoader	compileToClassLoader(Java.CompilationUnit compilationUnit) Compiles the given compilation unit.
void	cook(ClassFile[] classFiles) Serializes the given classFiles as bytecode, stores them in a map, and then invokes cook(Map).
void	cook(Java.CompilationUnit compilationUnit) Cooks this compilation unit directly and invokes cook(ClassFile[]).
void	cook(Map<String,byte[]> classes) Creates a ClassLoader that loads the given classes (lazily), and makes that class loader available through getClassLoader().
void	cook(Scanner scanner) Scans, parses and compiles a given compilation unit from the given scanner.
void	cook(String optionalFileName, Reader r) Scans, parses and compiles a given compilation unit from the given Reader.
boolean	equals(Object 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 Object.equals(Object)
ClassLoader	getClassLoader()
int	hashCode()
static void	main(String[] args)
protected Java.Type	optionalClassToType(Location location, Class<?> clazz) Wraps a reflection Class in a Java.Type object.
EnumSet<JaninoOption>	options()
SimpleCompiler	options(EnumSet<JaninoOption> options) Sets the options for all future compilations.
void	setCompileErrorHandler(ErrorHandler optionalCompileErrorHandler)
void	setDebuggingInformation(boolean debugSource, boolean debugLines, boolean debugVars)
void	setNoPermissions()
void	setParentClassLoader(ClassLoader optionalParentClassLoader)
void	setPermissions(Permissions permissions)
void	setWarningHandler(WarningHandler optionalWarningHandler)

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.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

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(@Nullable
                      String optionalFileName,
                      Reader in)
               throws IOException,
                      CompileException

Equivalent to

     SimpleCompiler sc = new SimpleCompiler();
     sc.cook(optionalFileName, in);
 

Throws:

IOException

CompileException

See Also:

SimpleCompiler(), ICookable.cook(String, Reader)

SimpleCompiler

public SimpleCompiler(@Nullable
                      String optionalFileName,
                      InputStream is)
               throws IOException,
                      CompileException

Equivalent to

     SimpleCompiler sc = new SimpleCompiler();
     sc.cook(optionalFileName, is);
 

Throws:

IOException

CompileException

See Also:

SimpleCompiler(), Cookable.cook(String, InputStream)

SimpleCompiler

public SimpleCompiler(String fileName)
               throws IOException,
                      CompileException

Equivalent to

     SimpleCompiler sc = new SimpleCompiler();
     sc.cook(fileName);
 

Throws:

IOException

CompileException

See Also:

SimpleCompiler(), Cookable.cookFile(String)

SimpleCompiler

public SimpleCompiler(Scanner scanner,
                      @Nullable
                      ClassLoader optionalParentClassLoader)
               throws IOException,
                      CompileException

Equivalent to

     SimpleCompiler sc = new SimpleCompiler();
     sc.setParentClassLoader(optionalParentClassLoader);
     sc.cook(scanner);
 

Throws:

IOException

CompileException

See Also:

SimpleCompiler(), setParentClassLoader(ClassLoader), Cookable.cook(Reader)

SimpleCompiler

public SimpleCompiler()

Method Detail

main

public static void main(String[] args)
                 throws Exception

Throws:

Exception

setParentClassLoader

public void setParentClassLoader(@Nullable
                                 ClassLoader optionalParentClassLoader)

Specified by:

setParentClassLoader in interface ICookable

setDebuggingInformation

public void setDebuggingInformation(boolean debugSource,
                                    boolean debugLines,
                                    boolean debugVars)

Specified by:

setDebuggingInformation in interface ICookable

cook

public final void cook(@Nullable
                       String optionalFileName,
                       Reader r)
                throws CompileException,
                       IOException

Scans, parses and compiles a given compilation unit from the given Reader. After completion, getClassLoader() returns a ClassLoader that allows for access to the compiled classes.

Specified by:

cook in interface ICookable

Throws:

CompileException

IOException

cook

public void cook(Scanner scanner)
          throws CompileException,
                 IOException

Scans, parses and compiles a given compilation unit from the given scanner. After completion, getClassLoader() returns a ClassLoader that allows for access to the compiled classes.

Throws:

CompileException

IOException

cook

public void cook(Java.CompilationUnit compilationUnit)
          throws CompileException

Cooks this compilation unit directly and invokes cook(ClassFile[]).

Throws:

CompileException

cook

public void cook(ClassFile[] classFiles)

Serializes the given classFiles as bytecode, stores them in a map, and then invokes cook(Map).

cook

public void cook(Map<String,byte[]> classes)

Creates a ClassLoader that loads the given classes (lazily), and makes that class loader available through getClassLoader().

Parameters:

classes - Maps fully qualified classes names to bytecodes

getClassLoader

public ClassLoader getClassLoader()

Specified by:

getClassLoader in interface ISimpleCompiler

setPermissions

public void setPermissions(Permissions permissions)

Specified by:

setPermissions in interface ISimpleCompiler

setNoPermissions

public void setNoPermissions()

Specified by:

setNoPermissions in interface ISimpleCompiler

equals

public boolean equals(@Nullable
                      Object 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 Object.equals(Object)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

setCompileErrorHandler

public void setCompileErrorHandler(@Nullable
                                   ErrorHandler optionalCompileErrorHandler)

Specified by:

setCompileErrorHandler in interface ICookable

setWarningHandler

public void setWarningHandler(@Nullable
                              WarningHandler optionalWarningHandler)

Specified by:

setWarningHandler in interface ICookable

options

public EnumSet<JaninoOption> options()

Returns:

A reference to the currently effective compilation options; changes to it take effect immediately

options

public SimpleCompiler options(EnumSet<JaninoOption> options)

Sets the options for all future compilations.

optionalClassToType

@Nullable
protected Java.Type optionalClassToType(Location location,
                                                   @Nullable
                                                   Class<?> clazz)

Wraps a reflection Class in a Java.Type object.

classToType

protected Java.Type classToType(Location location,
                                Class<?> clazz)

Wraps a reflection Class in a Java.Type object.

classesToTypes

protected Java.Type[] classesToTypes(Location location,
                                     @Nullable
                                     Class<?>[] classes)

Converts an array of Classes into an array ofJava.Types.

compileToClassLoader

protected final ClassLoader compileToClassLoader(Java.CompilationUnit compilationUnit)
                                          throws CompileException

Compiles the given compilation unit. (A "compilation unit" is typically the contents of a Java source file.)

Parameters:

compilationUnit - The parsed compilation unit

Returns:

The ClassLoader into which the compiled classes were defined

Throws:

CompileException