Softpedia >Windows >Programming >Other Programming Files >Janino >  Changelog

Janino Changelog

What's new in Janino 3.1.12

Feb 6, 2024
  • Fixed issue #212 "Assignment conversion not possible from type
  • Fixed issue #209: Use Java's ServiceLoader instead of org.codehaus.commons.compiler.properties
  • Added test case for issue #169 "Problems with varargs and inheritance".
  • Fixed issue #210 "CompilerException with static inner classes".

New in Janino 3.1.11 (Nov 27, 2023)

  • Implemented the Java 15 feature "text blocks".
  • Fixed issue #209 "Use Java's ServiceLoader instead of org.codehaus.commons.compiler.properties".
  • Bug fixed: Unlabeled BREAK did break a labeled statement, which is wrong (it breaks the loop enclosing the labeled statement).
  • Fixed issue #208 "spark compilation failed with ArrayIndexOutOfBoundsException"

New in Janino 3.1.9 (Nov 16, 2022)

  • Merged pr #189 "Implement implicit conversions to Arrays with Annotations".
  • Reproduce issue #188 "Some expressions are failing without explicit cast of null".
  • Fixed issue #187 "Compilation of vars initialized in different if/else branches is failing".
  • Fixed issue #185 "InternalCompilerException while compiling variables initialized in while condition".
  • Added the "-benchmark" command line option.
  • Fixed issue #182 "Incompatible return types, when there are multiple methods with different return type".
  • Eliminated generation of empty StackMapTable attributes.

New in Janino 3.1.8 (Sep 1, 2022)

  • Generation of the StackMapTable is finally correct! However, the default tar version is still 6.
  • Regression tests finally pass for target version 8!
  • Fixed an AccessControlException with JRE 7.
  • Fixed issue #172 "SimpleCompiler Variable Bug", and also for VOID return type. Added test cases for issue 172 "SimpleCompiler Variable Bug".
  • Added more test cases for the "ConstantValue" attribute.
  • Added fix and regression test case for issue #177 "ClassFormatError when assigning integer to constant double". Added test cases.
  • Fixed issue #174: "Byte code is 350 times larger due to StackMapTable, JVM crashes when loading the class". Added test cases.
  • Implementing nested types didn't work (dollar signs in class name).
  • Added code for debugging the loading of .class file and source files.
  • Added fix and regression test case for issue #178 "Janino incorrectly thinks variables are uninitialized". Added regression test cases.
  • Issue #176: "String s = System.out.println();" throws an InternalCompilerException
  • Implemented a system property "org.codehaus.janino.CodeContext.suppressStackMapTable" (boolean).
  • Fixed Issue #168 "commons-compiler-jdk: Unable to load class".
  • Added JDISASM with scope "test" because some test cases now need JDISASM.
  • Fixed GITHUB PR #10: Replace if condition with literal if possible to simplify if statement
  • Allow variable declarators between the LV declaration and the IF statement iff none of the VDs modify the LV.
  • Added "-Xverify:all" to all run configuration to enforce the strictest bytecode verification possible.
  • Test case "JlsTest.test_9_7_1__Normal_Annotations2()" choked because of annotation-type element value (annotation type is described by an UTF8 CPE, not a CLASS CPE).
  • Fixed issue #167 "After a successful compilation, compiling identical (or similar) code fails with an assignment conversion error".
  • Moved the "getArrayIClass(...)" methods from "IClass" to "IClassLoader", and keep the array classes per-class-loader (which is important because arrays refer to java.lang.Object). Also added a test case.
  • Removed JUnit launch configurations for Java 12, 15 and 16, which are no longer supported.

