Package org.codehaus.janino

# Class ScriptEvaluator

java.lang.Object
org.codehaus.commons.compiler.Cookable
org.codehaus.commons.compiler.MultiCookable
org.codehaus.janino.ScriptEvaluator

All Implemented Interfaces:
  `ICookable`, `IMultiCookable`, `IScriptEvaluator`

public class ScriptEvaluator extends MultiCookable implements IScriptEvaluator
An implementation of `IScriptEvaluator` that utilizes the JANINO Java compiler.

This implementation implements the concept of "Local methods", i.e. statements may be freely intermixed with method declarations. These methods are typically called by the "main code" of the script evaluator. One limitation exists: When cooking multiple scripts in one `ScriptEvaluator`, then local method signatures (names and parameter types) must not collide between scripts.

A plethora of "convenience constructors" exist that execute the setup steps instantly. Their use is discouraged, in favor of using the default constructor, plus calling a number of setters, and then one of the `cook()` methods.

## Field Summary

### Fields inherited from interface org.codehaus.commons.compiler.IScriptEvaluator

`DEFAULT_METHOD_NAME, DEFAULT_RETURN_TYPE`

## Constructor Summary

Constructors
Constructor
Description
`ScriptEvaluator()`
Constructs a script evaluator with all the default settings.
`ScriptEvaluator(int count)`
Constructs a script evaluator with the given number of scripts.
`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

## Method Summary

Modifier and Type
Method
Description
`protected Java.Type[]`
`classesToTypes(Location location, Class<?>[] classes)`
`protected Java.Type`
`classToType(Location loc, Class<?> clazz)`
`final void`
`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`
`cook(String fileName, Reader reader)`
Reads, scans, parses and compiles Java tokens from the given `Reader`.
`protected void`
`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 `getMethod(int)`.
`final void`
`cook(Java.CompilationUnit compilationUnit, Collection<Java.MethodDeclarator> methodDeclarators)`
`final void`
`cook(Parser[] parsers)`
`final void`
`cook(Scanner... scanners)`
Cooks a set of scripts into one class.
`<T> T`
`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`
`createFastEvaluator(String script, Class<T> interfaceToImplement, String[] parameterNames)`
`<T> T`
`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`
`createFastScriptEvaluator(String script, Class<?> interfaceToImplement, String[] parameterNames)`
Deprecated.
Use `createFastEvaluator(Scanner, Class, String[])` instead
`static Object`
`createFastScriptEvaluator(Scanner scanner, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)`
Deprecated.
Use `createFastEvaluator(Scanner, Class, String[])` instead
`static Object`
`createFastScriptEvaluator(Scanner scanner, String[] defaultImports, String className, Class<?> extendedClass, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)`
Deprecated.
Use `createFastEvaluator(Scanner,Class,String[])` instead:
`static Object`
`createFastScriptEvaluator(Scanner scanner, String className, Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, ClassLoader parentClassLoader)`
Deprecated.
Use `createFastEvaluator(Scanner, Class, String[])` instead
`Object`
`evaluate()`
Shorthand for `evaluate``(new Object[0])`.
`Object`
`evaluate(int idx, Object[] arguments)`
Same as `IScriptEvaluator.evaluate(Object[])`, but for multiple scripts.
`Object`
`evaluate(Object[] arguments)`
Calls the script with concrete parameter values.
`Map<String,byte[]>`
`getBytecodes()`
`Class<?>`
`getClazz()`
`String[]`
`getDefaultImports()`
`Class<?>`
`getDefaultReturnType()`
`Method`
`getMethod()`
`Method`
`getMethod(int idx)`
Same as `IScriptEvaluator.getMethod()`, but for multiple scripts.
`Method[]`
`getResult()`
`protected final Class<?>`
`getReturnType(int index)`
`static String[]`
`guessParameterNames(Scanner scanner)`
Guesses the names of the parameters used in the given expression.
`protected void`
`makeStatements(int idx, Parser parser, List<Java.BlockStatement> resultStatements, List<Java.MethodDeclarator> resultMethods)`
Parses statements from the parser until end-of-input.
`protected Java.Type`
`optionalClassToType(Location loc, Class<?> clazz)`
`EnumSet<JaninoOption>`
`options()`
`ScriptEvaluator`
`options(EnumSet<JaninoOption> options)`
Sets the options for all future compilations.
`void`
`setClassName(String className)`
`void`
`setCompileErrorHandler(ErrorHandler compileErrorHandler)`
Installs an `ErrorHandler` which is invoked during compilation on each error.
`void`
`setDebuggingInformation(boolean debugSource, boolean debugLines, boolean debugVars)`
Determines what kind of debugging information is included in the generates classes.
`void`
`setDefaultImports(String... defaultImports)`
`void`
`setDefaultReturnType(Class<?> defaultReturnType)`
When this `IScriptEvaluator` is coooked, then the defaultReturnType applies to all scripts for which no explicit return type was configured.
`void`
`setExtendedClass(Class<?> extendedType)`
`void`
`setImplementedInterfaces(Class<?>[] implementedTypes)`
`void`
`setMethodName(String methodName)`
Defines the name of the generated method.
`void`
`setMethodNames(String[] methodNames)`
Same as `IScriptEvaluator.setMethodName(String)`, but for multiple scripts.
`void`
`setOverrideMethod(boolean overrideMethod)`
Defines whether the generated method overrides a methods declared in a supertype.
`void`
`setOverrideMethod(boolean[] overrideMethod)`
Same as `IScriptEvaluator.setOverrideMethod(boolean)`, but for multiple scripts.
`void`
`setParameters(String[][] parameterNames, Class<?>[][] parameterTypes)`
Same as `IScriptEvaluator.setParameters(String[], Class[])`, but for multiple scripts.
`void`
`setParameters(String[] parameterNames, Class<?>[] parameterTypes)`
Defines the names and types of the parameters of the generated method.
`void`
`setParentClassLoader(ClassLoader parentClassLoader)`
The "parent class loader" is used to load referenced classes.
`void`
`setReturnType(Class<?> returnType)`
Defines the return type of the generated method.
`void`
`setReturnTypes(Class<?>[] returnTypes)`
Configures the return types of the generated methods.
`void`
`setScriptCount(int count)`
`void`
`setSourceVersion(int version)`
Specifies the version of source code accepted, in analogy with JAVAC's `-source` command line option.
`void`
`setStaticMethod(boolean staticMethod)`
Defines whether the generated method should be STATIC or not.
`void`
`setStaticMethod(boolean[] staticMethod)`
Same as `IScriptEvaluator.setStaticMethod(boolean)`, but for multiple scripts.
`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`
`setThrownExceptions(Class<?>[] thrownExceptions)`
Defines the exceptions that the generated method may throw.
`void`
`setThrownExceptions(Class<?>[][] thrownExceptions)`
Same as `IScriptEvaluator.setThrownExceptions(Class[])`, but for multiple scripts.
`void`
`setWarningHandler(WarningHandler warningHandler)`
By default, warnings are discarded, but an application my install a custom `WarningHandler`.

