rJava

About rJava
GIT access
Download/Files
News
Check results
Package R docs

News/Changelog

NEWS/ChangeLog for rJava
--------------------------

1.0-12  2024-01-26
    o   Win32: minor changes to adapt to (undocumented) API changes in
        R 4.2.0.

    o   Win32: warn if R_HOME path is too long.

    o   dispatch on superclasses when converting native types in
        the reflection API (J/.jrcall). Please note that it is
        safer to use the native API than to rely on reflection
        conversions so packages are encouraged to use the native API
        which is much faster and type-safe. (#317)

    o   remove JavaDoc from the distribution tar ball due to
        security issues (#303). Note that JavaDoc can be generated
        from the source package by running make javadoc in the
        src/java directory.

    o   bugfix: .jarray(..., dispatch=TRUE) was generating nested
        arrays with incorrect content if the input array had more than
        two dimensions. (#5)

    o   the IGNORE env var was misspelled in configure.win. (#304)

1.0-10  2023-11-30
    o   minor documentation fixes

    o   fix format specifier in an error message

1.0-9   2023-11-28
    o   clean up benign C warnings

1.0-8   2022-12-30
    o   attempt to prevent (close to) infinite loop in stack
        detection due to unwanted tail call optimization by
        gcc >= 11 if JDK older than Java 10 is used. (#300)

1.0-7   2022-04-29
    o   fix conversion from native encoding into UTF-16 (introduced
        in 1.0-2) to work correctly if the native encoding is
        neither UTF-8 nor Latin1. (#228)

    o   debugging: if DEBUG_ENCODING C macro is defined string
        conversion routines will output debugging information
        when strings are converted between R and Java.

    o   JRI: console callbacks (Read/WriteConsole) encode and decode
        strings between native encoding and Java. (#24)
        Previously, only UTF-8 native locales were supported.

    o   Replaced deprected constructors like new Double(double) with
        valueOf() calls to make recent JDKs happy.

    o   Work around a crash in RStudio on UCRT Windows. (#296)

    o   add .jvmState() reporting the state of the JVM. (#259)

1.0-6   2021-12-10
    o   remove obsolete autoconf macros

    o   JRI 0.5-7 changes:
        - add support for JRI_CPPFLAGS and JRI_LIBS variables which
          allow specific flag overrides in JRI only
        - use config.h in jri.h (except for Windows)
        - add header checks needed for R_ext/eventloop.h (#284)
        - update automake tools

1.0-5   2021-09-24
    o   allow access modifications to fail on JDK-17

        == Important note to Java developers:
        JDK-17 no longer allows access overrides, so J() wrapper
        will fail for cases where the underlying class does
        not allow public access. This means that it is no longer
        possible to write high-level code that behaves as if it was a
        member of the class. Do not upgrade to JDK-17 if that is
        important in your application or write a Java wrapper that
        exposes the necessary fields/methods as public.

1.0-4   2021-09-03
    o   make jverify() check the object type before checking for
        serialization content. This fixes possible segfaults,
        including one in .jfield() when used on jclassName objects
        where jverify() was used on the wrapping S4 class.

1.0-3   2021-04-16
    o   update URLs referring to Java docs to current 1.8 website

1.0-2   2021-04-15
    o   convert UTF-16 surrogate pairs to UTF-8 when retrieving strings
        from Java to R (#51)

    o   use UTF-16 encoding when converting R strings to Java

    o   avoid warnings in the "blah" R Windows API by casting to
        different types on Windows and unix.

1.0-1   2021-04-12
    o   New feature: support for custom class loaders. It is strongly
        recommended that package authors that use rJava in their
        package use this new feature since it avoids conflicts of
        classes in packages. (#250)

        The main mechanism is the own.loader=TRUE option in
        .jpackage() which instantiates a new, clean class loader for a
        package such that it is not affected by subsequent class path
        changes by the user or other packages. In order to use it, the
        package has to use class.loader=.rJava.class.loader in calls
        to functions that need to load classes such as .jnew() or J().
        This can also be done automatically via something like

        J <- function(...) rJava::J(..., class.loader=.rJava.class.loader)

        in the package without need to change every call to J()
        separately. See the documentation for .jpackage() for details.

    o   J() will automatically call .jinit() if rJava has not been
        initialized yet.

    o   .jchar(x) supports single non-NA string by calling the
        String$toCharArray() method.

    o   raw vectors were not recognised in J() API (#260)

0.9-14  2021-02-04
    o   JRI: fixed detection of the major Java version (#239)

    o   JRI: support Java major versions with suffixes like 13-ea (#236)

    o   JRI: Windows: flags sources as 1.8 to support Java 14 and
        higher where changes in the language break old code (#241)

    o   Fixed compilation of JRI on macOS to not require the JavaVM
        framework, but rely on flags from R CMD javareconf. This avoids
        breakage on macOS 11 which no longer provides JavaVM in the SDK.
        (#248)

0.9-13  2020-07-06
    o   increase default JVM stack size by adding -Xss2m to JVM parameters
        unless -Xss is already specified in .jinit(). This is an
        attempt to address stack overflow problems in Java 11 and higher
        on some platforms which appear to use very small stack
        sizes. (#224)

    o   re-define EXTPTR_xx macros to avoid ABI breakage between R 4.0.0
        and later R 4.0.x versions.

    o   add missing C entry points to the symbol cache. (#221)

    o   disable dynamic symbol lookup to catch any (inadvertent) use of
        unregistered symbols.

0.9-12  2020-03-23
    o   rJava has a new option --enable-dynload which enables rJava to load
        JVM dynamically at run-time. It is only supported on unix platforms
        at this point and is enabled by default on macOS. When enabled,
        rJava library does not link to JVM, but instead assumes that the
        JVM library will be loaded into R before JVM functions are used.

        The default initialization uses the following order to find JVM at
        run-time:
        - use JAVA_HOME (typically set by R CMD javareconf)
        - call /usr/libexec/java_home (if JAVA_HOME is not set)
        Find ${JAVA_HOME}[/jre]/lib/server/libjvm.{so|dylib}
        If not found, Java cannot be loaded.

        On Windows the order has not changed: getOption("java.home"),
        JAVA_HOME environment variable and registry. However, if the
        Java home setting is specified, it must be a valid directory,
        otherwise a warning is issued (#209) and it is assumed to
        be "" and thus the search continues in the registry.

    o   convert class names from Java objects into JNI notation when
        constructing method signatures. (#81)

    o   fix a bug in .jfield() which prevented accessing static fields
        if rJava class loader was not present yet (only affected
        initialization).

    o   modify bootstrap to avoid reflection calls which are broken in
        Java 12 (see #175 and https://bugs.openjdk.java.net/browse/JDK-8221530).

    o   added .jgc() to run JVM garbage collector (#180)

    o   fix filtered .jfields() to return actual values (#213)

    o   .jfields() and .jmethods() now correctly filter results even for
        as.obj=TRUE (#212). Filtering is done by retrieving the names and
        applying the regular expression specified in `name'.

0.9-11  2019-03-27
    o   fix segfault if en exception is thrown during rJava initialization
        (#177)

    o   disable Java stack workaround if loaded from a JVM process (#130)

    o   bump JVM target to 1.8 for JDK 12 and higher since such target is
        no longer supported (#174).

    o   fix HAVE_XRS detection (#168)

    o   Windows: fix build if javah.exe is missing (#157)

    o   Windows: detect JAVA_HOME correctly from registry even if the
        key is using JDK instead Java Development Kit (#120)

    o   Windows: don't fail if RuntimeLib registry entry is missing (#163)

0.9-10  2018-05-29
    o   support builds with JDKs that are missing javah (#141)

    o   detect JDKs that don't call themselves Java (such as openjdk)
        (#146)

    o   macOS: pre-load libjvm.dylib to avoid issues with incorrect ID
        in Oracle's released binaries

0.9-9   2017-10-11
    o   add support for --disable-Xrs configure option in case java -Xrs
        is so broken that it cannot even be tested - reportedly the case
        with Docker (see #63).

    o   add optional class.loader= argument to .jnew() which allows to
        use a custom loader in special cases.

    o   change target to 1.6 and higher since Java 1.9 breaks when asked
        to compile anything older than that. There is no technical reason,
        so you can still build 1.2/1.4 targets by reverting 992828b and
        using a JDK that won't break on 1.4 targets.

    o   Process events on Windows while in rniIndle. (#23)

    o   Work around a bug of Oracle's Java on Linux which caps the stack of
        R at 2M. (#102) The bug leads to segfaults in recursive
        computations (not an R error as R doesn't know the stack size has
        been reduced).  The workaround can be disabled via environment
        variable RJAVA_JVM_STACK_WORKAROUND=0, which may produce better
        results with memory access checkers (ASAN, valgrind), because the
        workaround detects the new stack size by trying to access
        inaccessible memory.  This JVM behavior was a workaround for an
        issue in old Linux systems (JDK-4466587) and is going to be fixed in
        Java 10.

    o   Work around a change in registry location on Windows for Oracle
        Java 1.9. (#120)

0.9-8   2016-01-06
    o   Work around a bug on Oracle's Java on OS X by pre-loading jli

    o   Work around DYLD_FALLBACK_LIBRARY_PATH being dropped in OS X 10.11

0.9-7   2015-07-27
    o   explicitly set -classpath in configure for getps since the user
        may have set CLASSPATH and thus override the default
        (see #3)

    o   when constructing String references from character vectors,
        treat NA as null on the Java side (see #15)

    o   add .jsimplify(..., promote=TRUE) option to promote int
        to double if integer NAs are to be interpreted literally as
        -2147483648 values. (see #39)

    o   fix .jarray(.jshort(...)) to respect the jshort tag (see #40)

0.9-6   2012-12-23
    o   bugfix: the first JVM parameters was shadowed by headless
        mode parameter if enabled (default on OS X).

0.9-5   2012-12-03
    o   add more debugging information in RJavaClassLoader to trace
        cases where class path entries are invalid or discarded

    o   detect support for -Xrs and enable it by default (this prevents
        Java from killing R process on interrupt)

    o   restore locales after Java initialization (some JVMs clobber
        locales with incompatible settings).

    o   add --enable-headless option which sets the java.awt.headless
        to true. In the auto mode this flag is only enabled on Mac OS X.
        Note that it is only set upon initialization, it does not
        affect already running JVMs.

0.9-4   2013-03-11
    o   added support for unboxing of Double[], Integer[] and Boolean[]
        to .jevalArray(.., simplify=TRUE) and thus also to .jcall()

    o   Windows: add Java configuration paths before existing PATH
        entries

    o   Windows: honor a new option "java.home" to override JAVA_HOME
        environment variable and system settings to allow co-existence
        of other tools that may require different Java paths.

    o   Windows: fix a buglet in error reporting when no Java is installed

    o   raise an error if the number of arguments to a Java call exceeds
        maxJavaPars. Previously, calls would be silently truncated.
        Note that maxJavaPars can be raised by compiling rJava, e.g. with:
        PKG_CFLAGS=-DmaxJavaPars=96 R CMD INSTAL rJava_...

0.9-3   2011-12-10
    o   bugfix: .jinit() was failing on Java 1.4 with
        "cannot obtain Class.getSimpleName method ID"
        since the method is only present in Java 1.5+
        This was inadvertent, rJava aims to support Java 1.2+

0.9-2   2011-10-26
    o   When NOAWT is set, rJava will enable headless mode in the JVM
        by setting the java.awt.headless property to true during
        initialization in .jinit()

    o   All C-level entry points are now pre-cached when rJava is
        loaded such that calls can be made much faster since symbols
        don't need to be looked up. This should speed up calls to
        methods that take very little time as well as other parts
        such as checking for exceptions.

0.9-1   2011-06-28
    o   fixed Java detection from registry on Windows (bug introduced
        in 0.9-0)

0.9-0   2011-06-22
    o   fixes issues introduced by several new features in the late
        0.8 series. Most importantly .jarray() and .jevalArray() behave
        as intended (and as implemented in previous versions). The
        same applies to .jcall() behavior with respect to arrays and
        its evalArray argument. The defaults for some new arguments
        have been changed to reflect the original behavior.

    o   .jevalArray() has an additional argument `simplify' which allows
        multi-dimensional arrays to be converted to native R
        types. Use with care - it may convert more recursive types in
        the future so it should be used preferably where you have
        control over the types converted.

    o   fixed a bug in .jevalArray that was not simplifying string
        vectors correctly when the array type was not specified
        (.jclass returns dot notation whereas signatures use JNI
        notation so a conversion was necessary)

    o   use install.libs.R in R 2.13.1 to install multi-arch JRI

0.8-8   2010-12-20
    o   Add support for r.arch in RJavaClassLoader on Windows as well

    o   javaImport was only able to import java packages from the system class
        loader (not from additional jars)

0.8-7   2010-10-18
    o   Windows updates to accommodate changes in R 2.12 and layout
        changes in recent Sun Java installations.

0.8-6   2010-09-17
    o   JRI 0.5-4: rniStop() provides several ways to notify R on unix.
        It improves handing of user interrupts via rniStop() by
        allowing to avoid signals (signals can cause problems in some
        recent JVM implementations).

0.8-5   2010-09-02
    o   fix a bug introduced in 0.8-2 where .jclassPath() would not
        show the real class path

    o   if the rJava class loader is used as a primary loader it will
        also register as the context class loader. Some projects
        rely on the thread context class loader instead of
        Class.getClassLoader() [which is still more reliable]
        so those will now work as well.

    o   JRI 0.5-3 (bugfixes)

0.8-4   2010-04-28
    o   JRI 0.5-2
        IMPORTANT NOTE: handling of NAs in character vectors has been
        fixed, NAs were incorrectly passed as "NA" from R to Java
        instead of nulls (it was correct the other way round). Any
        code that relies on such incorrect behavior will need to be
        fixed!

        Other changes in JRI are mostly related to Windows support
        (bugfixes R 2.11.0 and Windows 64-bit support)

    o   run.bat is now installed as part of JRI

0.8-3   2010-03-16
    o   REngine and JRIEngine classes are now included in rJava/JRI
        although they are not loaded by default.

    o   .r2j now has convert parameter to allow the creation of
        pure references (convert=FALSE)

    o   toJava() is a new function equivalent to .r2j but resulting
        in REngine API references (instances of REXPReference).
        By default the references are not resolved since the primary
        use is to pass R functions to Java for callbacks.

    o   set text mode for stdin on Windows (thanks to Brian Ripley)

    o   fix support of NULL arguments in new(J("SomeClass"), ...)

    o   fixed issues in with() and within() when used on jobjRef;
        also the evaluation environment is now the parent frame as
        expected

    o   disable AWT tests if NOAWT is set; enable a few more tests

0.8-2   2010-01-22
    o   faster class loader implementation

    o   added support for 64-bit Windows (thanks to Brian Ripley)

0.8-1   2009-10-30
    o   fixed exception handling on Windows: the access to "call"
        was off for Windows builds causing incorrect "call" entries
        in exceptions which broke when encountered in try().

    o   fixed .jcall() which had inadvertently the default for
        use.true.class argument set to TRUE. That is considered
        a bug since it breaks the original behavior and is against the
        idea of .jcall being the low-level interface.

0.8-0   2009-10-27
    o   new exception handling was introduced:

        Java exceptions are mapped to Exception conditions which can
        be used to catch the exception at R level using e.g tryCatch.

        The class name automatically contains "Exception", "error"
        and "condition", as well as all the names (without package path)
        of the classes in the inheritance tree of the actual class of the
        Exception. This allows targeted handlers:
        tryCatch(.jnew("foo"), NoClassDefFoundError=function(e) ...)

        In addition JNI code now causes an error instead of a warning,
        however, some errors internal to JNI may not have an associated
        Java exception and thus will fire the usual simpleError
        condition.

        As a consequence of the new error handling exception objects
        are now supplied in e$jobj of the handler and .jgetEx()
        becomes obsolete.

    o   added new high-level API using the "J" function. It replaces
        the previously used .J()/.jrnew() and .jrcall().

        New Java objects are created using new(J("class"), ...) and
        static methods and fields are accessed using J("class")$...
        The corresponding implementation uses reflection in all cases.

        An additional class "jclassName" was created to support static
        calls to accessor methods such as $ and calls to new().

    o   [RF] arrays are now split in two classes : "jrectRef" for rectangular
        arrays, similar to R arrays, and jarrayRef for rugged arrays.
        Indexing of all arrays is supported using the double bracket
        indexer "[[" and "[[<-"

        The single indexer "[" is only currently implemented for
        rectangular arrays. This is experimental. Replacement ([<-)
        is not supported yet.

    o   [RF] with.jclassName and within.jclassName is added to support
        "with" semantics on static fields and methods of java classes.

        Double <- J("java.lang.Double" )
        with( Double, parseDouble( "10.2" ) )

    o   [RF] length.jarrayRef queries the number
        of objects in a java array. An exception is generated if the
        object is not an array. Also array$length can be used
        similarly to array.length in java

    o   [RF] .jcast gains arguments "check" and "convert.array". Their
             default value is FALSE for backwards compatibility with
             previous releases of rJava

    o   [RF] Binary operators <, >, <=, >= to compare two objects where
             at least one is a java object reference.
             d <- new( J("java.lang.Double"), 0.0 )
             d < 1.0
             d < 1L
             Comparison of arrays is not currently supported

    o   [RF] lapply and sapply may now be used on Iterable java objects
             such as Vector and java arrays. see ?as.list.jobjRef

    o   [RF] The generic "clone" function is added, and an implementation for
             java objects. an Object must implement the Cloneable
             interface, otherwise an exception will be raised.
             Furthermore, careful reading of the java documentation
             of Object#clone is recommended since this is not standard
             java behaviour. Currently "clone" is not supported on
             arrays

    o   [RF] A mechanism for "attach"ing java packages has been introduced,
             following the mechanism of the RObjectTables package
             from the OmegaHat project. This allows to "attach" a set of
             java package paths to R's search path:

             > attach( javaImport( "java.util", "java.lang" ) )

             and then use classes from this package like this :

             > new( Vector )
             > new( HashMap )
             > new( Double, 10.2 )
             > new( Integer, 10L )
             > Collections$EMPTY_MAP

             This feature is currently __very__ experimental and is as
             dangerous as any other use of attach

0.7-1   (never released)
    o   [RF] added .J high-level java constructor (based on reflection
        as opposed to complete match as .jnew does)

    o   [RF] added .jinstanceof and instanceof operator

    o   when loaded into another JVM (e.g. via JRI), rJava would crash
        on any call if .jinit() was missing. Now it correctly reports
        the error.

    o   fixed synchronization issues in both JRI and REngine

0.7-0   2009-08-22
    o   fixed bug in $ getter of fields using old .jfield API

    o   fixed a bug in .jevalArray which failed when the signature
        was specified directly (and subsequently .jfield failed in
        most cases)

    o   improve speed of reflection-based API (.jrcall and `$')
        by using native array support in rJava

    o   reflection API now returns NULL invisibly for void results

    o   try to find the best match in reflection-based API
        using internal Java code (code and idea by
        Romain Francois)

    o   added with() method for jobjRef (by Romain Francois), see
        http://romainfrancois.blog.free.fr/index.php?
        post/2009/06/17/with-semantics-for-java-objects-in-rJava

    o   added names() method for jobjRef to facilitate code
        completion (based on code by RF: http://tr.im/w33B)

    o   update to JRI 0.5-0

0.6-3   2009-06-14
    o   update to JRI 0.4-3 (adds REngine API, enhanced support for
        environments and references)

    o   allow signatures longer than 256 bytes

    o   added lib.loc parameter to .jpackage()

0.6-2   2009-01-26
    o   fix --enable-debug to really enable debug code

    o   improve Windows setup (add only paths if they are not already
        listed and check their presence first) and warn if the system
        suffers from PATH truncation bug (or PATH is truncated in
        general)

0.6-1   2008-12-23
    o   substitute $(JAVA_HOME) in configuration flags when necessary

    o   flag generated strings as UTF-8 and convert incoming strings
        into UTF-8 (see note in ?.jcall for details)
        This should improve interoperability in non-UTF-8 locales
        (most prominent example is Windows)

0.6-0   2008-09-22
    o   add support for object cache - see .jcache() - based
        on Java serialization

0.5-2   (never released, turned into 0.6-0)
    o   add direct support for raw vectors as method parameters
        (before .jarray(r) had to be used)

    o   add .jserialize() and .junserialize() functions for
        Java-serialization (do not confuse with R serialization!)

0.5-1   2007-11-05
    o   fix crashes in Windows when Java calls the vfprintf hook

    o   enhance Java environment checks, add more specific errors

    o   add support for r.arch system property which allows multi-arch
        support on platforms that don't have fat binaries (e.g. Linux)

0.5-0   2007-08-22
    o   **API CHANGE**
        The order of arguments of .jfield has been changed to match
        the order used in .jcall and the return value is as expected
        and doesn't need .jsimplify anymore.

    o   The implementation of .jfield no longer uses reflection
        it supports static fields and .jfield<-() was added.

    o   Consolidate interface code for static/non-static calls.
        It is now possible to call a static method using a non-static
        object.

    o   Add .jpackage function for initialization of Java packages.
        See documentation for details, packages should no longer
        use .jinit in their initialization code.

    o   Add preliminary JRI support from R (see .jengine)

    o   Prepare hooks for de-serialization

    o   Add support for short Java type

    o   Add support for converters

    o   Fix R-devel compatibility issues

    o   Fix a memory leak in string array handling

    o   Use Java settings from R for compilation

    o   Add a custom class loader

    o   Fix a bug in .jcastToArray that produced invalid signatures

    o   Added support for [Z in .jevalArray

    o   Fix a bug in .jarray missing [ prefix for native type arrays

0.4-13  2007-01-14
    o   Fix Java-side memory leaks (temporary parameters to methods
        were not properly released, thanks to Erik van Barneveld for
        supplying a reproducible example).

    o   Fix a bug that caused only the first VM parameter to be passed
        on during initialization (thanks to Bernard Rosman for
        reporting).

    o   .jmkref now accepts plain class names (with .)

    o   Fix bug in .jarray (and underlying RcreateArray) that was
        returning wrong class name if the contents class was an array.

    o   Add --enable-callbacks option to configure (disabled by
        default). The callbacks support is currently incomplete and
        experimental.

    o   Update URL to http://www.rforge.net/rJava/

    o   Update to JRI 0.3-7 (LCons, createRJavaRef, assign XT_NONE)

0.4-12  2006-11-29
    o   Added documentation for .jthrow, .jclear and .jgetEx and
        a bugfix in .jgetEx

    o   rJava now uses a namespace. This is still somewhat experimental,
        because rJava needs to perform some dirty tricks to unseal
        the namespace during initialization. Please test and report!

    o   Update to JRI 0.3-6 (GIJ fix and fix for R-devel interface changes)

0.4-11  2006-10-10
    o   Replace variadic macros with wrappers (for compilers that don't
        support ISO C99).

    o   Modify JNI error reporting - use warnings instead of direct stderr.

    o   Update to JRI 0.3-5

0.4-10  2006-09-14
    o   Removed obsolete JNI 1.1 support that is no longer provided
        in JDK 1.6 and thus prevented rJava from being used with JDK 1.6

    o   Update to JRI 0.3-4 (change compilation to force Java 1.4
        compatibility even when more recent JDK is used)

0.4-9   2006-09-12
    o   Update to JRI 0.3-3 which fixes API version mistake which

0.4-8   2006-09-11
    o   Added --enable-jri=auto option which will build JRI only if R
        shared library is present. It is now the default.

    o   Update to JRI 0.3-2 (added boolean support)

0.4-7   2006-09-05
    o   .jevalArray now works with Java objects that have not been
        cast to a Java array explicitly. The function is now also
        documented properly.

    o   Added .jgetEx and .jclear functions for querying and clearing
        of Java exceptions/throwables.

    o   Added .jthrow to allow throwing of exceptions from R code.

    o   Fixed a typo in .jrcall when handling string return values.

0.4-6   2006-08-20
    o   Fixed bug in initialization on Windows, introduced in 0.4-4

0.4-5   2006-06-24
    o   Added support for scalar bytes as .jbyte (byte arrays are still
        natively represented as RAW vectors)

    o   Added .r2j function which allows to push R objects into Java as
        references. This works only if R is run via JRI, because it
        requires a working Rengine instance.

0.4-4   2006-06-21
    o   Fixed bug that prevented loading into existing VM
        if the classpath contained duplicate items.
        .jmergeClassPath now filters out duplicate paths.

    o   .jcall and .jnew discard all named parameters that are passed
        as `...'. Named parameters are now reserved for future call options

    o   Converted all S3-methods into S4 methods.
        Also show' is now used instead of print' and the
        output format was changed.

    o   Prototype for jobjRef is now a valid null-Object

    o   Added .jequals and corresponding ==, != op methods.
        Currently == and != operators feature the same behavior as
        .jequals(...,strict=FALSE), i.e. scalar non-Java objects are
        converted into Java objects if possible and then compared, so
         s <- .jnew("java/lang/String","foo")
         s == "foo"  # returns TRUE

    o   Added .jinherits which allows to check Java-side
        inheritance using JNI (= isAssignableTo).

    o   Added .jfindClass and .jclassRef that return Java
        class object

    o   Added check parameter to .jcall and .jnew that allows the caller
        to prevent implicit call to .jcheck
        It is mainly useful in cases where silent operation
        is desired (e.g. in conjunction with try).
        Additionally, silent parameter was added to .jnew

    o   Added is.jnull which is like is.null but also returns
        TRUE if the supplied Java object is a null-reference

    o   Added jlong class and .jlong function. Those were documented in
        the tutorial but never really implemented. Still, they may not
        be supported in all parts of rJava.
        WARNING: conversion between Java's long and R's jlong is lossy!
        R stores jlong in doubles so the conversion implies loss of
        precision.

0.4-3   2006-05-16
    o   improved, documented and fixed handling of fields
        .jfield is dedicated accessor with more options

0.4-2   2006-05-08
    o   Update to JRI 0.2-5 (no change in rJava)

0.4-1   2006-05-05
    o   Fixed bug in Windows initialization

0.4-0   2006-05-03
    o   JRI is now included in rJava

0.3-9   2006-04-20
     o  fixed a minor bug in Rglue.c that may prevent older
        compilers from compiling it.

0.3-8   2006-04-17
     o  .jinit has an additional parameter `parameters' that allows
        users to pass additional parameters to the VM (such as -X...)

     o  .jinit now uses a hack (defined in .jmergeClassPath) that
        allows us to modify the class path of a running VM. This may
        or may not work for a specific VM, because it is an ugly hack
        exploiting some implementational features of the VM.
        See .jmergeClassPath source for reference and explanation.

     o  .jarray now supports the use of .jarray(x) where x is a Java
        reference. The documentation requires you to use
        .jarray(list(x)), but since the use of .jarray(x) seems to be
        a very common mistake, we may as well silently support it.

     o  .jarray has an optional parameter contents.class which allows
        the global specification of the class type for arrays of
        objects. (Untested, use with care! In most cases .jcast is
        probably what you really want.)

     o  Added some more support for floats, longs and byte arrays.
        (Again, untested)

0.3-7   2006-01-31 (non-public release)
     o  New, experimental feature has been added - JNI cache. This
        feature can be enabled by passing --enable-jni-cache argument
        to configure. Normally, each time we access JVM we retrieve
        new JNI environment to make sure there are no threading
        issues. In single-threaded environment this is superfluous, so
        we may as well cache it. The idea is to reduce the
        overhead. However, the gain is not as huge as expected, so it
        is not enabled by default. Also note that threads and
        jni-cache are mutually exclusive.

     o  Another even more experimental feature has been added -
        support for threads. This feature is enabled by using
        --enable-threads configure argument. When threads support is
        enabled, JVM is started on a thread separate from the main
        thread. Some implementations of AWT classes require
        this. However, it is not always safe to use, because R event
        loop is unaware of the separate thread and can deadlock it.

0.3-6   2006-01-30

0.3-5   2006-01-02

0.3-4   2005-12-28

0.3-3   2005-12-20

0.3     2005-12-19
     o  finalizers, arrays

0.2     2005-09-03
     o  S4 classes

0.1     2003-08-26
     o  initial release