# Uses of Class
org.codehaus.commons.compiler.CompileException

Packages that use CompileException
Package
Description
org.codehaus.commons.compiler
This package declares interfaces for the implementation of an `IExpressionEvaluator`, an `IScriptEvaluator`, an `IClassBodyEvaluator` and an `ISimpleCompiler`.
org.codehaus.commons.compiler.jdk
An implementation of the `org.codehaus.commons.compiler` API that uses the "JAVAC" Java compiler that is part of the "Java Development Kit" (JDK).
org.codehaus.janino
The core of the Janino Java compiler.
org.codehaus.janino.samples
Sample applications for the Janino Java compiler.
org.codehaus.janino.util
Application-independent helper classes.

## Uses of CompileException in org.codehaus.commons.compiler

Methods in org.codehaus.commons.compiler that throw CompileException
Modifier and Type
Method
Description
`final boolean`
AbstractCompiler.`compile(File[] sourceFiles)`
`boolean`
ICompiler.`compile(File[] sourceFiles)`
Reads a set of Java compilation units (a.k.a.
`void`
ICompiler.`compile(Resource[] sourceResources)`
See `ICompiler.compile(File[])`.
`final void`
Cookable.`cook(InputStream is)`
`final void`
Cookable.`cook(InputStream is, String encoding)`
`final void`
Cookable.`cook(Reader r)`
`final void`
Cookable.`cook(String s)`
`final void`
Cookable.`cook(String fileName, InputStream is)`
`final void`
Cookable.`cook(String fileName, InputStream is, String encoding)`
`abstract void`
Cookable.`cook(String fileName, Reader reader)`
`final void`
Cookable.`cook(String fileName, String s)`
`void`
ICookable.`cook(InputStream is)`
Reads, scans, parses and compiles Java tokens from the given `InputStream`, encoded in the "platform default encoding".
`void`
ICookable.`cook(InputStream is, String encoding)`
Reads, scans, parses and compiles Java tokens from the given `InputStream` with the given `encoding`.
`void`
ICookable.`cook(Reader r)`
Reads, scans, parses and compiles Java tokens from the given `Reader`.
`void`
ICookable.`cook(String s)`
Reads, scans, parses and compiles Java tokens from the given `String`.
`void`
ICookable.`cook(String fileName, InputStream is)`
Reads, scans, parses and compiles Java tokens from the given `InputStream`, encoded in the "platform default encoding".
`void`
ICookable.`cook(String fileName, InputStream is, String encoding)`
Reads, scans, parses and compiles Java tokens from the given `InputStream` with the given `encoding`.
`void`
ICookable.`cook(String fileName, Reader r)`
Reads, scans, parses and compiles Java tokens from the given `Reader`.
`void`
ICookable.`cook(String fileName, String s)`
Reads, scans, parses and compiles Java tokens from the given `String`.
`void`
IMultiCookable.`cook(InputStream... inputStreams)`
Same as `Cookable.cook(InputStream)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cook(InputStream[] inputStreams, String[] encodings)`
Same as `Cookable.cook(InputStream, String)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cook(Reader... readers)`
Same as `Cookable.cook(Reader)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cook(String[] strings)`
Same as `Cookable.cook(String)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cook(String[] fileNames, InputStream[] inputStreams)`
Same as `Cookable.cook(String, InputStream)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cook(String[] fileNames, InputStream[] inputStreams, String[] encodings)`
Same as `Cookable.cook(String, InputStream, String)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cook(String[] fileNames, Reader[] readers)`
Same as `Cookable.cook(String, Reader)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cook(String[] fileNames, String[] strings)`
Same as `Cookable.cook(String, String)`, but cooks a set of documents into one class.
`void`
IScriptEvaluator.`cook(Reader... readers)`
Same as `ICookable.cook(Reader)`, but for multiple scripts.
`void`
IScriptEvaluator.`cook(String[] strings)`
Same as `ICookable.cook(String)`, but for multiple scripts.
`void`
IScriptEvaluator.`cook(String[] fileNames, Reader[] readers)`
Same as `ICookable.cook(String, Reader)`, but cooks a set of scripts into one class.
`void`
IScriptEvaluator.`cook(String[] fileNames, String[] strings)`
Same as `ICookable.cook(String, String)`, but for multiple scripts.
`final void`
MultiCookable.`cook(InputStream... inputStreams)`
`final void`
MultiCookable.`cook(InputStream[] inputStreams, String[] encodings)`
`final void`
MultiCookable.`cook(Reader... readers)`
`final void`
MultiCookable.`cook(String[] strings)`
`final void`
MultiCookable.`cook(String[] fileNames, InputStream[] inputStreams)`
`final void`
MultiCookable.`cook(String[] fileNames, InputStream[] inputStreams, String[] encodings)`
`abstract void`
MultiCookable.`cook(String[] fileNames, Reader[] readers)`
`final void`
MultiCookable.`cook(String[] fileNames, String[] strings)`
`final void`
Cookable.`cookFile(File file)`
`final void`
Cookable.`cookFile(File file, String encoding)`
`final void`
Cookable.`cookFile(String fileName)`
`final void`
Cookable.`cookFile(String fileName, String encoding)`
`void`
ICookable.`cookFile(File file)`
Reads, scans, parses and compiles Java tokens from the given `File`, encoded in the "platform default encoding".
`void`
ICookable.`cookFile(File file, String encoding)`
Reads, scans, parses and compiles Java tokens from the given `File` with the given `encoding`.
`void`
ICookable.`cookFile(String fileName)`
Reads, scans, parses and compiles Java tokens from the named file, encoded in the "platform default encoding".
`void`
ICookable.`cookFile(String fileName, String encoding)`
Reads, scans, parses and compiles Java tokens from the named file with the given encoding.
`void`
IMultiCookable.`cookFiles(File[] files)`
Same as `Cookable.cookFile(File)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cookFiles(File[] files, String[] encodings)`
Same as `Cookable.cookFile(File, String)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cookFiles(String[] fileNames)`
Same as `Cookable.cookFile(String)`, but cooks a set of documents into one class.
`void`
IMultiCookable.`cookFiles(String[] fileNames, String[] encodings)`
Same as `Cookable.cookFile(String, String)`, but cooks a set of documents into one class.
`final void`
MultiCookable.`cookFiles(File[] files)`
`final void`
MultiCookable.`cookFiles(File[] files, String[] encodings)`
`final void`
MultiCookable.`cookFiles(String[] fileNames)`
`final void`
MultiCookable.`cookFiles(String[] fileNames, String[] encodings)`
`<T> T`
IExpressionEvaluator.`createFastEvaluator(Reader reader, Class<? extends T> interfaceToImplement, String... parameterNames)`
`<T> T`
IExpressionEvaluator.`createFastEvaluator(String expression, Class<? extends T> interfaceToImplement, String... parameterNames)`
If the parameter and return types of the expression are known at compile time, then a "fast" expression evaluator can be instantiated through `IExpressionEvaluator.createFastEvaluator(String, Class, String[])`.
`<T> T`
IScriptEvaluator.`createFastEvaluator(Reader reader, Class<T> interfaceToImplement, String[] parameterNames)`
If the parameter and return types of the expression are known at compile time, then a "fast" script evaluator can be instantiated through this method.
`<T> T`
IScriptEvaluator.`createFastEvaluator(String script, Class<T> interfaceToImplement, String[] parameterNames)`
`Object`
IClassBodyEvaluator.`createInstance(Reader reader)`
Scans, parses and compiles a class body from the tokens delivered by the the given `Reader`, then creates and returns an instance of that class.
`void`
ErrorHandler.`handleError(String message, Location location)`
May or may not choose to throw a `CompileException`.
`void`
WarningHandler.`handleWarning(String handle, String message, Location location)`
May or may not choose to throw a `CompileException`.

## Uses of CompileException in org.codehaus.commons.compiler.jdk

Methods in org.codehaus.commons.compiler.jdk that throw CompileException
Modifier and Type
Method
Description
`void`
Compiler.`compile(Resource[] sourceResources)`
`void`
Compiler.`compile(Resource[] sourceResources, SortedSet<Location> offsets)`
`void`
ClassBodyEvaluator.`cook(String fileName, Reader r)`
`protected void`
ClassBodyEvaluator.`cook(String fileName, String[] imports, Reader r)`
`void`
ExpressionEvaluator.`cook(String[] fileNames, Reader[] readers)`
`void`
ExpressionEvaluator.`cook(String fileName, Reader reader)`
`void`
ScriptEvaluator.`cook(String[] fileNames, Reader[] readers)`
`protected final void`
ScriptEvaluator.`cook(String[] fileNames, Reader[] readers, String[] imports)`
`void`
ScriptEvaluator.`cook(String fileName, Reader reader)`
`void`
SimpleCompiler.`cook(String fileName, Reader r)`
`<T> T`
ExpressionEvaluator.`createFastEvaluator(Reader reader, Class<? extends T> interfaceToImplement, String... parameterNames)`
`<T> T`
ExpressionEvaluator.`createFastEvaluator(String expression, Class<? extends T> interfaceToImplement, String... parameterNames)`
`<T> T`
ScriptEvaluator.`createFastEvaluator(Reader r, Class<T> interfaceToImplement, String[] parameterNames)`
`<T> T`
ScriptEvaluator.`createFastEvaluator(String script, Class<T> interfaceToImplement, String[] parameterNames)`
`Object`
ClassBodyEvaluator.`createInstance(Reader reader)`
Constructors in org.codehaus.commons.compiler.jdk that throw CompileException
Modifier
Constructor
Description
``
`ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes)`
Equivalent to
``
`ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, Class<?> extendedType, Class<?>[] implementedTypes, ClassLoader parentClassLoader)`
Equivalent to
``
`ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Equivalent to
``
`ScriptEvaluator(String script)`
Equivalent to
``
`ScriptEvaluator(String fileName, InputStream is, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Equivalent to
``
`ScriptEvaluator(String fileName, Reader reader, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Equivalent to
``
`ScriptEvaluator(String script, Class<?> returnType)`
Equivalent to
``
`ScriptEvaluator(String script, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes)`
Equivalent to
``
`ScriptEvaluator(String script, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions)`
Equivalent to

## Uses of CompileException in org.codehaus.janino

Methods in org.codehaus.janino that return CompileException
Modifier and Type
Method
Description
`protected final CompileException`
Parser.`compileException(String message)`
Convenience method for throwing a `CompileException`.
`protected static CompileException`
Parser.`compileException(String message, Location location)`
Convenience method for throwing a `CompileException`.
`protected final CompileException`
TokenStreamImpl.`compileException(String message)`
Convenience method for throwing a `CompileException`.
Methods in org.codehaus.janino that throw CompileException
Modifier and Type
Method
Description
`protected void`
UnitCompiler.`buildLocalVariableMap(Java.CatchClause catchClause, Map<String,Java.LocalVariable> localVars)`
Adds the given localVars to the 'local variable map' of the given catchClause.
`void`
Compiler.`compile(Resource[] sourceResources)`
`protected final ClassLoader`
SimpleCompiler.`compileToClassLoader(Java.AbstractCompilationUnit abstractCompilationUnit)`
Compiles the given compilation unit.
`void`
UnitCompiler.`compileUnit(boolean debugSource, boolean debugLines, boolean debugVars, Collection<ClassFile> generatedClassFiles)`
Generates a set of `ClassFile` objects which represent the classes and interfaces declared in the compilation unit.
`void`
UnitCompiler.`compileUnit(boolean debugSource, boolean debugLines, boolean debugVars, UnitCompiler.ClassFileConsumer storesClassFiles)`
Generates a set of `ClassFile` objects which represent the classes and interfaces declared in the compilation unit.
`final void`
ClassBodyEvaluator.`cook(String fileName, Reader r)`
`void`
ClassBodyEvaluator.`cook(Scanner scanner)`
`void`
ExpressionEvaluator.`cook(String[] fileNames, Reader[] readers)`
`void`
ExpressionEvaluator.`cook(String fileName, Reader reader)`
`final void`
ExpressionEvaluator.`cook(Parser... parsers)`
`final void`
ExpressionEvaluator.`cook(Scanner scanner)`
`final void`
ExpressionEvaluator.`cook(Scanner... scanners)`
Like `ExpressionEvaluator.cook(Scanner)`, but cooks a set of scripts into one class.
`final void`
ScriptEvaluator.`cook(String[] fileNames, Reader[] readers)`
On a 2 GHz Intel Pentium Core Duo under Windows XP with an IBM 1.4.2 JDK, compiling 10000 expressions "a + b" (integer) takes about 4 seconds and 56 MB of main memory.
`void`
ScriptEvaluator.`cook(String fileName, Reader reader)`
`protected void`
ScriptEvaluator.`cook(Java.CompilationUnit compilationUnit)`
Compiles the given compilationUnit, defines it into a `ClassLoader`, loads the generated class, gets the script methods from that class, and makes them available through `ScriptEvaluator.getMethod(int)`.
`final void`
ScriptEvaluator.`cook(Java.CompilationUnit compilationUnit, Collection<Java.MethodDeclarator> methodDeclarators)`
`final void`
ScriptEvaluator.`cook(Parser[] parsers)`
`final void`
ScriptEvaluator.`cook(Scanner... scanners)`
Cooks a set of scripts into one class.
`final void`
SimpleCompiler.`cook(String fileName, Reader r)`
Scans, parses and compiles a given compilation unit from the given `Reader`.
`void`
SimpleCompiler.`cook(Java.AbstractCompilationUnit abstractCompilationUnit)`
Cooks this compilation unit directly.
`void`
SimpleCompiler.`cook(Scanner scanner)`
Scans, parses and compiles a given compilation unit from the given scanner.
`static Object`
ClassBodyEvaluator.`createFastClassBodyEvaluator(Scanner scanner, Class<?> baseType, ClassLoader parentClassLoader)`
Deprecated.
Use `ClassBodyEvaluator.createInstance(Reader)` instead
`static Object`
ClassBodyEvaluator.`createFastClassBodyEvaluator(Scanner scanner, String className, Class<?> extendedClass, Class<?>[] implementedInterfaces, ClassLoader parentClassLoader)`
Deprecated.
Use `ClassBodyEvaluator.createInstance(Reader)` instead
`<T> T`
ExpressionEvaluator.`createFastEvaluator(Reader reader, Class<? extends T> interfaceToImplement, String... parameterNames)`
`<T> T`
ExpressionEvaluator.`createFastEvaluator(String script, Class<? extends T> interfaceToImplement, String... parameterNames)`
`<T> T`
ExpressionEvaluator.`createFastEvaluator(Scanner scanner, Class<T> interfaceToImplement, String... parameterNames)`
Notice: This method is not declared in `IScriptEvaluator`, and is hence only available in this implementation of `org.codehaus.commons.compiler`.
`<T> T`
ScriptEvaluator.`createFastEvaluator(Reader reader, Class<T> interfaceToImplement, String[] parameterNames)`
`<T> T`
ScriptEvaluator.`createFastEvaluator(String script, Class<T> interfaceToImplement, String[] parameterNames)`
`<T> T`
ScriptEvaluator.`createFastEvaluator(Scanner scanner, Class<?> interfaceToImplement, String[] parameterNames)`
Notice: This method is not declared in `IScriptEvaluator`, and is hence only available in this implementation of `org.codehaus.commons.compiler`.
`static Object`
ExpressionEvaluator.`createFastExpressionEvaluator(String expression, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)`
Deprecated.
Use `ExpressionEvaluator.createFastEvaluator(String, Class, String[])` instead:
`static Object`
ExpressionEvaluator.`createFastExpressionEvaluator(Scanner scanner, String[] defaultImports, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)`
Deprecated.
Use `ExpressionEvaluator.createFastEvaluator(Reader, Class, String[])` instead
`static Object`
ExpressionEvaluator.`createFastExpressionEvaluator(Scanner scanner, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)`
Deprecated.
Use `ExpressionEvaluator.createFastEvaluator(Reader, Class, String[])` instead
`static Object`
ScriptEvaluator.`createFastScriptEvaluator(String script, Class<?> interfaceToImplement, String[] parameterNames)`
Deprecated.
Use `ScriptEvaluator.createFastEvaluator(Scanner, Class, String[])` instead
`static Object`
ScriptEvaluator.`createFastScriptEvaluator(Scanner scanner, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)`
Deprecated.
Use `ScriptEvaluator.createFastEvaluator(Scanner, Class, String[])` instead
`static Object`
ScriptEvaluator.`createFastScriptEvaluator(Scanner scanner, String[] defaultImports, String className, Class<?> extendedClass, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)`
Deprecated.
Use `ScriptEvaluator.createFastEvaluator(Scanner,Class,String[])` instead:
`static Object`
ScriptEvaluator.`createFastScriptEvaluator(Scanner scanner, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)`
Deprecated.
Use `ScriptEvaluator.createFastEvaluator(Scanner, Class, String[])` instead
`Object`
ClassBodyEvaluator.`createInstance(Reader reader)`
`void`
Java.AbstractClassDeclaration.`defineSyntheticField(IClass.IField iField)`
`protected Java.AbstractCompilationUnit`
JavaSourceIClassLoader.`findCompilationUnit(String className)`
Finds the Java source file for the named class through the configured 'source resource finder' and parses it.
`final IClass.IConstructor`
IClass.`findIConstructor(IClass[] parameterTypes)`
`final IClass.IMethod`
IClass.`findIMethod(String methodName, IClass[] parameterTypes)`
`IClass.IMethod`
UnitCompiler.`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`
UnitCompiler.`findIMethod(Java.SuperclassMethodInvocation superclassMethodInvocation)`
`IClass.IInvocable`
UnitCompiler.`findMostSpecificIInvocable(Java.Locatable locatable, IClass.IInvocable[] iInvocables, IClass[] argumentTypes, boolean boxingPermitted, Java.Scope contextScope)`
Determines the applicable invocables and choose the most specific invocable.
`IType`
IClass.IAnnotation.`getAnnotationType()`
`ITypeVariableOrIClass[]`
ITypeVariable.`getBounds()`
`abstract Object`
IClass.IField.`getConstantValue()`
Returns the value of the field if it is a compile-time constant value, i.e.
`final Object`
UnitCompiler.`getConstantValue(Java.ArrayInitializerOrRvalue rv)`
Attempts to evaluate as a constant expression.
`final Object`
UnitCompiler.`getConstantValue(Java.Rvalue rv)`
Attempts to evaluate as a constant expression.
`final IClass[]`
IClass.`getDeclaredIClasses()`
Returns the classes and interfaces declared as members of the class (but not inherited classes and interfaces).
`protected IClass[]`
ClassFileIClass.`getDeclaredIClasses2()`
`protected abstract IClass[]`
IClass.`getDeclaredIClasses2()`
`final IClass`
IClass.`getDeclaringIClass()`
`protected IClass`
ClassFileIClass.`getDeclaringIClass2()`
`protected abstract IClass`
IClass.`getDeclaringIClass2()`
`String`
IClass.IField.`getDescriptor()`
`final MethodDescriptor`
IClass.IInvocable.`getDescriptor()`
Returns the method descriptor of this constructor or method.
`MethodDescriptor`
IClass.IConstructor.`getDescriptor2()`
`abstract MethodDescriptor`
IClass.IInvocable.`getDescriptor2()`
Uncached implementation of `IClass.IInvocable.getDescriptor()`.
`MethodDescriptor`
IClass.IMethod.`getDescriptor2()`
`Object`
IClass.IAnnotation.`getElementValue(String name)`
Returns the value of the named element: `Boolean` `Byte` `Character` `Double` `Float` `Integer` `Long` `Short` A primitive value `String` A string value `IClass.IField` An enum constant `IClass` A class literal `IClass.IAnnotation` An annotation `Object``[]` An array value
`final IClass.IAnnotation[]`
IClass.`getIAnnotations()`
`protected IClass.IAnnotation[]`
ClassFileIClass.`getIAnnotations2()`
`protected IClass.IAnnotation[]`
IClass.`getIAnnotations2()`
`final IClass.IMethod[]`
IClass.`getIMethods()`
Returns all methods declared in the class or interface, its superclasses and its superinterfaces.
`void`
UnitCompiler.`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.
`final IClass[]`
IClass.`getInterfaces()`
Returns the interfaces implemented by the class, respectively the superinterfaces of the interface, respectively `{` `Cloneable``,` `Serializable` `}` for arrays.
`protected IClass[]`
ClassFileIClass.`getInterfaces2()`
`protected abstract IClass[]`
IClass.`getInterfaces2()`
`final ITypeVariable[]`
IClass.`getITypeVariables()`
`protected ITypeVariable[]`
ClassFileIClass.`getITypeVariables2()`
`protected abstract ITypeVariable[]`
IClass.`getITypeVariables2()`
The uncached version of `IClass.getDeclaredIConstructors()` which must be implemented by derived classes.
`Java.LocalVariable`
UnitCompiler.`getLocalVariable(Java.CatchParameter parameter)`
`Java.LocalVariable`
UnitCompiler.`getLocalVariable(Java.FunctionDeclarator.FormalParameter parameter)`
`Java.LocalVariable`
UnitCompiler.`getLocalVariable(Java.FunctionDeclarator.FormalParameter parameter, boolean isVariableArityParameter)`
`Java.LocalVariable`
UnitCompiler.`getLocalVariable(Java.LocalVariableDeclarationStatement lvds, Java.VariableDeclarator vd)`
`final IClass`
IClass.`getOuterIClass()`
The following types have an "outer class": Anonymous classes declared in a non-static method of a class Local classes declared in a non-static method of a class Non-static member classes
`protected IClass`
ClassFileIClass.`getOuterIClass2()`
`protected abstract IClass`
IClass.`getOuterIClass2()`
`final IClass[]`
IClass.IInvocable.`getParameterTypes()`
Returns the types of the parameters of this constructor or method.
`abstract IClass[]`
IClass.IInvocable.`getParameterTypes2()`
Opposed to the `Constructor`, there is no magic "`this$0`" parameter.
`abstract IClass`
IClass.IMethod.`getReturnType()`
`String[]`
UnitCompiler.`getSingleTypeImport(String name, Location location)`
Checks if the given simple name was imported through a single type import.
`final IClass`
IClass.`getSuperclass()`
Returns the superclass of the class.
`protected IClass`
ClassFileIClass.`getSuperclass2()`
`protected abstract IClass`
IClass.`getSuperclass2()`
`final IClass[]`
IClass.IInvocable.`getThrownExceptions()`
Returns the types thrown by this constructor or method.
`abstract IClass[]`
IClass.IInvocable.`getThrownExceptions2()`
`abstract IClass`
IClass.IField.`getType()`
`static String[]`
ExpressionEvaluator.`guessParameterNames(Scanner scanner)`
Guess the names of the parameters used in the given expression.
`static String[]`
ScriptEvaluator.`guessParameterNames(Scanner scanner)`
Guesses the names of the parameters used in the given expression.
`void`
FilterWarningHandler.`handleWarning(String handle, String message, Location location)`
`final boolean`
IClass.`hasIMethod(String methodName, IClass[] parameterTypes)`
`boolean`
IClass.`implementsInterface(IClass that)`
If `this` represents a class: Return `true` if this class directly or indirectly implements `that` interface.
`IClass`
UnitCompiler.`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.
`boolean`
IClass.`isAssignableFrom(IClass that)`
Determines if `this` is assignable from that.
`boolean`
IClass.IInvocable.`isLessSpecificThan(IClass.IInvocable that)`
`boolean`
IClass.IMethod.`isLessSpecificThan(IClass.IInvocable that)`
`boolean`
IClass.IInvocable.`isMoreSpecificThan(IClass.IInvocable that)`
`boolean`
IClass.IMethod.`isMoreSpecificThan(IClass.IInvocable that)`
`boolean`
IClass.`isSubclassOf(IClass that)`
Returns `true` if this class is an immediate or non-immediate subclass of `that` class.
`protected void`
ScriptEvaluator.`makeStatements(int idx, Parser parser, List<Java.BlockStatement> resultStatements, List<Java.MethodDeclarator> resultMethods)`
Parses statements from the parser until end-of-input.
`Java.AbstractCompilationUnit`
Parser.`parseAbstractCompilationUnit()`
CompilationUnit := [ PackageDeclaration ] { ImportDeclaration } { TypeDeclaration }
`Java.Atom`
Parser.`parseAdditiveExpression()`
AdditiveExpression := MultiplicativeExpression { ( '+' | '-' ) MultiplicativeExpression }
`Java.Atom`
Parser.`parseAndExpression()`
AndExpression := EqualityExpression { '&' EqualityExpression }
`Java.AnnotationTypeDeclaration`
Parser.`parseAnnotationTypeDeclarationRest(String docComment, Java.Modifier[] modifiers, Parser.InterfaceDeclarationContext context)`
AnnotationTypeDeclarationRest := Identifier AnnotationTypeBody
`Java.Rvalue[]`
Parser.`parseArgumentList()`
ArgumentList := Expression { ',' Expression }
`Java.Rvalue[]`
Parser.`parseArguments()`
Arguments := '(' [ ArgumentList ] ')'
`Java.ArrayInitializer`
Parser.`parseArrayInitializer()`
ArrayInitializer := '{' [ VariableInitializer { ',' VariableInitializer } [ ',' ] '}'
`Java.Statement`
Parser.`parseAssertStatement()`
AssertStatement := 'assert' Expression [ ':' Expression ] ';'
`Java.Atom`
Parser.`parseAssignmentExpression()`
AssignmentExpression := ConditionalExpression [ AssignmentOperator AssignmentExpression ] AssignmentOperator := '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|='
`Java.Block`
Parser.`parseBlock()`
Block := '{' BlockStatements '}'
`Java.BlockStatement`
Parser.`parseBlockStatement()`
BlockStatement := Statement | (1) 'class' ...
`List<Java.BlockStatement>`
Parser.`parseBlockStatements()`
BlockStatements := { BlockStatement }
`Java.Statement`
Parser.`parseBreakStatement()`
BreakStatement := 'break' [ Identifier ] ';'
`Java.CatchParameter`
Parser.`parseCatchParameter()`
CatchFormalParameter := { VariableModifier } CatchType VariableDeclaratorId CatchType := UnannClassType { '|' ClassType } VariableModifier := Annotation | 'final' VariableDeclaratorId := Identifier [ Dims ] Dims := { Annotation } '[' ']' { { Annotation } '[' ']' } UnannClassType := Identifier [ TypeArguments ] | UnannClassOrInterfaceType '.' { Annotation } Identifier [ TypeArguments ] UnannInterfaceType := UnannClassType UnannClassOrInterfaceType := UnannClassType | UnannInterfaceType ClassType := { Annotation } Identifier [ TypeArguments ] | ClassOrInterfaceType '.' { Annotation } Identifier [ TypeArguments ]
`void`
Parser.`parseClassBody(Java.AbstractClassDeclaration classDeclaration)`
ClassBody := '{' { ClassBodyDeclaration } '}'
`void`
Parser.`parseClassBodyDeclaration(Java.AbstractClassDeclaration classDeclaration)`
ClassBodyDeclaration := ';' | ModifiersOpt ( Block | // Instance (JLS7 8.6) or static initializer (JLS7 8.7) 'void' Identifier MethodDeclarationRest | 'class' ClassDeclarationRest | 'interface' InterfaceDeclarationRest | ConstructorDeclarator | [ TypeArguments ] Type Identifier MethodDeclarationRest | Type Identifier FieldDeclarationRest ';' )
`Java.NamedClassDeclaration`
Parser.`parseClassDeclarationRest(String docComment, Java.Modifier[] modifiers, Parser.ClassDeclarationContext context)`
ClassDeclarationRest := Identifier [ typeParameters ] [ 'extends' ReferenceType ] [ 'implements' ReferenceTypeList ] ClassBody
`Java.Atom`
Parser.`parseConditionalAndExpression()`
ConditionalAndExpression := InclusiveOrExpression { '&&' InclusiveOrExpression }
`Java.Atom`
Parser.`parseConditionalExpression()`
ConditionalExpression := ConditionalOrExpression [ '?' Expression ':' ConditionalExpression ]
`Java.Atom`
Parser.`parseConditionalOrExpression()`
ConditionalOrExpression := ConditionalAndExpression { '||' ConditionalAndExpression ]
`Java.ConstructorDeclarator`
Parser.`parseConstructorDeclarator(String docComment, Java.Modifier[] modifiers)`
ConstructorDeclarator := Identifier FormalParameters [ 'throws' ReferenceTypeList ] '{' [ 'this' Arguments ';' | 'super' Arguments ';' | Primary '.' 'super' Arguments ';' ] BlockStatements '}'
`Java.Statement`
Parser.`parseContinueStatement()`
ContinueStatement := 'continue' [ Identifier ] ';'
`Java.Rvalue`
Parser.`parseDimExpr()`
DimExpr := '[' Expression ']'
`Java.Rvalue[]`
Parser.`parseDimExprs()`
DimExprs := DimExpr { DimExpr }
`Java.Statement`
Parser.`parseDoStatement()`
DoStatement := 'do' Statement 'while' '(' Expression ')' ';'
`Java.Statement`
Parser.`parseEmptyStatement()`
EmptyStatement := ';'
`void`
Parser.`parseEnumBody(Java.EnumDeclaration enumDeclaration)`
EnumBody := '{' [ EnumConstant { ',' EnumConstant } [ ',' ] [ ';' ] { ClassBodyDeclaration } '}'
`Java.EnumConstant`
Parser.`parseEnumConstant()`
EnumConstant := [ Annotations ] Identifier [ Arguments ] [ ClassBody ]
`Java.EnumDeclaration`
Parser.`parseEnumDeclarationRest(String docComment, Java.Modifier[] modifiers, Parser.ClassDeclarationContext context)`
EnumDeclarationRest := Identifier [ 'implements' ReferenceTypeList ] EnumBody
`Java.Atom`
Parser.`parseEqualityExpression()`
EqualityExpression := RelationalExpression { ( '==' | '!=' ) RelationalExpression }
`Java.Atom`
Parser.`parseExclusiveOrExpression()`
ExclusiveOrExpression := AndExpression { '^' AndExpression }
`Java.Rvalue`
Parser.`parseExpression()`
Expression := AssignmentExpression | LambdaExpression
`Java.Rvalue[]`
Parser.`parseExpressionList()`
ExpressionList := Expression { ',' Expression }
`Java.Atom`
Parser.`parseExpressionOrType()`
Same as `Parser.parseExpression()`, but types like `int` or `Map<String, Object>` are also parsed.
`Java.Statement`
Parser.`parseExpressionStatement()`
ExpressionStatement := Expression ';'
`Java.VariableDeclarator[]`
Parser.`parseFieldDeclarationRest(String name)`
FieldDeclarationRest := VariableDeclaratorRest { ',' VariableDeclarator }
`Java.FunctionDeclarator.FormalParameter`
Parser.`parseFormalParameter(boolean[] hasEllipsis)`
FormalParameter := [ 'final' ] Type FormalParameterRest
`Java.FunctionDeclarator.FormalParameters`
Parser.`parseFormalParameterList()`
FormalParameterList := FormalParameter { ',' FormalParameter }
`Java.FunctionDeclarator.FormalParameters`
Parser.`parseFormalParameterListRest(Java.Type firstParameterType)`
FormalParameterListRest := Identifier { ',' FormalParameter }
`Java.FunctionDeclarator.FormalParameter`
Parser.`parseFormalParameterRest(Java.Modifier[] modifiers, Java.Type type, boolean[] hasEllipsis)`
FormalParameterRest := [ '.' '.' '.' ] Identifier BracketsOpt
`Java.FunctionDeclarator.FormalParameters`
Parser.`parseFormalParameters()`
FormalParameters := '(' [ FormalParameterList ] ')'
`Java.Statement`
Parser.`parseForStatement()`
ForStatement := 'for' '(' [ ForInit ] ';' [ Expression ] ';' [ ExpressionList ] ')' Statement | 'for' '(' FormalParameter ':' Expression ')' Statement ForInit := Modifiers Type VariableDeclarators | ModifiersOpt PrimitiveType VariableDeclarators | Expression VariableDeclarators (1) | Expression { ',' Expression }
`Java.Statement`
Parser.`parseIfStatement()`
IfStatement := 'if' '(' Expression ')' Statement [ 'else' Statement ]
`Java.AbstractCompilationUnit.ImportDeclaration`
Parser.`parseImportDeclaration()`
ImportDeclaration := 'import' ImportDeclarationBody ';'
`Java.AbstractCompilationUnit.ImportDeclaration`
Parser.`parseImportDeclarationBody()`
ImportDeclarationBody := [ 'static' ] Identifier { '.' Identifier } [ '.' '*' ]
`Java.Atom`
Parser.`parseInclusiveOrExpression()`
InclusiveOrExpression := ExclusiveOrExpression { '|' ExclusiveOrExpression }
`void`
Parser.`parseInterfaceBody(Java.InterfaceDeclaration interfaceDeclaration)`
InterfaceBody := '{' { ';' | ModifiersOpt ( 'void' Identifier MethodDeclarationRest | 'class' ClassDeclarationRest | 'interface' InterfaceDeclarationRest | Type Identifier ( MethodDeclarationRest | FieldDeclarationRest ) ) } '}'
`Java.InterfaceDeclaration`
Parser.`parseInterfaceDeclarationRest(String docComment, Java.Modifier[] modifiers, Parser.InterfaceDeclarationContext context)`
InterfaceDeclarationRest := Identifier [ typeParameters ] [ 'extends' ReferenceTypeList ] InterfaceBody
`Java.Statement`
Parser.`parseLabeledStatement()`
LabeledStatement := Identifier ':' Statement
`Java.Rvalue`
Parser.`parseLiteral()`
Literal := IntegerLiteral | FloatingPointLiteral | BooleanLiteral | CharacterLiteral | StringLiteral | NullLiteral
`Java.Block`
Parser.`parseMethodBody()`
MethodBody := Block
`Java.MethodDeclarator`
Parser.`parseMethodDeclaration()`
Equivalent with `parseMethodDeclaration(false, MethodDeclarationContext.CLASS_DECLARATION)`.
`Java.MethodDeclarator`
Parser.`parseMethodDeclaration(boolean allowDefaultClause, Parser.MethodDeclarationContext context)`
MethodDeclaration := [ DocComment ] Modifiers [ TypeParameters ] VoidOrType Identifier MethodDeclarationRest
`Java.MethodDeclarator`
Parser.`parseMethodDeclarationRest(String docComment, Java.Modifier[] modifiers, Java.TypeParameter[] typeParameters, Java.Type type, String name, boolean allowDefaultClause, Parser.MethodDeclarationContext context)`
MethodDeclarationRest := FormalParameters { '[' ']' } [ 'throws' ReferenceTypeList ] [ 'default' expression ] ( ';' | MethodBody )
`Java.Modifier[]`
Parser.`parseModifiers()`
Modifiers := { Modifier }
`Java.ModuleDeclaration`
Parser.`parseModuleDeclarationRest(Java.Modifier[] modifiers)`
ModuleDeclarationRest := [ 'open' ] 'module' identifier { '.' identifier} '{' { ModuleDirective } '}'
`Java.Atom`
Parser.`parseMultiplicativeExpression()`
MultiplicativeExpression := UnaryExpression { ( '*' | '/' | '%' ) UnaryExpression }
`Java.Modifier`
Parser.`parseOptionalModifier()`
Modifier := Annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' | 'default'
`Java.PackageDeclaration`
Parser.`parsePackageDeclaration()`
PackageDeclaration := 'package' QualifiedIdentifier ';'
`Java.PackageDeclaration`
Parser.`parsePackageDeclarationRest(String docComment, Java.Modifier[] modifiers)`
PackageDeclaration := { PackageModifier } 'package' identifier { '.' identifier} ';'
`Java.PackageMemberTypeDeclaration`
Parser.`parsePackageMemberTypeDeclaration()`
PackageMemberTypeDeclaration := ModifiersOpt PackageMemberTypeDeclarationRest
`Java.Atom`
Parser.`parsePrimary()`
Primary := CastExpression | // CastExpression 15.16 '(' Expression ')' | // ParenthesizedExpression 15.8.5 Literal | // Literal 15.8.1 Name | // AmbiguousName Name Arguments | // MethodInvocation Name '[]' { '[]' } | // ArrayType 10.1 Name '[]' { '[]' } '.' 'class' | // ClassLiteral 15.8.2 'this' | // This 15.8.3 'this' Arguments | // Alternate constructor invocation 8.8.5.1 'super' Arguments | // Unqualified superclass constructor invocation 8.8.5.1 'super' '.' Identifier | // SuperclassFieldAccess 15.11.2 'super' '.' Identifier Arguments | // SuperclassMethodInvocation 15.12.4.9 NewClassInstance | NewAnonymousClassInstance | // ClassInstanceCreationExpression 15.9 NewArray | // ArrayCreationExpression 15.10 NewInitializedArray | // ArrayInitializer 10.6 PrimitiveType { '[]' } | // Type PrimitiveType { '[]' } '.' 'class' | // ClassLiteral 15.8.2 'void' '.' 'class' | // ClassLiteral 15.8.2 MethodReference // MethodReference JLS9 15.13 Name := Identifier { '.' Identifier } CastExpression := '(' PrimitiveType { '[]' } ')' UnaryExpression | '(' Expression ')' UnaryExpression NewClassInstance := 'new' ReferenceType Arguments NewAnonymousClassInstance := 'new' ReferenceType Arguments [ ClassBody ] NewArray := 'new' Type DimExprs { '[]' } NewInitializedArray := 'new' ArrayType ArrayInitializer
`String[]`
Parser.`parseQualifiedIdentifier()`
QualifiedIdentifier := Identifier { '.' Identifier }
`Java.ReferenceType`
Parser.`parseReferenceType()`
ReferenceType := { Annotation } QualifiedIdentifier [ TypeArguments ]
`Java.ReferenceType[]`
Parser.`parseReferenceTypeList()`
ReferenceTypeList := ReferenceType { ',' ReferenceType }
`Java.Atom`
Parser.`parseRelationalExpression()`
RelationalExpression := ShiftExpression { 'instanceof' ReferenceType | '<' ShiftExpression [ { ',' TypeArgument } '>' ] | '<' TypeArgument [ { ',' TypeArgument } '>' ] | ( '>' | '<=' | '>=' ) ShiftExpression }
`Java.Statement`
Parser.`parseReturnStatement()`
ReturnStatement := 'return' [ Expression ] ';'
`Java.Atom`
Parser.`parseSelector(Java.Atom atom)`
Selector := '.' Identifier | // FieldAccess 15.11.1 '.' Identifier Arguments | // MethodInvocation '.' '<' TypeList '>' 'super' Arguments // Superconstructor invocation (?) '.' '<' TypeList '>' 'super' '.' .
`Java.Atom`
Parser.`parseShiftExpression()`
ShiftExpression := AdditiveExpression { ( '<<' | '>>' | '>>>' ) AdditiveExpression }
`Java.Statement`
Parser.`parseStatement()`
Statement := LabeledStatement | Block | IfStatement | ForStatement | WhileStatement | DoStatement | TryStatement | 'switch' ...
`Java.Statement`
Parser.`parseSwitchStatement()`
SwitchStatement := 'switch' '(' Expression ')' '{' { SwitchLabels BlockStatements } '}' SwitchLabels := SwitchLabels { SwitchLabels } SwitchLabel := 'case' Expression ':' | 'default' ':'
`Java.Statement`
Parser.`parseSynchronizedStatement()`
SynchronizedStatement := 'synchronized' '(' expression ')' Block
`Java.Statement`
Parser.`parseThrowStatement()`
ThrowStatement := 'throw' Expression ';'
`Java.Statement`
Parser.`parseTryStatement()`
TryStatement := 'try' Block Catches [ Finally ] | 'try' Block Finally Catches := CatchClause { CatchClause } CatchClause := 'catch' '(' FormalParameter ')' Block Finally := 'finally' Block
`Java.Type`
Parser.`parseType()`
Type := ( 'byte' | 'short' | 'char' | 'int' | 'long' | 'float' | 'double' | 'boolean' | ReferenceType ) { '[' ']' }
`Java.Atom`
Parser.`parseUnaryExpression()`
UnaryExpression := { PrefixOperator } Primary { Selector } { PostfixOperator } PrefixOperator := '++' | '--' | '+' | '-' | '~' | '!' PostfixOperator := '++' | '--'
`Java.VariableDeclarator`
Parser.`parseVariableDeclarator()`
VariableDeclarator := Identifier VariableDeclaratorRest
`Java.VariableDeclarator`
Parser.`parseVariableDeclaratorRest(String name)`
VariableDeclaratorRest := { '[' ']' } [ '=' VariableInitializer ]
`Java.VariableDeclarator[]`
Parser.`parseVariableDeclarators()`
VariableDeclarators := VariableDeclarator { ',' VariableDeclarator }
`Java.ArrayInitializerOrRvalue`
Parser.`parseVariableInitializer()`
VariableInitializer := ArrayInitializer | Expression
`Java.Type`
Parser.`parseVoidOrType()`
VoidOrType := 'void' | Type
`Java.Statement`
Parser.`parseWhileStatement()`
WhileStatement := 'while' '(' Expression ')' Statement
`Token`
Parser.`peek()`
`boolean`
Parser.`peek(String suspected)`
`int`
Parser.`peek(String... suspected)`
`boolean`
Parser.`peek(TokenType suspected)`
`int`
Parser.`peek(TokenType... suspected)`
`Token`
TokenStream.`peek()`
`boolean`
TokenStream.`peek(String suspected)`
`int`
TokenStream.`peek(String... suspected)`
Checks whether the value of the next token equals any of the suspected; does not consume the next token.
`boolean`
TokenStream.`peek(TokenType suspected)`
`int`
TokenStream.`peek(TokenType... suspected)`
Checks whether the type of the next token is any of the suspected; does not consume the next token.
`Token`
TokenStreamImpl.`peek()`
`boolean`
TokenStreamImpl.`peek(String suspected)`
`int`
TokenStreamImpl.`peek(String... suspected)`
`boolean`
TokenStreamImpl.`peek(TokenType suspected)`
`int`
TokenStreamImpl.`peek(TokenType... suspected)`
`Token`
Parser.`peekNextButOne()`
`boolean`
Parser.`peekNextButOne(String suspected)`
`boolean`
Parser.`peekNextButOne(TokenType suspected)`
`Token`
TokenStream.`peekNextButOne()`
`boolean`
TokenStream.`peekNextButOne(String suspected)`
`Token`
TokenStreamImpl.`peekNextButOne()`
`boolean`
TokenStreamImpl.`peekNextButOne(String suspected)`
`boolean`
Parser.`peekRead(String suspected)`
`int`
Parser.`peekRead(String... suspected)`
`String`
Parser.`peekRead(TokenType suspected)`
`boolean`
TokenStream.`peekRead(String suspected)`
Checks whether the value of the next token equals the suspected; if so, consumes the token.
`int`
TokenStream.`peekRead(String... suspected)`
Checks whether the value of the next token is one of the suspected; if so, consumes the token.
`String`
TokenStream.`peekRead(TokenType suspected)`
Checks whether the type of the next token is the suspected; if so, consumes the token.
`int`
TokenStream.`peekRead(TokenType... suspected)`
Checks whether the type of the next token is one of the suspected; if so, consumes the token.
`boolean`
TokenStreamImpl.`peekRead(String suspected)`
`int`
TokenStreamImpl.`peekRead(String... suspected)`
`String`
TokenStreamImpl.`peekRead(TokenType suspected)`
`int`
TokenStreamImpl.`peekRead(TokenType... suspected)`
`Token`
Scanner.`produce()`
Produces and returns the next token.
`Token`
Parser.`read()`
`void`
Parser.`read(String expected)`
`int`
Parser.`read(String... expected)`
`String`
Parser.`read(TokenType expected)`
`Token`
TokenStream.`read()`
`void`
TokenStream.`read(String expected)`
Verifies that the value of the next token equals expected, and consumes the token.
`int`
TokenStream.`read(String... expected)`
Verifies that the value of the next token equals one of the expected, and consumes the token.
`String`
TokenStream.`read(TokenType expected)`
Verifies that the type of the next token is the expected, and consumes the token.
`int`
TokenStream.`read(TokenType... expected)`
Verifies that the type of the next token is one of the expected, and consumes the token.
`Token`
TokenStreamImpl.`read()`
`void`
TokenStreamImpl.`read(String expected)`
`int`
TokenStreamImpl.`read(String... expected)`
`String`
TokenStreamImpl.`read(TokenType expected)`
`int`
TokenStreamImpl.`read(TokenType... expected)`
`void`
Java.AbstractAnnotation.`throwCompileException(String message)`
`void`
Java.AbstractTypeDeclaration.`throwCompileException(String message)`
`void`
Java.Locatable.`throwCompileException(String message)`
Throws a `CompileException` with the given message and this object's location.
`void`
Java.Located.`throwCompileException(String message)`
`final Java.Lvalue`
Java.Atom.`toLvalueOrCompileException()`
`final Java.Rvalue`
Java.Atom.`toRvalueOrCompileException()`
`final Java.Type`
Java.Atom.`toTypeOrCompileException()`
Constructors in org.codehaus.janino that throw CompileException
Modifier
Constructor
Description
``
`ClassBodyEvaluator(String classBody)`
Equivalent to
``
`ClassBodyEvaluator(String fileName, InputStream is)`
Equivalent to
``
`ClassBodyEvaluator(String fileName, Reader reader)`
Equivalent to
``
`ClassBodyEvaluator(Scanner scanner, Class<?> extendedType, Class<?>[] implementedTypes, ClassLoader parentClassLoader)`
Equivalent to
``
`ClassBodyEvaluator(Scanner scanner, ClassLoader parentClassLoader)`
Equivalent to
``
`ClassBodyEvaluator(Scanner scanner, String className, Class<?> extendedType, Class<?>[] implementedTypes, ClassLoader parentClassLoader)`
Equivalent to
``
`ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes)`
Equivalent to
``
`ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, Class<?> extendedClass, Class<?>[] implementedTypes, ClassLoader parentClassLoader)`
Equivalent to
``
`ExpressionEvaluator(String expression, Class<?> expressionType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Equivalent to
``
`ExpressionEvaluator(Scanner scanner, String className, Class<?> extendedType, Class<?>[] implementedTypes, boolean staticMethod, Class<?> expressionType, String methodName, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Creates an expression evaluator with the full configurability.
``
`ExpressionStatement(Java.Rvalue rvalue)`
``
`ScriptEvaluator(String script)`
Equivalent to
``
`ScriptEvaluator(String fileName, InputStream is, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Equivalent to
``
`ScriptEvaluator(String fileName, Reader reader, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Equivalent to
``
`ScriptEvaluator(String script, Class<?> returnType)`
Equivalent to
``
`ScriptEvaluator(String script, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes)`
Equivalent to
``
`ScriptEvaluator(String script, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions)`
Equivalent to
``
`ScriptEvaluator(Scanner scanner, Class<?> extendedType, Class<?>[] implementedTypes, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Equivalent to
``
`ScriptEvaluator(Scanner scanner, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Equivalent to
``
`ScriptEvaluator(Scanner scanner, String className, Class<?> extendedType, Class<?>[] implementedTypes, boolean staticMethod, Class<?> returnType, String methodName, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, ClassLoader parentClassLoader)`
Equivalent to
``
`SimpleCompiler(String fileName)`
Equivalent to
``
`SimpleCompiler(String fileName, InputStream is)`
Equivalent to
``
`SimpleCompiler(String fileName, Reader in)`
Equivalent to
``
`SimpleCompiler(Scanner scanner, ClassLoader parentClassLoader)`
Equivalent to

## Uses of CompileException in org.codehaus.janino.samples

Methods in org.codehaus.janino.samples that throw CompileException
Modifier and Type
Method
Description
`static void`
DeclarationCounter.`main(String[] args)`

## Uses of CompileException in org.codehaus.janino.util

Methods in org.codehaus.janino.util that throw CompileException
Modifier and Type
Method
Description
`Java.AbstractCompilationUnit`
DeepCopier.`copyAbstractCompilationUnit(Java.AbstractCompilationUnit subject)`
`Java.ConstructorInvocation`
DeepCopier.`copyAlternateConstructorInvocation(Java.AlternateConstructorInvocation subject)`
`Java.Lvalue`
DeepCopier.`copyAmbiguousName(Java.AmbiguousName subject)`
`Java.Annotation`
DeepCopier.`copyAnnotation(Java.Annotation subject)`
`Java.Annotation[]`
DeepCopier.`copyAnnotations(Java.Annotation[] subject)`
`Java.AnonymousClassDeclaration`
DeepCopier.`copyAnonymousClassDeclaration(Java.AnonymousClassDeclaration subject)`
`Java.Lvalue`
DeepCopier.`copyArrayAccessExpression(Java.ArrayAccessExpression subject)`
`Java.Rvalue`
DeepCopier.`copyArrayCreationReference(Java.ArrayCreationReference subject)`
`Java.ArrayInitializer`
DeepCopier.`copyArrayInitializer(Java.ArrayInitializer subject)`
`Java.ArrayInitializerOrRvalue`
DeepCopier.`copyArrayInitializerOrRvalue(Java.ArrayInitializerOrRvalue subject)`
`Java.ArrayInitializerOrRvalue[]`
DeepCopier.`copyArrayInitializerOrRvalues(Java.ArrayInitializerOrRvalue[] subject)`
`Java.Rvalue`
DeepCopier.`copyArrayLength(Java.ArrayLength subject)`
`Java.ArrayType`
DeepCopier.`copyArrayType(Java.ArrayType subject)`
`Java.BlockStatement`
DeepCopier.`copyAssertStatement(Java.AssertStatement subject)`
`Java.Rvalue`
DeepCopier.`copyAssignment(Java.Assignment subject)`
`Java.Atom`
DeepCopier.`copyAtom(Java.Atom subject)`
`Java.Rvalue`
DeepCopier.`copyBinaryOperation(Java.BinaryOperation subject)`
`Java.Block`
DeepCopier.`copyBlock(Java.Block b)`
`Java.BlockStatement`
DeepCopier.`copyBlockStatement(Java.BlockStatement subject)`
`List<Java.BlockStatement>`
DeepCopier.`copyBlockStatements(Collection<? extends Java.BlockStatement> subject)`
`Java.Rvalue`
DeepCopier.`copyBooleanLiteral(Java.BooleanLiteral subject)`
`Java.BlockStatement`
DeepCopier.`copyBreakStatement(Java.BreakStatement subject)`
`Java.Rvalue`
DeepCopier.`copyCast(Java.Cast subject)`
`Java.CatchClause`
DeepCopier.`copyCatchClause(Java.CatchClause subject)`
`List<Java.CatchClause>`
DeepCopier.`copyCatchClauses(Collection<? extends Java.CatchClause> subject)`
`Java.CatchParameter`
DeepCopier.`copyCatchParameter(Java.CatchParameter subject)`
`Java.Rvalue`
DeepCopier.`copyCharacterLiteral(Java.CharacterLiteral subject)`
`Java.Rvalue`
DeepCopier.`copyClassInstanceCreationReference(Java.ClassInstanceCreationReference subject)`
`Java.Rvalue`
DeepCopier.`copyClassLiteral(Java.ClassLiteral subject)`
`Java.CompilationUnit`
DeepCopier.`copyCompilationUnit(Java.CompilationUnit subject)`
`Java.Rvalue`
DeepCopier.`copyConditionalExpression(Java.ConditionalExpression subject)`
`Java.ConstructorDeclarator`
DeepCopier.`copyConstructorDeclarator(Java.ConstructorDeclarator subject)`
`Java.ConstructorInvocation`
DeepCopier.`copyConstructorInvocation(Java.ConstructorInvocation subject)`
`Java.BlockStatement`
DeepCopier.`copyContinueStatement(Java.ContinueStatement subject)`
`Java.Rvalue`
DeepCopier.`copyCrement(Java.Crement subject)`
`Java.BlockStatement`
DeepCopier.`copyDoStatement(Java.DoStatement subject)`
`Java.ElementValue`
DeepCopier.`copyElementValue(Java.ElementValue subject)`
`Java.ElementValue`
DeepCopier.`copyElementValueArrayInitializer(Java.ElementValueArrayInitializer subject)`
`Java.ElementValuePair`
DeepCopier.`copyElementValuePair(Java.ElementValuePair subject)`
`Java.ElementValuePair[]`
DeepCopier.`copyElementValuePairs(Java.ElementValuePair[] subject)`
`Java.ElementValue[]`
DeepCopier.`copyElementValues(Java.ElementValue[] subject)`
`Java.BlockStatement`
DeepCopier.`copyEmptyStatement(Java.EmptyStatement subject)`
`Java.EnumConstant`
DeepCopier.`copyEnumConstant(Java.EnumConstant subject)`
`Java.BlockStatement`
DeepCopier.`copyExpressionStatement(Java.ExpressionStatement es)`
`Java.Lvalue`
DeepCopier.`copyFieldAccess(Java.FieldAccess subject)`
`Java.Lvalue`
DeepCopier.`copyFieldAccessExpression(Java.FieldAccessExpression subject)`
`Java.FieldDeclaration`
DeepCopier.`copyFieldDeclaration(Java.FieldDeclaration subject)`
`Java.FieldDeclarationOrInitializer`
DeepCopier.`copyFieldDeclarationOrInitializer(Java.FieldDeclarationOrInitializer subject)`
`Java.Rvalue`
DeepCopier.`copyFloatingPointLiteral(Java.FloatingPointLiteral subject)`
`Java.BlockStatement`
DeepCopier.`copyForEachStatement(Java.ForEachStatement fes)`
`Java.FunctionDeclarator.FormalParameter`
DeepCopier.`copyFormalParameter(Java.FunctionDeclarator.FormalParameter subject)`
`Java.FunctionDeclarator.FormalParameter[]`
DeepCopier.`copyFormalParameters(Java.FunctionDeclarator.FormalParameter[] subject)`
`Java.FunctionDeclarator.FormalParameters`
DeepCopier.`copyFormalParameters(Java.FunctionDeclarator.FormalParameters subject)`
`Java.BlockStatement`
DeepCopier.`copyForStatement(Java.ForStatement fs)`
`Java.FunctionDeclarator`
DeepCopier.`copyFunctionDeclarator(Java.FunctionDeclarator subject)`
`Java.BlockStatement`
DeepCopier.`copyIfStatement(Java.IfStatement is)`
`Java.AbstractCompilationUnit.ImportDeclaration`
DeepCopier.`copyImportDeclaration(Java.AbstractCompilationUnit.ImportDeclaration subject)`
`Java.AbstractCompilationUnit.ImportDeclaration[]`
DeepCopier.`copyImportDeclarations(Java.AbstractCompilationUnit.ImportDeclaration[] subject)`
`Java.Initializer`
DeepCopier.`copyInitializer(Java.Initializer subject)`
`Java.Rvalue`
DeepCopier.`copyInstanceof(Java.Instanceof subject)`
`Java.Rvalue`
DeepCopier.`copyIntegerLiteral(Java.IntegerLiteral subject)`
`Java.BlockStatement`
DeepCopier.`copyLabeledStatement(Java.LabeledStatement ls)`
`Java.LocalClassDeclaration`
DeepCopier.`copyLocalClassDeclaration(Java.LocalClassDeclaration subject)`
`Java.BlockStatement`
DeepCopier.`copyLocalClassDeclarationStatement(Java.LocalClassDeclarationStatement subject)`
`Java.Lvalue`
DeepCopier.`copyLocalVariableAccess(Java.LocalVariableAccess subject)`
`Java.BlockStatement`
DeepCopier.`copyLocalVariableDeclarationStatement(Java.LocalVariableDeclarationStatement subject)`
`Java.TryStatement.Resource`
DeepCopier.`copyLocalVariableDeclaratorResource(Java.TryStatement.LocalVariableDeclaratorResource subject)`
`Java.Lvalue`
DeepCopier.`copyLvalue(Java.Lvalue subject)`
`Java.Annotation`
DeepCopier.`copyMarkerAnnotation(Java.MarkerAnnotation subject)`
`Java.MemberTypeDeclaration`
DeepCopier.`copyMemberAnnotationTypeDeclaration(Java.MemberAnnotationTypeDeclaration subject)`
`Java.MemberTypeDeclaration`
DeepCopier.`copyMemberClassDeclaration(Java.MemberClassDeclaration subject)`
`Java.MemberTypeDeclaration`
DeepCopier.`copyMemberEnumDeclaration(Java.MemberEnumDeclaration subject)`
`Java.MemberTypeDeclaration`
DeepCopier.`copyMemberInterfaceDeclaration(Java.MemberInterfaceDeclaration subject)`
`Java.MemberTypeDeclaration`
DeepCopier.`copyMemberTypeDeclaration(Java.MemberTypeDeclaration subject)`
`Java.MethodDeclarator`
DeepCopier.`copyMethodDeclarator(Java.MethodDeclarator subject)`
`Java.Rvalue`
DeepCopier.`copyMethodInvocation(Java.MethodInvocation subject)`
`Java.Rvalue`
DeepCopier.`copyMethodReference(Java.MethodReference subject)`
`Java.Modifier`
DeepCopier.`copyModifier(Java.Modifier modifier)`
`Java.Modifier[]`
DeepCopier.`copyModifiers(Java.Modifier[] subject)`
`Java.ModularCompilationUnit`
DeepCopier.`copyModularCompilationUnit(Java.ModularCompilationUnit subject)`
`Java.Rvalue`
DeepCopier.`copyNewAnonymousClassInstance(Java.NewAnonymousClassInstance subject)`
`Java.Rvalue`
DeepCopier.`copyNewArray(Java.NewArray subject)`
`Java.Rvalue`
DeepCopier.`copyNewClassInstance(Java.NewClassInstance subject)`
`Java.Rvalue`
DeepCopier.`copyNewInitializedArray(Java.NewInitializedArray subject)`
`Java.Annotation`
DeepCopier.`copyNormalAnnotation(Java.NormalAnnotation subject)`
`Java.Rvalue`
DeepCopier.`copyNullLiteral(Java.NullLiteral subject)`
`Java.ArrayInitializer`
DeepCopier.`copyOptionalArrayInitializer(Java.ArrayInitializer subject)`
`Java.ArrayInitializerOrRvalue`
DeepCopier.`copyOptionalArrayInitializerOrRvalue(Java.ArrayInitializerOrRvalue subject)`
`Java.ArrayType`
DeepCopier.`copyOptionalArrayType(Java.ArrayType subject)`
`Java.Atom`
DeepCopier.`copyOptionalAtom(Java.Atom subject)`
`Java.Block`
DeepCopier.`copyOptionalBlock(Java.Block subject)`
`Java.BlockStatement`
DeepCopier.`copyOptionalBlockStatement(Java.BlockStatement subject)`
`Java.ConstructorInvocation`
DeepCopier.`copyOptionalConstructorInvocation(Java.ConstructorInvocation subject)`
`Java.ElementValue`
DeepCopier.`copyOptionalElementValue(Java.ElementValue subject)`
`Java.PackageDeclaration`
DeepCopier.`copyOptionalPackageDeclaration(Java.PackageDeclaration subject)`
`Java.ReferenceType`
DeepCopier.`copyOptionalReferenceType(Java.ReferenceType subject)`
`Java.ReferenceType[]`
DeepCopier.`copyOptionalReferenceTypes(Java.ReferenceType[] subject)`
`Java.Rvalue`
DeepCopier.`copyOptionalRvalue(Java.Rvalue subject)`
`Java.Rvalue[]`
DeepCopier.`copyOptionalRvalues(Java.Rvalue[] subject)`
`List<Java.BlockStatement>`
DeepCopier.`copyOptionalStatements(Collection<? extends Java.BlockStatement> subject)`
`Java.Type`
DeepCopier.`copyOptionalType(Java.Type subject)`
`Java.TypeArgument[]`
DeepCopier.`copyOptionalTypeArguments(Java.TypeArgument[] subject)`
`Java.TypeParameter[]`
DeepCopier.`copyOptionalTypeParameters(Java.TypeParameter[] subject)`
`Java.Atom`
DeepCopier.`copyPackage(Java.Package subject)`
`Java.PackageDeclaration`
DeepCopier.`copyPackageDeclaration(Java.PackageDeclaration subject)`
`Java.TypeDeclaration`
DeepCopier.`copyPackageMemberAnnotationTypeDeclaration(Java.PackageMemberAnnotationTypeDeclaration subject)`
`Java.TypeDeclaration`
DeepCopier.`copyPackageMemberClassDeclaration(Java.PackageMemberClassDeclaration subject)`
`Java.TypeDeclaration`
DeepCopier.`copyPackageMemberEnumDeclaration(Java.PackageMemberEnumDeclaration subject)`
`Java.TypeDeclaration`
DeepCopier.`copyPackageMemberInterfaceDeclaration(Java.PackageMemberInterfaceDeclaration subject)`
`Java.PackageMemberTypeDeclaration`
DeepCopier.`copyPackageMemberTypeDeclaration(Java.PackageMemberTypeDeclaration subject)`
`Java.Rvalue`
DeepCopier.`copyParameterAccess(Java.ParameterAccess pa)`
`Java.Lvalue`
DeepCopier.`copyParenthesizedExpression(Java.ParenthesizedExpression subject)`
`Java.Type`
DeepCopier.`copyPrimitiveType(Java.PrimitiveType bt)`
`Java.Rvalue`
DeepCopier.`copyQualifiedThisReference(Java.QualifiedThisReference subject)`
`Java.ReferenceType`
DeepCopier.`copyReferenceType(Java.ReferenceType subject)`
`Java.ReferenceType[]`
DeepCopier.`copyReferenceTypes(Java.ReferenceType[] subject)`
`Java.TryStatement.Resource`
DeepCopier.`copyResource(Java.TryStatement.Resource subject)`
`List<Java.TryStatement.Resource>`
DeepCopier.`copyResources(Collection<? extends Java.TryStatement.Resource> subject)`
`Java.BlockStatement`
DeepCopier.`copyReturnStatement(Java.ReturnStatement subject)`
`Java.Rvalue`
DeepCopier.`copyRvalue(Java.Rvalue subject)`
`Java.Type`
DeepCopier.`copyRvalueMemberType(Java.RvalueMemberType subject)`
`List<Java.Rvalue>`
DeepCopier.`copyRvalues(Collection<? extends Java.Rvalue> subject)`
`Java.Rvalue[]`
DeepCopier.`copyRvalues(Java.Rvalue[] subject)`
`Java.Rvalue`
DeepCopier.`copySimpleLiteral(Java.SimpleConstant subject)`
`Java.Type`
DeepCopier.`copySimpleType(Java.SimpleType st)`
`Java.Annotation`
DeepCopier.`copySingleElementAnnotation(Java.SingleElementAnnotation subject)`
`Java.AbstractCompilationUnit.ImportDeclaration`
DeepCopier.`copySingleStaticImportDeclaration(Java.AbstractCompilationUnit.SingleStaticImportDeclaration stid)`
`Java.AbstractCompilationUnit.ImportDeclaration`
DeepCopier.`copySingleTypeImportDeclaration(Java.AbstractCompilationUnit.SingleTypeImportDeclaration stid)`
`Java.Statement`
DeepCopier.`copyStatement(Java.Statement subject)`
`List<Java.BlockStatement>`
DeepCopier.`copyStatements(Collection<? extends Java.BlockStatement> subject)`
`Java.AbstractCompilationUnit.ImportDeclaration`
DeepCopier.`copyStaticImportOnDemandDeclaration(Java.AbstractCompilationUnit.StaticImportOnDemandDeclaration siodd)`
`Java.Rvalue`
DeepCopier.`copyStringLiteral(Java.StringLiteral subject)`
`Java.Lvalue`
DeepCopier.`copySuperclassFieldAccessExpression(Java.SuperclassFieldAccessExpression subject)`
`Java.Rvalue`
DeepCopier.`copySuperclassMethodInvocation(Java.SuperclassMethodInvocation subject)`
`Java.ConstructorInvocation`
DeepCopier.`copySuperConstructorInvocation(Java.SuperConstructorInvocation subject)`
`Java.SwitchStatement.SwitchBlockStatementGroup`
DeepCopier.`copySwitchBlockStatementGroup(Java.SwitchStatement.SwitchBlockStatementGroup subject)`
`List<Java.SwitchStatement.SwitchBlockStatementGroup>`
DeepCopier.`copySwitchBlockStatementGroups(Collection<? extends Java.SwitchStatement.SwitchBlockStatementGroup> subject)`
`Java.BlockStatement`
DeepCopier.`copySwitchStatement(Java.SwitchStatement subject)`
`Java.BlockStatement`
DeepCopier.`copySynchronizedStatement(Java.SynchronizedStatement subject)`
`Java.Rvalue`
DeepCopier.`copyTextBlock(Java.TextBlock subject)`
`Java.Rvalue`
DeepCopier.`copyThisReference(Java.ThisReference subject)`
`Java.BlockStatement`
DeepCopier.`copyThrowStatement(Java.ThrowStatement subject)`
`Java.BlockStatement`
DeepCopier.`copyTryStatement(Java.TryStatement ts)`
`Java.Type`
DeepCopier.`copyType(Java.Type subject)`
`Java.TypeArgument`
DeepCopier.`copyTypeArgument(Java.TypeArgument subject)`
`Java.TypeArgument[]`
DeepCopier.`copyTypeArguments(Java.TypeArgument[] subject)`
`Java.TypeBodyDeclaration`
DeepCopier.`copyTypeBodyDeclaration(Java.TypeBodyDeclaration subject)`
`Java.TypeDeclaration`
DeepCopier.`copyTypeDeclaration(Java.TypeDeclaration subject)`
`Java.AbstractCompilationUnit.ImportDeclaration`
DeepCopier.`copyTypeImportOnDemandDeclaration(Java.AbstractCompilationUnit.TypeImportOnDemandDeclaration tiodd)`
`Java.TypeParameter`
DeepCopier.`copyTypeParameter(Java.TypeParameter subject)`
`Java.TypeParameter[]`
DeepCopier.`copyTypeParameters(Java.TypeParameter[] subject)`
`Java.Type[]`
DeepCopier.`copyTypes(Java.Type[] subject)`
`Java.Rvalue`
DeepCopier.`copyUnaryOperation(Java.UnaryOperation subject)`
`Java.TryStatement.Resource`
DeepCopier.`copyVariableAccessResource(Java.TryStatement.VariableAccessResource subject)`
`Java.VariableDeclarator`
DeepCopier.`copyVariableDeclarator(Java.VariableDeclarator subject)`
`Java.VariableDeclarator[]`
DeepCopier.`copyVariableDeclarators(Java.VariableDeclarator[] subject)`
`Java.BlockStatement`
DeepCopier.`copyWhileStatement(Java.WhileStatement ws)`
`Java.TypeArgument`
DeepCopier.`copyWildcard(Java.Wildcard subject)`