### Methods inherited from class org.codehaus.commons.compiler.MultiCookable

`cook, cook, cook, cook, cook, cook, cook, cookFiles, cookFiles, cookFiles, cookFiles`

### Methods inherited from class org.codehaus.commons.compiler.Cookable

`cook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFile`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, 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`

### Methods inherited from interface org.codehaus.commons.compiler.IMultiCookable

`cook, cook, cook, cook, cookFiles, cookFiles, cookFiles, cookFiles`

### Methods inherited from interface org.codehaus.commons.compiler.IScriptEvaluator

`cook, cook, cook`

## Constructor Details

### ScriptEvaluator

public ScriptEvaluator(String script) throws CompileException
Equivalent to

         ScriptEvaluator se = new ScriptEvaluator();
         se.cook(script);

Throws:
  `CompileException`
See Also:
  - `ScriptEvaluator()`
  - `Cookable.cook(String)`

### ScriptEvaluator

public ScriptEvaluator(String script, Class<?> returnType) throws CompileException
Equivalent to

         ScriptEvaluator se = new ScriptEvaluator();
         se.setReturnType(returnType);
         se.cook(script);

Throws:
  `CompileException`
See Also:
  - `ScriptEvaluator()`
  - `setReturnType(Class)`
  - `Cookable.cook(String)`

### ScriptEvaluator

public ScriptEvaluator(String script, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes) throws CompileException
Equivalent to

         ScriptEvaluator se = new ScriptEvaluator();
         se.setReturnType(returnType);
         se.setParameters(parameterNames, parameterTypes);
         se.cook(script);

Throws:
  `CompileException`
See Also:
  - `ScriptEvaluator()`
  - `setReturnType(Class)`
  - `setParameters(String[], Class[])`
  - `Cookable.cook(String)`

### ScriptEvaluator

public ScriptEvaluator(String script, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions) throws CompileException
Equivalent to

         ScriptEvaluator se = new ScriptEvaluator();
         se.setReturnType(returnType);
         se.setParameters(parameterNames, parameterTypes);
         se.setThrownExceptions(thrownExceptions);
         se.cook(script);

Throws:
  `CompileException`
See Also:
  - `ScriptEvaluator()`
  - `setReturnType(Class)`
  - `setParameters(String[], Class[])`
  - `setThrownExceptions(Class[])`
  - `Cookable.cook(String)`

### ScriptEvaluator

public ScriptEvaluator(@Nullable String fileName, InputStream is, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException
Equivalent to

         ScriptEvaluator se = new ScriptEvaluator();
         se.setReturnType(returnType);
         se.setParameters(parameterNames, parameterTypes);
         se.setThrownExceptions(thrownExceptions);
         se.setParentClassLoader(parentClassLoader);
         se.cook(fileName, is);

Throws:
  `CompileException`
  `IOException`
See Also:
  - `ScriptEvaluator()`
  - `setReturnType(Class)`
  - `setParameters(String[], Class[])`
  - `setThrownExceptions(Class[])`
  - `SimpleCompiler.setParentClassLoader(ClassLoader)`
  - `Cookable.cook(String, InputStream)`

### ScriptEvaluator

public ScriptEvaluator(@Nullable String fileName, Reader reader, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException
Equivalent to

         ScriptEvaluator se = new ScriptEvaluator();
         se.setReturnType(returnType);
         se.setParameters(parameterNames, parameterTypes);
         se.setThrownExceptions(thrownExceptions);
         se.setParentClassLoader(parentClassLoader);
         se.cook(reader);

Throws:
  `CompileException`
  `IOException`
See Also:
  - `ScriptEvaluator()`
  - `setReturnType(Class)`
  - `setParameters(String[], Class[])`
  - `setThrownExceptions(Class[])`
  - `SimpleCompiler.setParentClassLoader(ClassLoader)`
  - `Cookable.cook(String, Reader)`

### ScriptEvaluator

public ScriptEvaluator(Scanner scanner, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException
Equivalent to

         ScriptEvaluator se = new ScriptEvaluator();
         se.setReturnType(returnType);
         se.setParameters(parameterNames, parameterTypes);
         se.setThrownExceptions(thrownExceptions);
         se.setParentClassLoader(parentClassLoader);
         se.cook(scanner);

Throws:
  `CompileException`
  `IOException`
See Also:
  - `ScriptEvaluator()`
  - `setReturnType(Class)`
  - `setParameters(String[], Class[])`
  - `setThrownExceptions(Class[])`
  - `SimpleCompiler.setParentClassLoader(ClassLoader)`
  - `Cookable.cook(Reader)`

### ScriptEvaluator

public ScriptEvaluator(Scanner scanner, @Nullable Class<?> extendedType, Class<?>[] implementedTypes, Class<?> returnType, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException
Equivalent to

         ScriptEvaluator se = new ScriptEvaluator();
         se.setExtendedType(extendedType);
         se.setImplementedTypes(implementedTypes);
         se.setReturnType(returnType);
         se.setParameters(parameterNames, parameterTypes);
         se.setThrownExceptions(thrownExceptions);
         se.setParentClassLoader(parentClassLoader);
         se.cook(scanner);

Throws:
  `CompileException`
  `IOException`
See Also:
  - `ScriptEvaluator()`
  - `ClassBodyEvaluator.setExtendedClass(Class)`
  - `ClassBodyEvaluator.setImplementedInterfaces(Class[])`
  - `setReturnType(Class)`
  - `setParameters(String[], Class[])`
  - `setThrownExceptions(Class[])`
  - `SimpleCompiler.setParentClassLoader(ClassLoader)`
  - `Cookable.cook(Reader)`

### ScriptEvaluator

public ScriptEvaluator(Scanner scanner, String className, @Nullable Class<?> extendedType, Class<?>[] implementedTypes, boolean staticMethod, Class<?> returnType, String methodName, String[] parameterNames, Class<?>[] parameterTypes, Class<?>[] thrownExceptions, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException
Equivalent to

         ScriptEvaluator se = new ScriptEvaluator();
         se.setClassName(className);
         se.setExtendedType(extendedType);
         se.setImplementedTypes(implementedTypes);
         se.setStaticMethod(staticMethod);
         se.setReturnType(returnType);
         se.setMethodName(methodName);
         se.setParameters(parameterNames, parameterTypes);
         se.setThrownExceptions(thrownExceptions);
         se.setParentClassLoader(parentClassLoader);
         se.cook(scanner);

Throws:
  `CompileException`
  `IOException`
See Also:
  - `ScriptEvaluator()`
  - `ClassBodyEvaluator.setClassName(String)`
  - `ClassBodyEvaluator.setExtendedClass(Class)`
  - `ClassBodyEvaluator.setImplementedInterfaces(Class[])`
  - `setStaticMethod(boolean)`
  - `setReturnType(Class)`
  - `setMethodName(String)`
  - `setParameters(String[], Class[])`
  - `setThrownExceptions(Class[])`
  - `SimpleCompiler.setParentClassLoader(ClassLoader)`
  - `Cookable.cook(Reader)`

### ScriptEvaluator

public ScriptEvaluator()
Constructs a script evaluator with all the default settings.

### ScriptEvaluator

public ScriptEvaluator(int count)
Constructs a script evaluator with the given number of scripts.

The argument of all following invocations of `setMethodNames(String[])`, `setOverrideMethod(boolean[])`, `setParameters(String[][], Class[][])`, `setReturnTypes(Class[])`, `setStaticMethod(boolean[])`, `setThrownExceptions(Class[][])`, `cook(Parser[])`, `MultiCookable.cook(Reader[])`, `cook(Scanner[])`, `MultiCookable.cook(String[])`, `cook(String[], Reader[])` and `MultiCookable.cook(String[], String[])` must be arrays with exactly that length.

If a different constructor is used, then the first invocation of one of the above method implicitly sets the script count.

## Method Details

### setParentClassLoader

public void setParentClassLoader(@Nullable ClassLoader parentClassLoader)
Description copied from interface: `IScriptEvaluator`
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
`ClassLoaders.BOOTCLASSPATH_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 `IScriptEvaluator`

