org.codehaus.janino

The package comprises a scanner ({@link org.codehaus.janino.Scanner}, a parser ({@link org.codehaus.janino.Parser}) and a class file library. The parser builds a syntax tree from the "Java.*" classes that represents the parsed code. The {@link org.codehaus.janino.UnitCompiler#compileUnit} method compiles this syntax tree into a {@link org.codehaus.janino.util.ClassFile} object, which can write Java^TM bytecode to an "OutputStream".

The application provides access to the resource storeage through a pair of a org.codehaus.janino.util.resource.ResourceFinder and a org.codehaus.janino.util.resource.ResourceCreator (see CachingJavaSourceClassLoader.CachingJavaSourceClassLoader(ClassLoader,ResourceFinder,String,ResourceFinder,ResourceCreator,EnumeratorSet) .

See org.codehaus.janino.JavaSourceClassLoader.main(String[]) for an example how to use this class.

Notice: You must NOT rely on that this class stores some particular data in some particular resources through the given classFileCacheResourceFinder/Creator! These serve only as a means for the CachingJavaSourceClassLoader to persistently cache some data between invocations.

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.

As with any ClassLoader , it is not possible to "update" classes after they've been loaded.

The syntax of the script to compile is a sequence of import declarations (not allowed if you compile many scripts at a time, see below) 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).