Versions Compared

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.
Section
Column
width49%

Anchor
what
what

What is Janino?

Janino is a super-small, super-fast Java™ compiler. Not only can it compile a set of source files to a set of class files like the JAVAC tool, but also can it compile a Java™ expression, block, class body or source file in memory, load the bytecode and execute it directly in the same JVM. Janino is not intended to be a development tool, but an embedded compiler for run-time compilation purposes, e.g. expression evaluators or "server pages" engines like JSP.

JANINO is integrated with Apache Commons JCI ("Java Compiler Interface") and JBoss Rules / Drools.

JANINO can also be used for static code analysis or code manipulation.

JANINO can be configured to use the javax.tools.JavaCompiler API (available since JDK 1.6), i.e. JAVAC, which removes the Java 5-related limitations.

Anchor
properties
properties

Properties

The major design goal was to keep the compiler small and simple, while providing an (almost) Java 1.4 / 5 compatible compiler. I don't like the idea of carrying around huge libraries for simple applications.

The following elements of the Java programming language are implemented:

  • package declaration, import declaration
  • class declaration, interface declaration
  • Inheritance (extends and implements)
  • Static member type declaration
  • Inner classes (non-static member classes, local classes, anonymous classes) class declaration
  • Class initializer, Instance instance initializer
  • Field declaration, Method method declaration
  • Local variable declaration
  • Class variable initializer, Instance instance variable initializer
  • Block statement ({...})
  • if ... else statement
  • Basic for statement
  • Enhanced for statement
  • while statement
  • do ... while statement
  • try ... catch ... finally statement
  • throw statement
  • return statement
  • break statement
  • continue statement
  • switch statement
  • synchronized statement
  • All primitive types (boolean, char, byte, short, int, long, float, double)
  • Assignment operator =
  • Assignment Compound assignment operators +=, -=, *=, /=, &=, |=, ^=, %=, <<=, >>=, >>>=
  • Conditional operators ?...:, &&, ||
  • Boolean logical operators &, ^, |
  • Integer bitwise operators &, ^, |
  • Numeric operators *, /, %, +, -, <<, >>, >>>
  • String concatenation operator +
  • Operators ++ and --
  • Type comparison operator instanceof
  • Unary operators +, -, ~, !
  • Parenthesized expression
Column
width10px
 
Column
width49%

Properties (cont'd.)

Column
width49%

Properties (cont'd.)

  • Field access (like System.out)
  • Superclass member access (super.meth();, super.field = x;)
Column
width10px
 
  • this (reference to current instance)
  • Alternate constructor invocation (like this(a, b, c);)
  • Superclass constructor invocation (like super(a, b, c);)
  • Method invocation (like System.out.println("Hello"))
  • Class instance creation (like new Foo())
  • Primitive array creation (like new int[10][5][])
  • Class or interface array creation (like new Foo[10][5][])
  • Array access (like args[0])
  • Local variable access
  • Integer, floating-point, boolean, character, string literal
  • null literal
  • Unary numeric conversion, binary numeric conversion, widening numeric conversion, narrowing numeric conversionWidening , widening reference conversion, narrowing reference conversion
  • Cast
  • Assignment conversion
  • String conversion (for string concatenation)
  • Constant expression
  • Block scope, method scope, class scope, global scope
  • throws clause
  • Array initializer (like String[] a = { "x", "y", "z" })
  • Primitive class literals , e.g. "(int.class")
  • Non-primitive class literals , e.g. "(String.class")
  • References between uncompiled compilation units
  • Line number tables a la ("-g:lines")
  • Source file information a la ("-g:source")
  • Local variable information information ("-g:vars")
  • Handling of @deprecated doc comment tag
  • Accessibility checking (PUBLIC, PROTECTED, PRIVATE)
  • Local variable information information for debugging (i.e. "-g:vars")
  • Checking of "definite assignment" (JLS2 JLS7 16)
  • Methods that compile to more than 32 KB
  • assert (partial: assertions are always enabled, as if '-ea' were given)
  • Static imports (single and on-demand; fields, types and methods)
  • Autoboxing and unboxing
  • StringBuilder class used (if available) for string concatenation
  • Covariant return types
  • Annotations (partial: Not yet stored into the CLASS file)
  • @Override
  • Variable arity methods (a.k.a. "varargs")
  • Type arguments (List<String>) are parsed, but otherwise ignored

Anchor
limitations
limitations

Limitations

The following elements of the Java programming language are not implemented:

  • Parametrized Declaration of parametrized types (generics)
  • Enhanced FOR loop
  • type arguments, however, are (partially) implemented, see above)
  • Typesafe enums
  • Variable arguments
  • Annotation declarations (annotation uses, however, are (partially) implemented, see above)