### setDebuggingInformation

public void setDebuggingInformation(boolean debugSource, boolean debugLines, boolean debugVars)
Description copied from interface: `IScriptEvaluator`
Determines what kind of debugging information is included in the generates classes. The default is typically "`-g:none`".

Specified by:
  `setDebuggingInformation` in interface `IScriptEvaluator`

### setSourceVersion

public void setSourceVersion(int version)
Description copied from interface: `ICookable`
Specifies the version of source code accepted, in analogy with JAVAC's `-source` command line option. May be ignored by an implementation (e.g. the `janino` implementation always accepts the language features as described on the home page). Allowed values, and the default value, depend on the implementation. `-1` means to use a default version.

Specified by:
  `setSourceVersion` in interface `ICookable`

### setTargetVersion

public void setTargetVersion(int version)
Description copied from interface: `ICookable`
Generates class files that target a specified release of the virtual machine, in analogy with JAVAC's `-target` command line option. Allowed values depend on the implementation. The default value also depends on the implementation. The only invariant is that the generated class files are suitable for the currently executing JVM. `-1` means to use a default version.

Specified by:
  `setTargetVersion` in interface `ICookable`

### setCompileErrorHandler

public void setCompileErrorHandler(@Nullable ErrorHandler compileErrorHandler)
Description copied from interface: `IScriptEvaluator`
Installs an `ErrorHandler` which is invoked during compilation on each error. (By default, the compilation throws a `CompileException` on the first error and terminates.)