New in Janino 3.1.7 (Apr 19, 2022)

  • Merged PR #148 "Correct the logic to truncate Stack map in CodeContext.restoreLocalVariables".
  • Merged PR #163 "Add SUPER flag for package member types only (#163)".
  • Fixed issue #166 "Get generate method bytecode size".
  • Added a test case for issue #165.
  • Fixed issue #165 "Compilation failure when a class and package name match case insensitively".
  • Replaced "new (Byte|Short|Integer|Long|Float|Double|Character|Boolean)(...)" with "valueOf(...)".
  • Replaced types "Visitor.*Visitor" with "*Visitor".
  • Fixed issue #135 again; this time right.
  • Fixed Issue #155 "Enhanced FOR statement does not work with primitive variable".
  • Verified compatibility with Java 17.
  • Began to extend IClass and ClassFile for generics; specifically added IType and ITypeVariable. However generics are not yet supported; work in progress (although regression tested).
  • Implemented private interface methods (a Java 9 feature).
  • Further simplified the org.codehaus.commons.compiler.jdk.SimpleCompiler: It now uses a delegate o.c.c.c.j.Compiler, which saves a lot of duplicate code.
  • Major refactoring of org.codehaus.commons.compiler.jdk to get rid of duplicate code.
  • Fixed the error handling of the o.c.c.c.jdk.(Compiler|SimpleCompiler); added respective test cases.
  • Marking the SimpleCompiler as "cooked" was not reliable.
  • Static and default interface methods were still declared as "not implemented" on the home page, while they are already implemented! Updated the home page, added some test cases and fixed a minor bug.
  • Added a test for the "diamond operator".
  • Removed all "redundant type arguments", i.e. made use of the "diamond operator". This became possible because support was dropped for Java 6.
  • Also dropped support for "funny" intermediate Java versions 9 and 10.
  • Dropped support for Java 6. Thus, Janino is now compiled against the JRE 7 runtime.

New in Janino 3.1.6 (Jul 28, 2021)

  • Fixed issue #151: Calcite tests fail with compiler error
  • Added a test case that reproduces issue #151.
  • #141 Class loader workaround so that Calcite doesn't need to change. (#150)

