Package org.codehaus.janino

Class UnitCompiler

java.lang.Object

org.codehaus.janino.UnitCompiler

public class UnitCompiler
extends Object

This class actually implements the Java compiler. It is associated with exactly one compilation unit which it compiles.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	UnitCompiler.SimpleIField	Short-hand implementation of IClass.IField that implements a non-constant, non-static, package-accessible field.

Field Summary

Fields

Modifier and Type	Field	Description
static boolean	JUMP_IF_FALSE	Special value for the orientation parameter of the compileBoolean(Java.Rvalue, CodeContext.Offset, boolean) methods, indicating that the code should be generated such that execution branches if the value on top of the operand stack is FALSE.
static boolean	JUMP_IF_TRUE	Special value for the orientation parameter of the compileBoolean(Java.Rvalue, CodeContext.Offset, boolean) methods, indicating that the code should be generated such that execution branches if the value on top of the operand stack is TRUE.
static Object	NOT_CONSTANT	Special return value for the getConstantValue(Java.Rvalue) method family indicating that the given Java.Rvalue does not evaluate to a constant value.

Constructor Summary

Constructors

Constructor	Description
UnitCompiler(Java.AbstractCompilationUnit abstractCompilationUnit, IClassLoader iClassLoader)

Method Summary

Modifier and Type	Method	Description
protected void	buildLocalVariableMap(Java.CatchClause catchClause, Map<String,Java.LocalVariable> localVars)	Adds the given localVars to the 'local variable map' of the given catchClause.
ClassFile[]	compileUnit(boolean debugSource, boolean debugLines, boolean debugVars)	Generates an array of ClassFile objects which represent the classes and interfaces declared in the compilation unit.
IClass	findClass(String className)	Finds one class or interface declaration in this compilation unit and resolves it into an IClass.
IClass.IMethod	findIMethod(Java.MethodInvocation mi)	Finds methods of the mi.target named mi.methodName, examines the argument types and chooses the most specific method.
IClass.IMethod	findIMethod(Java.SuperclassMethodInvocation superclassMethodInvocation)
IClass.IInvocable	findMostSpecificIInvocable(Java.Locatable locatable, IClass.IInvocable[] iInvocables, IClass[] argumentTypes, boolean boxingPermitted, Java.Scope contextScope)	Determines the applicable invocables and choose the most specific invocable.
Java.AbstractCompilationUnit	getAbstractCompilationUnit()
Object	getConstantValue(Java.Rvalue rv)	Attempts to evaluate as a constant expression.
void	getIMethods(IClass type, String methodName, List<IClass.IMethod> v)	Adds all methods with the given methodName that are declared by the type, its superclasses and all their superinterfaces to the result list v.
Java.LocalVariable	getLocalVariable(Java.CatchParameter parameter)
Java.LocalVariable	getLocalVariable(Java.FunctionDeclarator.FormalParameter parameter)
Java.LocalVariable	getLocalVariable(Java.FunctionDeclarator.FormalParameter parameter, boolean isVariableArityParameter)
Java.LocalVariable	getLocalVariable(Java.LocalVariableDeclarationStatement lvds, Java.VariableDeclarator vd)
String[]	getSingleTypeImport(String name, Location location)	Checks if the given simple name was imported through a single type import.
IClass	importTypeOnDemand(String simpleTypeName, Location location)	6.5.2.BL1.B1.B5, 6.5.2.BL1.B1.B6 Type-import-on-demand. 6.5.5.1.6 Type-import-on-demand declaration.
EnumSet<JaninoOption>	options()
UnitCompiler	options(EnumSet<JaninoOption> options)	Sets the options for all future compilations.
void	setCompileErrorHandler(ErrorHandler compileErrorHandler)	By default, CompileExceptions are thrown on compile errors, but an application my install its own (thread-local) ErrorHandler.
void	setTargetVersion(int version)	Generates class files that target a specified release of the virtual machine, in analogy with JAVAC's -target command line option.
void	setWarningHandler(WarningHandler warningHandler)	By default, warnings are discarded, but an application my install a custom WarningHandler.
IClass.IMethod	toIMethod(Java.MethodDeclarator methodDeclarator)

Methods inherited from class java.lang.Object

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

Field Detail

JUMP_IF_TRUE

public static final boolean JUMP_IF_TRUE

Special value for the orientation parameter of the compileBoolean(Java.Rvalue, CodeContext.Offset, boolean) methods, indicating that the code should be generated such that execution branches if the value on top of the operand stack is TRUE.

See Also:

Constant Field Values

JUMP_IF_FALSE

public static final boolean JUMP_IF_FALSE

Special value for the orientation parameter of the compileBoolean(Java.Rvalue, CodeContext.Offset, boolean) methods, indicating that the code should be generated such that execution branches if the value on top of the operand stack is FALSE.

See Also:

Constant Field Values

NOT_CONSTANT

public static final Object NOT_CONSTANT

Special return value for the getConstantValue(Java.Rvalue) method family indicating that the given Java.Rvalue does not evaluate to a constant value.

Constructor Detail

UnitCompiler

public UnitCompiler(Java.AbstractCompilationUnit abstractCompilationUnit,
                    IClassLoader iClassLoader)

Method Detail

options

public EnumSet<JaninoOption> options()

Returns:

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

options

public UnitCompiler options(EnumSet<JaninoOption> options)

Sets the options for all future compilations.

setTargetVersion

public void setTargetVersion(int version)

Generates class files that target a specified release of the virtual machine, in analogy with JAVAC's -target command line option. By default, Java 6 .class files are generated.

getAbstractCompilationUnit

public Java.AbstractCompilationUnit getAbstractCompilationUnit()

Returns:

The Java.AbstractCompilationUnit that this UnitCompiler compiles

compileUnit

public ClassFile[] compileUnit(boolean debugSource,
                               boolean debugLines,
                               boolean debugVars)
                        throws CompileException

Generates an array of ClassFile objects which represent the classes and interfaces declared in the compilation unit.

Throws:

CompileException

getLocalVariable

public Java.LocalVariable getLocalVariable(Java.LocalVariableDeclarationStatement lvds,
                                           Java.VariableDeclarator vd)
                                    throws CompileException

Returns:

The Java.LocalVariable corresponding with the local variable declaration/declarator

Throws:

CompileException

buildLocalVariableMap

protected void buildLocalVariableMap(Java.CatchClause catchClause,
                                     Map<String,Java.LocalVariable> localVars)
                              throws CompileException

Adds the given localVars to the 'local variable map' of the given catchClause.

Throws:

CompileException

getLocalVariable

public Java.LocalVariable getLocalVariable(Java.FunctionDeclarator.FormalParameter parameter)
                                    throws CompileException

Returns:

The Java.LocalVariable corresponding with the parameter

Throws:

CompileException

getLocalVariable

public Java.LocalVariable getLocalVariable(Java.FunctionDeclarator.FormalParameter parameter,
                                           boolean isVariableArityParameter)
                                    throws CompileException

Parameters:

isVariableArityParameter - Whether the parameter is the last parameter of a 'variable arity' (a.k.a. 'varargs') method declaration

Returns:

The Java.LocalVariable corresponding with the parameter

Throws:

CompileException

getLocalVariable

public Java.LocalVariable getLocalVariable(Java.CatchParameter parameter)
                                    throws CompileException

Returns:

The Java.LocalVariable corresponding with the parameter

Throws:

CompileException

getConstantValue

@Nullable
public final Object getConstantValue(Java.Rvalue rv)
                              throws CompileException

Attempts to evaluate as a constant expression. The result is one of the following: Boolean, Byte, Short, Integer, Long, Float, Double, Character, String, null (representing the null literal.

This method cannot be STATIC, because the constant value may refer to a constant declaration in this compilation unit.

Returns:

NOT_CONSTANT iff the rvalue is not a constant value

Throws:

CompileException

findIMethod

public IClass.IMethod findIMethod(Java.MethodInvocation mi)
                           throws CompileException

Finds methods of the mi.target named mi.methodName, examines the argument types and chooses the most specific method. Checks that only the allowed exceptions are thrown.

Notice that the returned IClass.IMethod may be declared in an enclosing type.

Returns:

The selected IClass.IMethod

Throws:

CompileException

getIMethods

public void getIMethods(IClass type,
                        String methodName,
                        List<IClass.IMethod> v)
                 throws CompileException

Adds all methods with the given methodName that are declared by the type, its superclasses and all their superinterfaces to the result list v.

Throws:

CompileException

findIMethod

public IClass.IMethod findIMethod(Java.SuperclassMethodInvocation superclassMethodInvocation)
                           throws CompileException

Returns:

The IClass.IMethod that implements the superclassMethodInvocation

Throws:

CompileException

findMostSpecificIInvocable

@Nullable
public IClass.IInvocable findMostSpecificIInvocable(Java.Locatable locatable,
                                                    IClass.IInvocable[] iInvocables,
                                                    IClass[] argumentTypes,
                                                    boolean boxingPermitted,
                                                    Java.Scope contextScope)
                                             throws CompileException

Determines the applicable invocables and choose the most specific invocable.

Returns:

The maximally specific IClass.IInvocable or null if no IClass.IInvocable is applicable

Throws:

CompileException

toIMethod

public IClass.IMethod toIMethod(Java.MethodDeclarator methodDeclarator)

Returns:

The IClass.IMethod that implements the methodDeclarator

getSingleTypeImport

@Nullable
public String[] getSingleTypeImport(String name,
                                    Location location)
                             throws CompileException

Checks if the given simple name was imported through a single type import.

Parameters:

name - The simple type name, e.g. "Inner"

Returns:

The fully qualified name, e.g. { "pkg", "Outer", "Inner" }, or null

Throws:

CompileException

importTypeOnDemand

@Nullable
public IClass importTypeOnDemand(String simpleTypeName,
                                 Location location)
                          throws CompileException

6.5.2.BL1.B1.B5, 6.5.2.BL1.B1.B6 Type-import-on-demand.
6.5.5.1.6 Type-import-on-demand declaration.

Returns:

null if the given simpleTypeName cannot be resolved through any of the type-import-on-demand declarations

Throws:

CompileException

findClass

@Nullable
public IClass findClass(String className)

Finds one class or interface declaration in this compilation unit and resolves it into an IClass.

Parameters:

className - Fully qualified class name, e.g. "pkg1.pkg2.Outer$Inner"

Returns:

null if a class or an interface with that name is not declared in this compilation unit

setCompileErrorHandler

public void setCompileErrorHandler(@Nullable
                                   ErrorHandler compileErrorHandler)

By default, CompileExceptions are thrown on compile errors, but an application my install its own (thread-local) 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 does not throw CompileExceptions, then compileUnit(boolean, boolean, boolean) will throw one when the compilation of the unit is finished, and errors had occurred. In other words: The ErrorHandler may throw a CompileException or not, but compileUnit(boolean, boolean, boolean) will definitely throw a CompileException if one or more compile errors have occurred.

Parameters:

compileErrorHandler - null to restore the default behavior (throwing a CompileException)

setWarningHandler

public void setWarningHandler(@Nullable
                              WarningHandler warningHandler)

By default, warnings are discarded, but an application my install a custom WarningHandler.

Parameters:

warningHandler - null to indicate that no warnings be issued