If the given `ErrorHandler` throws a `CompileException`, then the compilation terminates and the exception is propagated.

If the given `ErrorHandler` does not throw a `CompileException` but completes normally, then the compilation may or may not continue, depending on the error. Iff the compilation completes normally but errors were reported, then it will throw a `CompileException` indicating the number of errors.

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

Specified by:
  `setCompileErrorHandler` in interface `IScriptEvaluator`
Parameters:
  `compileErrorHandler` - `null` to restore the default behavior (throwing a `CompileException`)

### setWarningHandler

public void setWarningHandler(@Nullable WarningHandler warningHandler)
Description copied from interface: `IScriptEvaluator`
By default, warnings are discarded, but an application my install a custom `WarningHandler`.

Specified by:
  `setWarningHandler` in interface `IScriptEvaluator`
Parameters:
  `warningHandler` - `null` to indicate that no warnings be issued

### options

public EnumSet<JaninoOption> options()

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

### options

public ScriptEvaluator options(EnumSet<JaninoOption> options)
Sets the options for all future compilations.

### setScriptCount

public void setScriptCount(int count)

Throws:
  `IllegalArgumentException` - count is different from previous invocations of this method

### setClassName

public void setClassName(String className)

Specified by:
  `setClassName` in interface `IScriptEvaluator`