New in Janino 3.1.4 (Jan 25, 2021)

  • Issue #136: New BSD License?
  • janino-parent/pom.xml:
  • Changed license name from "New BSD License" to "BSD-3-Clause", because https://maven.apache.org/pom.html#Licenses recommends "... Using an SPDX identifier as the license name...".
  • Changed license URL from "https://raw.githubusercontent.com/janino-compiler/janino/master/LICENSE.txt" to "https://spdx.org.licenses/BSD-3-Clause.html", because the latter is probably the most reliable and stable copy. (We are already using the SPDX identifier, see above, so it appears reasonable to link to the SPDX web site.)
  • Generating MethodInfos: Don't include thrown exceptions that are parameterized, e.g. "void meth() throws EX {...}", because we don't generate "Signature" attributes for methods, and "throws Throwable" would cause compilation problems when the class is loaded later, e.g. by ClassFileIClass.
  • Fixed one StackMap-related NPE.
  • Issue #135: AssertionError for SimpleCompiler.cook when using DeepCopier
  • More StackMap-related fixes.
  • Fixed issue #129: Script evaluating does not work for java 11 when there is annotation processor (#130)
  • Bump junit from 4.12 to 4.13.1 in /janino-parent (#134)
  • Bump ant from 1.7.1 to 1.9.15 in /janino (#132)
  • Integrated Pull request #130: Fixed issue #129: Script evaluating does not work for java 11 when there is annotation processor
  • Janino's default source version is now 11, and the default target version is 6.
  • Fixed issue #131: Janino 3.1.2 is 10x slower than 3.0.11: The Compiler's IClassLoader was initialized way too eagerly, thus lots of classes were loaded from the class path, which is very slow.
  • The default source version was not processed correctly; now it is derived from the system property "java.specification.version" ("Java Runtime Environment specification version").
  • Fixed "org.codehaus.commons.compiler.tests.EvaluatorTest.testAnonymousFieldInitializedByCapture()" test case.
  • Fixed issue #69: Invocation of static interface method.
  • Stack map computation is now complete, but the generated StackMapTable attributes is still buggy. Thus the default target version is still 6, so that the attribute is *not* written. The test case for issue now succeeds, thanks to this new feature.
  • Stack map generation is now working; however the saved StackMapTable attribute is still buggy.
  • Changed the return type of "IScriptEvaluator.createFastEvaluator()" from "Object" to "T". (This does not break binary compatibility, because "T" eventually compiles to "Object".)
  • Issue #124: Janino Sandbox, JVisualVM cannot connect to the application
  • Added "ICookable.setSourceVersion()" and "ICookable.setTargetVersion()" in order to implement JAVAC's "-source" and "-target" command line options.

New in Janino 3.1.2 (Mar 18, 2020)

  • Fixed Issue #119 -- there was an ASSERT statement with a side effect.
  • Merged PR #117 which successfully fixes issue #116.
  • Reproduced issue #116 with new test "JlsTest.test_15_25__Conditional_operator__2()".
  • Upgraded TXT2HTML version from 0.0.1-SNAPSHOT to 1.0.0.
  • Improved the encoding of stack map frames according to JVMS11 4.7.4: Previously, only "full_frame"s were generated.

New in Janino 3.1.1 (Mar 9, 2020)

  • Merged pull request #114 "Grow the code for relocatables, and do fixup, and relocate".
  • FINALLY is no longer implemented with JSR-RET. (Java 6+ .class files forbid JSR and RET). Another step towards Java 7+ .class files!
  • Got rid of "CodeContext.flowAnalysis()" (approx. 500 LOC!), who's sole purpose was to compute the .class files' "maxStack" attribute - we now get that through the computed stack maps.
  • Added support for JDISASM option "printAllOffsets".
  • Enable generation of "StackMapTable" attribute by default.
  • Major rewrite of UnitCompiler and CodeContext to implement the generation of the StackMapTable attribute.
  • Upgraded JANINO JAVADOC from 8 to 11. Beautified the ASCII art in "overview.html".
  • Fixed issue #107: Janino requires "org.codehaus.commons.compiler.io", but commons-compiler does not export this package
  • Yes, that package was missing from the exports list, plus several more.
  • Added the concept of the "LocatableResource" declaring "getResource()", which simplifies the interfacing with "ClassLoader".
  • Minor refactoring: Moved the methods "setParentClassLoader()", "setDebuggingInformation()" and "set(Error|Warning)Handler()" from "ICookable" to "ISimpleCompiler", "IClassBodyEvaluator", "IScriptEvaluator" and "IExpressionEvaluator", where they belong.
  • Throw an NYI CompileException when a static interface method is invoked.
  • Fixed "testIssue69_IncompatibleClassChangeError_when_evaluating_against_janino9plus()".
  • Make DISASSEMBLER options configurable through system properties.
  • When a method was compiled and then stored in a ClassFile, then the "variableArity" flag was lost.
  • Renamed all "@Nullable optionalXyz" variables, fields and parameters to "@Nullable xyz" for consistency.
  • Big rewrite of the ExpressionEvaluator - ScriptEvaluator - ClassBodyEvaluator - SimpleCompiler - Cookable hierarchy:
  • Previously, these classes EXTENDED from left to right, which was always a bit awkward: Actually an ExpressionEvaluator IS NOT a ScriptEvaluator (asf.). To clean up that mess, the classes now DELEGATE instead of EXTENDING: ExpressionEvaluator now HAS a ScriptEvaluator (asf.). This works much better than the old model, and is so much cleaner.
  • Strictly speaking, this is an INCOMPATIBLE CHANGE. However I am very sure that nobody ever (intentionally) RELIES on the old class hierarchy, e.g. assigns an ExpressionEvaluator object to a ScriptEvaluator variable.
  • Also, the "trick" to NOT load the generated classes immediately, but process them differently (the "ExpressionCompiler") now works differently... need to update the documentation to accomodate for this.
  • The concept of the "ExpressionCompiler" was completely refactored: Instead of EXTENDING the "ExpressionEvaluater" in order to keep it from loading the generated bytecode, the ExpressionEvaluator now has a "getBytecodes()" method, and there is no more for an "ExpressionCompiler" class.
  • Bug in "testAnyType()": An ExpressionvEvaluator must be cooked at most ONCE.
  • Fixed the promotion of the array access index expression (see JLS7 15.13 Array Access Expressions).
  • Fixed issue #108: Improve Sandbox
  • Fixed issue #104: ClassLoaderIClassLoader 's ClassNotFoundException handle mechanism enhancement
  • Refactored class "TeeReader" to method "Readers.teeReader()".
  • Path to JAVAC executable is no longer hard-coded in "janino-parent/pom.xml".
  • Added test case for issue #102.
  • Eliminated the mis-named package "org.codehaus.commons.io".
  • Moved the two remaining classes of package "org.codehaus.commons.io" to "org.codehaus.commons.compiler.io" resp. ".util" for consistency.
  • Fixed issue #101: Using ResourceBundles with Java Class in SQL Database
  • Removed the support for "ClassLoader.getResourceAsStream(String)" again - delegation is better than inheritance.
  • Added "setResourceFinder(ResourceFinder)" to support "ClassLoader.getResourceAsStream(String)".
  • Added test cases.
  • Renamed "setEncoding(Charset)" to "setSourceCharset(Charset)", and leave the old method delegating to the new.

New in Janino 3.1.0 (Aug 14, 2019)

  • In this release, many classes were moved from module janino to module commons-compiler, thus their package declarations changed. The "important" APIs, however, remain unchanged. All in all, it was decided to release this as a "minor" release.
  • Moved some test which are implementation-independent from "org.codehaus.janino" to "org.codehaus.commons-tests".
  • Continued work on "jdk.Compiler". Thus moved lots of code from "janino" to "commons-compiler", and also the CompilerTests.
  • Removed the (previously deprecated) "JaninoRuntimeException"; moved the "InternalCompilerException" from "janino" to "commons-compiler".
  • Added a test that illustrates issue #98 "Is there a convenient way to compile multi class form different package?".

New in Janino 3.0.14 (Jul 8, 2019)

  • Issue #95: Conflict in sbt-assembly
  • Issue #93: Overloaded static on-demand imported methods cause a CompileException: Ambiguous static method import
  • Pull request #94: Handle overloaded static on-demand imports
  • Major refactoring of the Java 8 and Java 9 retrofit mechanism.
  • Added tests for "JLS8 8.6 Instance Initializers" and "JLS8 8.7 Static Initializers".
  • Issue #89: Local variables in instance initializers don't work
  • Issue #92: Provide an option to keep generated code files
  • Added compile error handler and warning handler to ICompiler.

New in Janino 3.0.13 (Jun 23, 2019)

  • Added compile error handler and warning handler to ICompiler
  • Added "parsePackageDeclaration()" for better backwards compatibility
  • Static single imports did not work for top-level class declaration annotations
  • Added test cases for the ternary operator
  • Issue #91: Read and modify line number table during compilation
  • Test case that reproduces the "NotNullByDefault.java, Line 49, Column 11: Expression TYPE is not an rvalue" bug
  • Issue #90: "Incompatible expression types" or verification errors when using ternary expressions with null in one branch
  • 88: Support for JDK 9/10 in Full Compiler
  • Issue #86: OSGi Manifest: optional Ant dependencies in OSGi metadata
  • Fixed #85 "Ternary expression resolves to strange supertype"
  • The syntax elements that can have modifiers now all have sets of "is...()" methods that check for each modifier. Some also have methods "getAccess()" and/or "getAnnotations()"
  • Issue #83: Implement "type annotations" (JLS8 9.7.4)
  • Implemented parsing (but not compilation) of "modular compilation units" (JLS11 7.3)
  • Simplified the debug configuration; instead of "-D disasm=true" use "-D UnitCompiler.disassembleClassFilesToStdout=true"
  • Allow space in empty method/constructor body (for "}" alignment)
  • CheckStyle clean-up with cs-contrib 1.2.19: Now not only the "{" of method declarations must be aligned, but also the "}"
  • Added test cases for Java modifiers
  • Replaced all "assert...Uncookable(..., Pattern messageRegex)" and "assert...Uncookable(..., String messageInfix)" method pairs with a single "assert...Uncookable(..., String messageRegex)" method
  • Minor refactoring: Allowed modifiers are now checked in the Parser, not in Java.*. This saves a lot of THROWS clauses
  • Major refactoring: Access modifiers (public, static, ...) and annotations now exist in a proper type hierarchy; the parser no longer uses the (.class file-related) "Mod" class
  • Added "allowMultipleArgsPerLine=true", because that makes sense with VARARGS arguments
  • Issue #78: Parse Type inference syntax: Type inference for generic instance creation implemented, test cases added
  • Issue #77: Parse MethodReference, ClassInstanceCreationReference and ArrayCreationReference

New in Janino 3.0.12 (Jan 18, 2019)

  • Fixed Github issue #73: Operator "&" not defined on types "java.lang.Long" and "int"
  • Fixed Issue #71: How can I move all local variable declarations to field declarations using janino?
  • More test cases for the "?:" operator.
  • Handle the (very special) case "condition ? Long : Integer => long".
  • The ?: operator no longer issues an error when the MHS is not assignable from the RHS and vice versa; instead, the expression type is the "common base type" of the MHS and RHS.
  • Merged pull request #70: Reuse local variable slots among non-overlapping scopes
  • Class literals no longer compile to "class$(String)" (as was necessary for Java <=5), but to the new Java 6 class literals.
  • Major bug in JavaSourceClassLoader: When loading the second and following classes, CUs were compiled again, leading to an inconsistent class hierarchy.
  • Don't generate bridge methods for PRIVATE methods.
  • Fixed issue #68: compilation failure: sensitivity to classpath order and package naming: Java 9 added "@Override public final CharBuffer CharBuffer.rewind() { ..." -- leads easily to a java.lang.NoSuchMethodError: java.nio.CharBuffer.rewind()Ljava/nio/CharBuffer; Cast to "Buffer" is the workaround.
  • Fixed Issue 65: Compilation Error Messages generated by JDK
  • "Scanner.location()" was one token too far. TAB characters were treated as simple characters when column numbers are tracked.
  • Changed all occurences of the words "Java bytecode" to "JVM bytecode" to make clearer that the generated bytecode is for the JVMS and not suitable for, e.g. DALVIK.
  • Added parsing and unparsing of lambdas; COMPILATION still reports "NYI".
  • Added parsing and unparsing of multiple-type catch parameters and type inference for generic instance creation.
  • Fixed Issue #59: Add more accessors to ClassFile

New in Janino 3.0.11 (Nov 13, 2018)

  • Fixed issue #63: Script with many "helper" variables.
  • At last, the "jdk-9" implementation works.
  • Made the code that is required for JDK 9+ (ModuleFinder and consorts) Java-6-compilable through reflection, so that commons-compiler-jdk can still be compiled with Java 6, but functions at runtime also with Java 9+.
  • Fixed Java 9+ compatibility (JRE module system).
  • Fixed issue #65: Compilation Error Messages Generated by JDK.
  • Added experimental support for the "StackMapFrame" attribute; not active yet.
  • Fixed issue #61: Make Unparser more flexible.
  • Fixed NPEs in various "toString()" methods.
  • Fixed issue #62: Optimize static method invocation with rvalue target expression.
  • Merged pull request #60: Added all missing "ClassFile.getConstant*Info()" methods, removing the necessity for many type casts.

New in Janino 3.0.10 (Sep 17, 2018)

  • Fixed issue #58: Integer overflow in ClassFile reader.

New in Janino 3.0.9 (Aug 23, 2018)

  • Implemented the TRY-with-resources statement (including Java 9's "enhanced try-with-resources statement")
  • Removed the (pretty bad) "JGrep" tool here, and re-incarnated it as https://github.com/aunkrig/jgrep/tree/master/jgrep.
  • Renamed class "Traverser" to class "AbstractTraverser", and extracted an interface "Traverser".
  • Merged pull request #31: StackOverflowError when using field annotations with enum members.
  • Implemented "default values" for annotation types' methods
  • Tested JANINO with JREs 9, 10, 11 and 12 (successfully).
  • Parse default methods, and throw an NYI exception when it comes to compilation.
  • Switched to class file version 6.
  • Implemented the "enhanced TRY-with-resources statement" that was introduced with Java 9.
  • Merged pull request #31: StackOverflowError when using field annotations with enum members.
  • Fixed issue #41: Invalid integer literal "9223372036854775808L".
  • Fixed pull request #42: Fix negation of integer literals of the minimal values of int or long.
  • Fixed issue #47: UnitCompiler fails with CompileException when parent interface method is overridden in child interface with subtype return type.
  • Fixed pull request #46: Report compile error when the number of slots required by a method is beyond the Class file limitation (255)"..
  • Merged pull request #54: Add isDefault property for methods; account for default in finding most specific invocable method.
  • Default values for annotation types' methods are now not only parsed, but also compiled.

New in Janino 3.0.8 (Dec 7, 2017)

  • Stack overflow when using new permission system in ClassLoader
  • Added some consistency checks in "IClassLoader.loadIClass()".
  • SIPUSH bytecode is not used for short integer constant #33
  • Renamed the "JaninoRuntimeException" to "InternalCompilerException" (and left the old class for backwards compatibility), because the old name was confusing.
  • The first digit of a three-digit octal escape (e.g. "377") was not correctly decoded.
  • The JUNIT test cases didn't work when executed from MAVEN... had to pre-initialize two JRE classes.
  • Moved the CheckStyle configuration from "de.unkrig.checkstyle" to "janino-parent/checkstyle".
  • Merge pull request #22 from janino-compiler/jdk_16
  • Fixed GITHUB issue #25 "Stack overflow when using new permission system in ClassLoader".

New in Janino 3.0.1 (Sep 6, 2016)

  • Implemented enum declarations.
  • Implemented underscores in integer and floating-point literals.
  • Implemented hexadecimal floating-point literals.
  • Implemented binary integer literals.
  • Merged pull request #3: When adding an entry into constant pool, it's index should be

New in Janino 3.0.0 (Sep 6, 2016)

  • JANINO-186: Code size error message should include method name: Also report when the constant pool size limit is exceeded.
  • JANINO-185: Improve logging: Replaced good ol' "if (DEBUG) System.err.println(...)" with "java.util.logging".
  • "org.codehaus.janino.ScriptEvaluator" now supports the concept of "local methods".
  • Implemented annotations (declarations and uses)
  • Implemented enums (uses only)
  • Added (limited) support for method type parameters.
  • Added support for annotations on package declarations.
  • Added an "architectural overview" in the JAVADOC.

New in Janino 2.7.8 (Jan 31, 2015)

  • JANINO-186 Code size error message should include method name

New in Janino 2.7.7 (Dec 8, 2014)

  • JANINO-182 Reference types "java.lang.Double" and "java.lang.Float" don't match
  • JANINO-184 "Operand stack incosistent..." exception while compiling legal (but dead) code

New in Janino 2.7.6 (Aug 18, 2014)

  • 'IClass.findIMethod(name, parameterTypes)' now ignores synthetic bridge methods by picking the method with the most significant return type.
  • JANINO-180 NullPointerException with JDK8
  • Reclassification of 'empty package types' was forgotten (JLS7: 6.5.2.BL1.B3.1 and .2). This caused 'EvaluatorTests.testWideInstructions()' to fail.
  • JANINO-178 ConcurrentModificationException while compiling anonymous class
  • JANINO-179 ClassCastException: ReflectionIClass
  • JANINO-174 MethodDescriptors should be cached in IMethod.getDescriptor
  • JANINO-172 qualified-name reclassifcations broken
  • JANINO-181 Add OSGi info in manifest.

New in Janino 2.7.5 (Jul 14, 2014)

  • JANINO-173 [janino-user] Dynamically loading from source + AST walk & transforms
  • JANINO-176 push latest version to maven central
  • JANINO-156 Tagged releases should contain parent pom and correct versions
  • Made JANINO available on MAVEN CENTRAL.

New in Janino 2.7.4 (Feb 5, 2014)

  • Simple implementation of type variables.
  • JANINO-170 NullPointerExceptions on Google AppEngine

New in Janino 2.7.3 (Jan 28, 2014)

  • Implemented 'enhanced FOR statement on Iterable' (with type inference).
  • Added parsing of type parameters.

New in Janino 2.7.2 (Jan 14, 2014)

  • JANINO-167 include Mod.is*() convenience methods
  • Allow an 'ArrayType' as a 'TypeArgument'
  • Local variable declaration statement with parameterized type didn't work
  • Added the 'enhanced FOR statement' (except for Iterable, which doesn't make much sense without generics)

New in Janino 2.7.1 (Nov 16, 2013)

  • "Missing @Override" is no longer an error, just a warning
  • ErrorHandler' and 'WarningHandler' moved from JANINO to COMMONS-COMPILER and can now be installed on ICookable - useful for testing
  • JANINO-161 Operand stack underrun
  • Added 'SimpleConstant'
  • JANINO-163 JANINO complains about "unreachable code"
  • JANINO-164 Add VARARGS support
  • Added tons of JAVADOC (thanks CheckStyle)
  • Last CheckStyle clean-up corrections -- all clean now
  • JANINO-165 Please expose Unparser's states to its subclasses

New in Janino 2.7.0 (Aug 12, 2013)

  • Added he 'assert' statement (simplified, ASSERTions are ALWAYS enabled, as if '-ea' were given)
  • Added annotations (but not yet annotation declarations)
  • Implemented '@Override'
  • Dropped support for Java 1.4 and 5

New in Janino 2.6.2 (Jun 25, 2013)

  • JANINO-148 Support Java 6 class file format
  • JANINO-147 JaninoRuntimeException: Cannot "set()" Offset more than once
  • JANINO-149 Janino incorrectly accepts String literals with invalid escape characters
  • JANINO-150 Special-value Float and Double literals don't unparse correctly
  • JANINO-152 Janino does not throw exception when compiling code with exceptions listed in wrong order
  • JANINO-155 Compound assignment does not implement boxing conversion
  • JANINO-157 Fail to "return x": Assignment conversion not possible from type "java.lang.Object" to type "java.lang.Long"
  • JANINO-153 Unable to cast from primitives to classes like Comparable
  • Various enhancements to JDISASM

New in Janino 2.5.16 (Feb 24, 2010)

  • Updated the overview page.

New in Janino 2.5.15 (Jun 19, 2008)

  • Solved:
  • Fully Qualified .class access fails to compile
  • UnparseVisitor does not handle precedence of operators
  • Access to protected members can fail across package boundaries
  • ArithmeticException in UnitCompiler.getConstantValue
  • Methods that compile to more than 32 KB of bytecode cannot be compiled
  • UnparseVisitor does not handle Byte or Short Literals
  • Contant Pool does not support >32K entries
  • flowAnalysis fails with GOTO_W
  • Janino Compiler Needs Optimizing
  • Some performance optimizations

New in Janino 2.5.14 (Apr 29, 2008)

  • Switched from CVS to svn

New in Janino 2.5.13 (Mar 10, 2008)

  • JANINO-106: Static imports of private fields can cause compiler to throw NPE

New in Janino 2.5.12 (Dec 21, 2007)

  • AccessControlException thrown with Janino compiled code under Java Webstart
  • Possible to call a method of an enclosing class as if it was a member of an inner class
  • Feature Request: Obtain parameter information for an evaluated expression

New in Janino 2.5.10 (Sep 5, 2007)

  • Updated the overview page.

New in Janino 2.5.9 (Jul 23, 2007)

  • Resolved the following issues:
  • JANINO-95 ClassBodyEvaluator base class can be abstract and compile fine although it shouldn't compile
  • JANINO-97 ExpressionEvaluator.createFastExpressionEvaluator calls setReturnType

New in Janino 2.5.8 (Jun 28, 2007)

  • JANINO-79 Overridden method resolution thru the inheritance chain is not correct
  • Throw a RuntimeException if cook() is called more than once.

New in Janino 2.5.7 (May 19, 2007)

  • janino.jar is now signed with a dummy certificate.
  • janino.jar is now published as http://www.janino.net/lib/janino.jar, so remote systems can always download the latest version from a fixed URL.
  • Resolved the following issues:
  • JANINO-78 Implement Superclass field access
  • JANINO-81 IncompatibleClassChangeError when invoking getClass() on interface references
  • JANINO-82 Make Compiler.storeClassFile public
  • JANINO-83 Code reuse in PathResourceFinder
  • JANINO-84 Filter out non-existant directories in JarDirectoriesResourceFinder
  • JANINO-85 Build system improvements
  • JANINO-86 Make more classes/constructors public
  • {{JANINO-92:Make {Class,Interface}DeclarationContext public}}

New in Janino 2.5.5 (Feb 5, 2007)

  • Optimized the handling of string concatenation: For sequences of 4 and more operands, the "new StringBuffer(a).append(b).append(c).append(d).toString()" is now used. (For two or three operands, "a.concat(b).concat(c)" is used as before.)
  • Also, if "java.lang.StringBuilder" (the unsynchronized brother of "StringBuffer") is available (since JDK 1.5), it is used.

New in Janino 2.5.4 (Jan 29, 2007)

  • Resolved the following issue: JANINO-75 Duplicate Single-Type-Imports and Single-Static-Imports cause compilation errors

New in Janino 2.4.7 (Sep 12, 2006)

  • Updated the overview page

New in Janino 2.4.5 (Jun 27, 2006)

  • Updated the overview page.

New in Janino 2.4.4 (Jun 19, 2006)

  • Updated the overview page.