org.codehaus.janino

Example:

 import java.util.*;
 static private int a = 1;
 private int b = 2;
 public void func(int c, int d) {
 return func2(c, d);
 }
 private static void func2(int e, int f) {
 return e * f;
 }
 

The optionalClassLoader serves two purposes:

• It is used to look for classes referenced by the class body.
• It is used to load the generated Java^TM class into the JVM; directly if it is a subclass of ByteArrayClassLoader , or by creation of a temporary ByteArrayClassLoader if not.

1. Create the ClassBodyEvaluator using ClassBodyEvaluator.ClassBodyEvaluator()
2. Configure the ClassBodyEvaluator by calling any of the following methods:
   • org.codehaus.janino.SimpleCompiler.setParentClassLoader(ClassLoader)
   • ClassBodyEvaluator.setDefaultImports(String[])
3. Call any of the org.codehaus.janino.Cookable.cook(Scanner) methods to scan, parse, compile and load the class body into the JVM.

To compile a class body and immediately instantiate an object, one of the ClassBodyEvaluator.createFastClassBodyEvaluator(Scanner,Class,ClassLoader) methods can be used.

The generated class may optionally extend/implement a given type; the returned instance can safely be type-casted to that optionalBaseType.

Example:

 public interface Foo {
 int bar(int a, int b);
 }
 ...
 Foo f = (Foo) ClassBodyEvaluator.createFastClassBodyEvaluator(
 new Scanner(null, new StringReader("public int bar(int a, int b) { return a + b; }")),
 Foo.class,                  // Base type to extend/implement
 (ClassLoader) null          // Use current thread's context class loader
 );
 System.out.println("1 + 2 = " + f.bar(1, 2));
 

The syntax of the expression to compile is that of a Java^TM expression, as defined in the Java Language Specification, 2nd edition, section 15. Notice that a Java^TM expression does not have a concluding semicolon.

Example:

 a + 7 * b

The expression may optionally be preceeded with a sequence of import directives like

 import java.text.*;
 new DecimalFormat("####,###.##").format(10200020.345345)
 

The expression evaluator is implemented by creating and compiling a temporary compilation unit defining one class with one static method with one return statement.

To set up an ExpressionEvaluator object, proceed as follows:

1. Create the ExpressionEvaluator using ExpressionEvaluator.ExpressionEvaluator()
2. Configure the ExpressionEvaluator by calling any of the following methods:
   • ExpressionEvaluator.setExpressionType(Class)
   • org.codehaus.janino.ScriptEvaluator.setParameters(String[]Class[])
   • org.codehaus.janino.ScriptEvaluator.setThrownExceptions(Class[])
   • org.codehaus.janino.SimpleCompiler.setParentClassLoader(ClassLoader)
   • org.codehaus.janino.ClassBodyEvaluator.setDefaultImports(String[])
3. Call any of the org.codehaus.janino.Cookable.cook(Scanner) methods to scan, parse, compile and load the expression into the JVM.

After the ExpressionEvaluator object is set up, the expression can be evaluated as often with different parameter values (see ExpressionEvaluator.evaluate(Object[]) ).

The syntax of the script to compile is a sequence of import declarations followed by a sequence of statements, as defined in the Java Language Specification, 2nd edition, sections 7.5 and 14.

Example:

 import java.text.*;
 System.out.println("HELLO");
 System.out.println(new DecimalFormat("####,###.##").format(a));
 

The script may complete abnormally, e.g.

Notice that it is possible to formulate invalid escape sequences, e.g. "\u123g" ("g" is not a valid hex character).