See Also:
  - `IClassBodyEvaluator.setClassName(String)`

### setImplementedInterfaces

public void setImplementedInterfaces(Class<?>[] implementedTypes)

Specified by:
  `setImplementedInterfaces` in interface `IScriptEvaluator`
See Also:
  - `IClassBodyEvaluator.setImplementedInterfaces(Class[])`

### setExtendedClass

public void setExtendedClass(@Nullable Class<?> extendedType)

Specified by:
  `setExtendedClass` in interface `IScriptEvaluator`
See Also:
  - `IClassBodyEvaluator.setExtendedClass(Class)`

### setDefaultReturnType

public void setDefaultReturnType(Class<?> defaultReturnType)
Description copied from interface: `IScriptEvaluator`
When this `IScriptEvaluator` is coooked, then the defaultReturnType applies to all scripts for which no explicit return type was configured.

The initial default return type (if you want, the "default-default" return type) is `void.class`.

Specified by:
  `setDefaultReturnType` in interface `IScriptEvaluator`
See Also:
  - `IScriptEvaluator.setReturnType(Class)`
  - `IScriptEvaluator.setReturnTypes(Class[])`

### getDefaultReturnType

public Class<?> getDefaultReturnType()

Specified by:
  `getDefaultReturnType` in interface `IScriptEvaluator`
Returns:
  The default return type that was previously configured with `IScriptEvaluator.setDefaultReturnType(Class)`, or `IScriptEvaluator.DEFAULT_RETURN_TYPE`

### setOverrideMethod

public void setOverrideMethod(boolean overrideMethod)
Description copied from interface: `IScriptEvaluator`
Defines whether the generated method overrides a methods declared in a supertype.

Specified by:
  `setOverrideMethod` in interface `IScriptEvaluator`

### setStaticMethod

public void setStaticMethod(boolean staticMethod)
Description copied from interface: `IScriptEvaluator`
Defines whether the generated method should be STATIC or not. Defaults to `true`.

Specified by:
  `setStaticMethod` in interface `IScriptEvaluator`

### setReturnType

public void setReturnType(@Nullable Class<?> returnType)
Description copied from interface: `IScriptEvaluator`
Defines the return type of the generated method. Value `null` means "use the default return type".

Specified by:
  `setReturnType` in interface `IScriptEvaluator`
See Also:
  - `IScriptEvaluator.setDefaultReturnType(Class)`

### setMethodName

public void setMethodName(@Nullable String methodName)
Description copied from interface: `IScriptEvaluator`
Defines the name of the generated method. Initially, the method name is "eval*".

Specified by:
  `setMethodName` in interface `IScriptEvaluator`
Parameters:
  `methodName` - `null` means reset to default name
See Also:
  - `IScriptEvaluator.DEFAULT_METHOD_NAME`

### setParameters

public void setParameters(String[] parameterNames, Class<?>[] parameterTypes)
Description copied from interface: `IScriptEvaluator`
Defines the names and types of the parameters of the generated method.

names`.length` and types`.length` must be equal. This invariant may be checked immediately, or later when the script is cooked.

The parameters can be of primitive type, e.g. `double.class`.

The default is to have zero parameters.

Specified by:
  `setParameters` in interface `IScriptEvaluator`

### setThrownExceptions

public void setThrownExceptions(Class<?>[] thrownExceptions)
Description copied from interface: `IScriptEvaluator`
Defines the exceptions that the generated method may throw.

Specified by:
  `setThrownExceptions` in interface `IScriptEvaluator`

### setOverrideMethod

public void setOverrideMethod(boolean[] overrideMethod)
Description copied from interface: `IScriptEvaluator`
Same as `IScriptEvaluator.setOverrideMethod(boolean)`, but for multiple scripts.

Specified by:
  `setOverrideMethod` in interface `IScriptEvaluator`

### setStaticMethod

public void setStaticMethod(boolean[] staticMethod)
Description copied from interface: `IScriptEvaluator`
Same as `IScriptEvaluator.setStaticMethod(boolean)`, but for multiple scripts.

Specified by:
  `setStaticMethod` in interface `IScriptEvaluator`

### setReturnTypes

public void setReturnTypes(Class<?>[] returnTypes)
Description copied from interface: `IScriptEvaluator`
Configures the return types of the generated methods. If an element of the array is `null`, then use the "default return type" for that script.

Specified by:
  `setReturnTypes` in interface `IScriptEvaluator`
Parameters:
  `returnTypes` - The methods' return types; `null` elements mean "use the default return type"
See Also:
  - `IScriptEvaluator.setDefaultReturnType(Class)`
  - `IScriptEvaluator.getDefaultReturnType()`

### setMethodNames

public void setMethodNames(String[] methodNames)
Description copied from interface: `IScriptEvaluator`
Same as `IScriptEvaluator.setMethodName(String)`, but for multiple scripts.

Define the names of the generated methods. By default the methods have distinct and implementation-specific names.

If two scripts have the same name, then they must have different parameter types (see `IScriptEvaluator.setParameters(String[][], Class[][])`).

Specified by:
  `setMethodNames` in interface `IScriptEvaluator`

### setParameters

public void setParameters(String[][] parameterNames, Class<?>[][] parameterTypes)
Description copied from interface: `IScriptEvaluator`
Same as `IScriptEvaluator.setParameters(String[], Class[])`, but for multiple scripts.

Specified by:
  `setParameters` in interface `IScriptEvaluator`

### setThrownExceptions

public void setThrownExceptions(Class<?>[][] thrownExceptions)
Description copied from interface: `IScriptEvaluator`
Same as `IScriptEvaluator.setThrownExceptions(Class[])`, but for multiple scripts.

Specified by:
  `setThrownExceptions` in interface `IScriptEvaluator`

### cook

public void cook(@Nullable String fileName, Reader reader) throws CompileException, IOException
Description copied from interface: `ICookable`
Reads, scans, parses and compiles Java tokens from the given `Reader`.

Specified by:
  `cook` in interface `ICookable`
Specified by:
  `cook` in class `Cookable`
Parameters:
  `fileName` - Used when reporting errors and warnings
Throws:
  `CompileException`
  `IOException`

### cook

public final void cook(String[] fileNames, Reader[] readers) throws CompileException, IOException
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. The generated class file is 639203 bytes large.

The number and the complexity of the scripts is restricted by the Limitations of the Java Virtual Machine, where the most limiting factor is the 64K entries limit of the constant pool. Since every method with a distinct name requires one entry there, you can define at best 32K (very simple) scripts.

Specified by:
  `cook` in interface `IMultiCookable`
Specified by:
  `cook` in interface `IScriptEvaluator`
Specified by:
  `cook` in class `MultiCookable`
Throws:
  `CompileException`
  `IOException`

### cook

public final void cook(Scanner... scanners) throws CompileException, IOException
Cooks a set of scripts into one class. Notice that if any of the scripts causes trouble, the entire compilation will fail. If you need to report which of the scripts causes the exception, you may want to use the fileName argument of `Scanner(String, Reader)` to distinguish between the individual token sources.

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. The generated class file is 639203 bytes large.

The number and the complexity of the scripts is restricted by the Limitations of the Java Virtual Machine, where the most limiting factor is the 64K entries limit of the constant pool. Since every method with a distinct name requires one entry there, you can define at best 32K (very simple) scripts.

If and only if the number of scanners is one, then that single script may contain leading IMPORT directives.

Throws:
  `IllegalStateException` - Any of the preceding `set...()` had an array size different from that of `scanners`
  `CompileException`
  `IOException`

### cook

public final void cook(Parser[] parsers) throws CompileException, IOException

Throws:
  `CompileException`
  `IOException`
See Also:
  - `cook(Scanner[])`

### cook

public final void cook(Java.CompilationUnit compilationUnit, Collection<Java.MethodDeclarator> methodDeclarators) throws CompileException

Throws:
  `CompileException`

### getResult

public Method[] getResult()

Specified by:
  `getResult` in interface `IScriptEvaluator`
Returns:
  The generated and loaded methods that implement the cooked scripts

### optionalClassToType

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

### classToType

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

### classesToTypes

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

### cook

protected void cook(Java.CompilationUnit compilationUnit) throws CompileException
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 `getMethod(int)`.

Throws:
  `CompileException`

### evaluate

@Nullable public Object evaluate() throws InvocationTargetException
Description copied from interface: `IScriptEvaluator`
Shorthand for `evaluate``(new Object[0])`.

Specified by:
  `evaluate` in interface `IScriptEvaluator`
Throws:
  `InvocationTargetException`

### evaluate

@Nullable public Object evaluate(@Nullable Object[] arguments) throws InvocationTargetException
Description copied from interface: `IScriptEvaluator`
Calls the script with concrete parameter values.

Each argument must have the same type as specified through the `parameterTypes` parameter of `IScriptEvaluator.setParameters(String[], Class[])`.

Arguments of primitive type must passed with their wrapper class objects.

The object returned has the class as specified through `IScriptEvaluator.setReturnType(Class)`.

This method is thread-safe.

Notice: In version 3.1.8, the arguments parameter was changed from `Object[]` to `Object...`, which turned out to be a really bad decision because it caused a very ugly invocation ambiguity with `IScriptEvaluator.evaluate(int, Object[])`. Thus, with version 3.1.10, the parameter was changed back to `Object[]`.

Specified by:
  `evaluate` in interface `IScriptEvaluator`
Parameters:
  `arguments` - The actual parameter values
Throws:
  `InvocationTargetException`

### evaluate

@Nullable public Object evaluate(int idx, @Nullable Object[] arguments) throws InvocationTargetException
Description copied from interface: `IScriptEvaluator`
Same as `IScriptEvaluator.evaluate(Object[])`, but for multiple scripts.

Specified by:
  `evaluate` in interface `IScriptEvaluator`
Throws:
  `InvocationTargetException`

### getMethod

public Method getMethod()

Specified by:
  `getMethod` in interface `IScriptEvaluator`
Returns:
  The generated and loaded `Method`

### getMethod

public Method getMethod(int idx)
Description copied from interface: `IScriptEvaluator`
Same as `IScriptEvaluator.getMethod()`, but for multiple scripts.

Specified by:
  `getMethod` in interface `IScriptEvaluator`

### getClazz

public Class<?> getClazz()

Specified by:
  `getClazz` in interface `IScriptEvaluator`
See Also:
  - `IClassBodyEvaluator.getClazz()`

### getBytecodes

public Map<String,byte[]> getBytecodes()

Specified by:
  `getBytecodes` in interface `ICookable`
Returns:
  The generated Java bytecode; maps class name to bytes

### getReturnType

@Nullable protected final Class<?> getReturnType(int index)

Returns:
  The return type of the indexed script; `null` means "use the `default return type`"

### makeStatements

protected void makeStatements(int idx, Parser parser, List<Java.BlockStatement> resultStatements, List<Java.MethodDeclarator> resultMethods) throws CompileException, IOException
Parses statements from the parser until end-of-input.

Parameters:
  `resultStatements` - Is filled with the generated statements
  `resultMethods` - Is filled with any local methods that the script declares
Throws:
  `CompileException`
  `IOException`

### createFastScriptEvaluator

@Deprecated public static Object createFastScriptEvaluator(String script, Class<?> interfaceToImplement, String[] parameterNames) throws CompileException
Deprecated.
Use `createFastEvaluator(Scanner, Class, String[])` instead

Throws:
  `CompileException`

### createFastScriptEvaluator

@Deprecated public static Object createFastScriptEvaluator(Scanner scanner, Class<?> interfaceToImplement, String[] parameterNames, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException
Deprecated.
Use `createFastEvaluator(Scanner, Class, String[])` instead

Throws:
  `CompileException`
  `IOException`

### createFastScriptEvaluator

@Deprecated public static Object createFastScriptEvaluator(Scanner scanner, String className, @Nullable Class<?> extendedType, Class<?> interfaceToImplement, String[] parameterNames, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException
Deprecated.
Use `createFastEvaluator(Scanner, Class, String[])` instead

Throws:
  `CompileException`
  `IOException`

### createFastScriptEvaluator

@Deprecated public static Object createFastScriptEvaluator(Scanner scanner, String[] defaultImports, String className, @Nullable Class<?> extendedClass, Class<?> interfaceToImplement, String[] parameterNames, @Nullable ClassLoader parentClassLoader) throws CompileException, IOException
Deprecated.
Use `createFastEvaluator(Scanner,Class,String[])` instead:

         ScriptEvaluator se = new ScriptEvaluator();
         se.setDefaultImports.(defaultImports);
         se.setClassName.(className);
         se.setExtendedClass.(extendedClass);
         se.setParentClassLoader(parentClassLoader);
         return se.createFastEvaluator(scanner,
         interfaceToImplement, parameterNames);

Throws:
  `CompileException`
  `IOException`

### setDefaultImports

public void setDefaultImports(String... defaultImports)

Specified by:
  `setDefaultImports` in interface `IScriptEvaluator`
See Also:
  - `IClassBodyEvaluator.setDefaultImports(String...)`

### getDefaultImports

public String[] getDefaultImports()

Specified by:
  `getDefaultImports` in interface `IScriptEvaluator`
See Also:
  - `IClassBodyEvaluator.getDefaultImports()`

### createFastEvaluator

public <T> T createFastEvaluator(Reader reader, Class<T> interfaceToImplement, String[] parameterNames) throws CompileException, IOException
Description copied from interface: `IScriptEvaluator`
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.

Script evaluation is faster than through `IScriptEvaluator.evaluate(Object[])`, because it is not done through reflection but through direct method invocation.

Example:

     public interface Foo {
         int bar(int a, int b);
     }
     ...
     IScriptEvaluator se = CompilerFactoryFactory.getDefaultCompilerFactory().newScriptEvaluator();

     // Optionally configure the SE her:
     se.setClassName("Bar");
     se.setDefaultImports(new String[] { "java.util.*" });
     se.setExtendedClass(SomeOtherClass.class);
     se.setParentClassLoader(someClassLoader);

     Foo f = (Foo) se.createFastScriptEvaluator(
         "return a - b;",
         Foo.class,
         new String[] { "a", "b" }
     );
     System.out.println("1 - 2 = " + f.bar(1, 2));

All other configuration (implemented type, static method, return type, method name, parameter names and types, thrown exceptions) are predetermined by the `interfaceToImplement`.

Notice: The `interfaceToImplement` must either be declared `public`, or with package scope in the same package as the generated class (see `IScriptEvaluator.setClassName(String)`).

s

Specified by:
  `createFastEvaluator` in interface `IScriptEvaluator`
Parameters:
  `reader` - Produces the stream of script tokens
  `interfaceToImplement` - Must declare exactly one method
  `parameterNames` - The names of the parameters of that method
Returns:
  An object that implements the given interface
Throws:
  `CompileException`
  `IOException`

### createFastEvaluator

public <T> T createFastEvaluator(String script, Class<T> interfaceToImplement, String[] parameterNames) throws CompileException

Specified by:
  `createFastEvaluator` in interface `IScriptEvaluator`
Parameters:
  `script` - Contains the sequence of script tokens
Throws:
  `CompileException`
See Also:
  - `IScriptEvaluator.createFastEvaluator(Reader, Class, String[])`

### createFastEvaluator

public <T> T createFastEvaluator(Scanner scanner, Class<?> interfaceToImplement, String[] parameterNames) throws CompileException, IOException
Notice: This method is not declared in `IScriptEvaluator`, and is hence only available in this implementation of `org.codehaus.commons.compiler`. To be independent from this particular implementation, try to switch to `createFastEvaluator(Reader, Class, String[])`.

Parameters:
  `scanner` - Source of tokens to read
Throws:
  `CompileException`
  `IOException`
See Also:
  - `createFastEvaluator(Reader, Class, String[])`

### guessParameterNames

public static String[] guessParameterNames(Scanner scanner) throws CompileException, IOException
Guesses the names of the parameters used in the given expression. The strategy is to look at all "ambiguous names" in the expression (e.g. in "a.b.c.d()", the ambiguous name is "a.b.c"), and then at the components of the ambiguous name.

- If any component starts with an upper-case letter, then ambiguous name is assumed to be a type name.
- Otherwise, if the first component of the ambiguous name matches the name of a previously defined local variable, then the first component of the ambiguous name is assumed to be a local variable name. (Notice that this strategy does not consider that the scope of a local variable declaration may end before the end of the script.)
- Otherwise, the first component of the ambiguous name is assumed to be a parameter name.

Throws:
  `CompileException`
  `IOException`
See Also:
  - `Scanner(String, Reader)`