[svn-r29226] HDFFV-9552: merge in java code.

11 files changed, 2099 insertions, 22 deletions

diff --git a/config/cmake/CMakeFindJavaCommon.cmake b/config/cmake/CMakeFindJavaCommon.cmake
new file mode 100644
index 0000000..fcf0389
--- /dev/null
+++ b/config/cmake/CMakeFindJavaCommon.cmake
@@ -0,0 +1,41 @@
+
+#=============================================================================
+# Copyright 2013-2014 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Do not include this module directly from code outside CMake!
+set(_JAVA_HOME "")
+if(JAVA_HOME AND IS_DIRECTORY "${JAVA_HOME}")
+  set(_JAVA_HOME "${JAVA_HOME}")
+  set(_JAVA_HOME_EXPLICIT 1)
+else()
+  set(_ENV_JAVA_HOME "")
+  if(DEFINED ENV{JAVA_HOME})
+    file(TO_CMAKE_PATH "$ENV{JAVA_HOME}" _ENV_JAVA_HOME)
+  endif()
+  if(_ENV_JAVA_HOME AND IS_DIRECTORY "${_ENV_JAVA_HOME}")
+    set(_JAVA_HOME "${_ENV_JAVA_HOME}")
+    set(_JAVA_HOME_EXPLICIT 1)
+  else()
+    set(_CMD_JAVA_HOME "")
+    if(APPLE AND EXISTS /usr/libexec/java_home)
+      execute_process(COMMAND /usr/libexec/java_home
+        OUTPUT_VARIABLE _CMD_JAVA_HOME OUTPUT_STRIP_TRAILING_WHITESPACE)
+    endif()
+    if(_CMD_JAVA_HOME AND IS_DIRECTORY "${_CMD_JAVA_HOME}")
+      set(_JAVA_HOME "${_CMD_JAVA_HOME}")
+      set(_JAVA_HOME_EXPLICIT 0)
+    endif()
+    unset(_CMD_JAVA_HOME)
+  endif()
+  unset(_ENV_JAVA_HOME)
+endif()
diff --git a/config/cmake/FindHDFJAVA.cmake.in b/config/cmake/FindHDFJAVA.cmake.in
new file mode 100644
index 0000000..b822280
--- /dev/null
+++ b/config/cmake/FindHDFJAVA.cmake.in
@@ -0,0 +1,68 @@
+#
+# To be used by projects that make use of CMakeified hdf-java
+#
+
+#
+# Find the HDFJAVA includes and get all installed hdf-java library settings from
+# HDFJAVA-config.cmake file : Requires a CMake compatible hdf-java-@HDFJAVA_PACKAGE_VERSION@ or later 
+# for this feature to work. The following vars are set if hdf-java is found.
+#
+# HDFJAVA_FOUND               - True if found, otherwise all other vars are undefined
+# HDFJAVA_VERSION_STRING      - full version (e.g. @HDFJAVA_PACKAGE_VERSION@)
+# HDFJAVA_VERSION_MAJOR       - major part of version (e.g. @HDFJAVA_PACKAGE_VERSION_MAJOR@)
+# HDFJAVA_VERSION_MINOR       - minor part (e.g. @HDFJAVA_PACKAGE_VERSION_MINOR@)
+# 
+# Target names that are valid (depending on enabled options)
+# will be the following
+#
+# 
+# To aid in finding HDFJAVA as part of a subproject set
+# HDFJAVA_ROOT_DIR_HINT to the location where @HDFJAVA_PACKAGE@@HDF_PACKAGE_EXT@-config.cmake lies
+
+INCLUDE (SelectLibraryConfigurations)
+INCLUDE (FindPackageHandleStandardArgs)
+
+# The HINTS option should only be used for values computed from the system.
+set (_HDFJAVA_HINTS
+    $ENV{HOME}/.local
+    $ENV{HDFJAVA_ROOT}
+    $ENV{HDFJAVA_ROOT_DIR_HINT}
+)
+# Hard-coded guesses should still go in PATHS. This ensures that the user
+# environment can always override hard guesses.
+set (_HDFJAVA_PATHS
+    $ENV{HOME}/.local
+    $ENV{HDFJAVA_ROOT}
+    $ENV{HDFJAVA_ROOT_DIR_HINT}
+    /usr/lib/@HDFJAVA_PACKAGE@
+    /usr/share/@HDFJAVA_PACKAGE@
+    /usr/local/@HDFJAVA_PACKAGE@
+    /usr/local/@HDFJAVA_PACKAGE@/share
+)
+
+FIND_PATH (HDFJAVA_ROOT_DIR "@HDFJAVA_PACKAGE@@HDF_PACKAGE_EXT@-config.cmake"
+    HINTS ${_HDFJAVA_HINTS}
+    PATHS ${_HDFJAVA_PATHS}
+    PATH_SUFFIXES
+        cmake/@HDFJAVA_PACKAGE@
+        lib/cmake/@HDFJAVA_PACKAGE@
+        share/cmake/@HDFJAVA_PACKAGE@
+)
+
+FIND_PATH (HDFJAVA_LIBRARY "jarhdf5-@HDFJAVA_PACKAGE_VERSION@.jar"
+    HINTS ${_HDFJAVA_HINTS}
+    PATHS ${_HDFJAVA_PATHS}
+    PATH_SUFFIXES
+        lib
+)
+
+if (HDFJAVA_ROOT_DIR)
+  set (HDFJAVA_FOUND "YES")
+  INCLUDE (${HDFJAVA_ROOT_DIR}/@HDFJAVA_PACKAGE@@HDF_PACKAGE_EXT@-config.cmake)
+  set (HDFJAVA_LIBRARIES "${HDFJAVA_LIBRARY}")
+  set (HDFJAVA_INCLUDE_DIRS 
+        ${HDFJAVA_LIBRARY}/jarhdf-@HDFJAVA_PACKAGE_VERSION@.jar
+        ${HDFJAVA_LIBRARY}/jarhdf5-@HDFJAVA_PACKAGE_VERSION@.jar
+  )
+  
+endif (HDFJAVA_ROOT_DIR)
diff --git a/config/cmake/FindJNI.cmake b/config/cmake/FindJNI.cmake
new file mode 100644
index 0000000..440a9889
--- /dev/null
+++ b/config/cmake/FindJNI.cmake
@@ -0,0 +1,342 @@
+#.rst:
+# FindJNI
+# -------
+#
+# Find JNI java libraries.
+#
+# This module finds if Java is installed and determines where the
+# include files and libraries are.  It also determines what the name of
+# the library is.  The caller may set variable JAVA_HOME to specify a
+# Java installation prefix explicitly.
+#
+# This module sets the following result variables:
+#
+# ::
+#
+#   JNI_INCLUDE_DIRS      = the include dirs to use
+#   JNI_LIBRARIES         = the libraries to use
+#   JNI_FOUND             = TRUE if JNI headers and libraries were found.
+#   JAVA_AWT_LIBRARY      = the path to the jawt library
+#   JAVA_JVM_LIBRARY      = the path to the jvm library
+#   JAVA_INCLUDE_PATH     = the include path to jni.h
+#   JAVA_INCLUDE_PATH2    = the include path to jni_md.h
+#   JAVA_AWT_INCLUDE_PATH = the include path to jawt.h
+
+#=============================================================================
+# Copyright 2001-2009 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Expand {libarch} occurences to java_libarch subdirectory(-ies) and set ${_var}
+macro(java_append_library_directories _var)
+    # Determine java arch-specific library subdir
+    # Mostly based on openjdk/jdk/make/common/shared/Platform.gmk as of openjdk
+    # 1.6.0_18 + icedtea patches. However, it would be much better to base the
+    # guess on the first part of the GNU config.guess platform triplet.
+    if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
+      if(CMAKE_LIBRARY_ARCHITECTURE STREQUAL "x86_64-linux-gnux32")
+        set(_java_libarch "x32" "amd64" "i386")
+      else()
+        set(_java_libarch "amd64" "i386")
+      endif()
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^i.86$")
+        set(_java_libarch "i386")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^alpha")
+        set(_java_libarch "alpha")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm")
+        # Subdir is "arm" for both big-endian (arm) and little-endian (armel).
+        set(_java_libarch "arm")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips")
+        # mips* machines are bi-endian mostly so processor does not tell
+        # endianess of the underlying system.
+        set(_java_libarch "${CMAKE_SYSTEM_PROCESSOR}" "mips" "mipsel" "mipseb" "mips64" "mips64el" "mipsn32" "mipsn32el")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64le")
+        set(_java_libarch "ppc64" "ppc64le")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64")
+        set(_java_libarch "ppc64" "ppc")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)")
+        set(_java_libarch "ppc")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^sparc")
+        # Both flavours can run on the same processor
+        set(_java_libarch "${CMAKE_SYSTEM_PROCESSOR}" "sparc" "sparcv9")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(parisc|hppa)")
+        set(_java_libarch "parisc" "parisc64")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^s390")
+        # s390 binaries can run on s390x machines
+        set(_java_libarch "${CMAKE_SYSTEM_PROCESSOR}" "s390" "s390x")
+    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^sh")
+        set(_java_libarch "sh")
+    else()
+        set(_java_libarch "${CMAKE_SYSTEM_PROCESSOR}")
+    endif()
+
+    # Append default list architectures if CMAKE_SYSTEM_PROCESSOR was empty or
+    # system is non-Linux (where the code above has not been well tested)
+    if(NOT _java_libarch OR NOT (CMAKE_SYSTEM_NAME MATCHES "Linux"))
+        list(APPEND _java_libarch "i386" "amd64" "ppc")
+    endif()
+
+    # Sometimes ${CMAKE_SYSTEM_PROCESSOR} is added to the list to prefer
+    # current value to a hardcoded list. Remove possible duplicates.
+    list(REMOVE_DUPLICATES _java_libarch)
+
+    foreach(_path ${ARGN})
+        if(_path MATCHES "{libarch}")
+            foreach(_libarch ${_java_libarch})
+                string(REPLACE "{libarch}" "${_libarch}" _newpath "${_path}")
+                list(APPEND ${_var} "${_newpath}")
+            endforeach()
+        else()
+            list(APPEND ${_var} "${_path}")
+        endif()
+    endforeach()
+endmacro()
+
+#include(${CMAKE_CURRENT_LIST_DIR}/CMakeFindJavaCommon.cmake)
+INCLUDE (CMakeFindJavaCommon)
+
+# Save CMAKE_FIND_FRAMEWORK
+if(DEFINED CMAKE_FIND_FRAMEWORK)
+  set(_JNI_CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK})
+else()
+  unset(_JNI_CMAKE_FIND_FRAMEWORK)
+endif()
+
+if(_JAVA_HOME_EXPLICIT)
+  set(CMAKE_FIND_FRAMEWORK NEVER)
+endif()
+
+set(JAVA_AWT_LIBRARY_DIRECTORIES)
+if(_JAVA_HOME)
+  JAVA_APPEND_LIBRARY_DIRECTORIES(JAVA_AWT_LIBRARY_DIRECTORIES
+    ${_JAVA_HOME}/jre/lib/{libarch}
+    ${_JAVA_HOME}/jre/lib
+    ${_JAVA_HOME}/lib/{libarch}
+    ${_JAVA_HOME}/lib
+    ${_JAVA_HOME}
+    )
+endif()
+get_filename_component(java_install_version
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit;CurrentVersion]" NAME)
+
+list(APPEND JAVA_AWT_LIBRARY_DIRECTORIES
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.4;JavaHome]/lib"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.3;JavaHome]/lib"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\${java_install_version};JavaHome]/lib"
+  )
+JAVA_APPEND_LIBRARY_DIRECTORIES(JAVA_AWT_LIBRARY_DIRECTORIES
+  /usr/java/lib
+  /usr/java/jre/lib
+  /usr/lib
+  /usr/lib64
+  /usr/local/lib
+  /usr/local/lib64
+  /usr/lib/jvm/java/lib
+  /usr/lib64/jvm/java/lib
+  /usr/lib/java/jre/lib/{libarch}
+  /usr/lib64/java/jre/lib/{libarch}
+  /usr/lib/jvm/jre/lib/{libarch}
+  /usr/lib64/jvm/jre/lib/{libarch}
+  /usr/local/lib/java/jre/lib/{libarch}
+  /usr/local/share/java/jre/lib/{libarch}
+  /usr/lib/j2sdk1.4-sun/jre/lib/{libarch}
+  /usr/lib/j2sdk1.5-sun/jre/lib/{libarch}
+  /opt/sun-jdk-1.5.0.04/jre/lib/{libarch}
+  /usr/lib/jvm/java-6-sun/jre/lib/{libarch}
+  /usr/lib/jvm/java-1.5.0-sun/jre/lib/{libarch}
+  /usr/lib/jvm/java-6-sun-1.6.0.00/jre/lib/{libarch}       # can this one be removed according to #8821 ? Alex
+  /usr/lib/jvm/java-6-openjdk/jre/lib/{libarch}
+  /usr/lib/jvm/java-7-openjdk/jre/lib/{libarch}
+  /usr/lib/jvm/java-7-openjdk-{libarch}/jre/lib/{libarch}
+  /usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0/jre/lib/{libarch}        # fedora
+  # Debian specific paths for default JVM
+  /usr/lib/jvm/default-java/jre/lib/{libarch}
+  /usr/lib/jvm/default-java/jre/lib
+  /usr/lib/jvm/default-java/lib
+  # OpenBSD specific paths for default JVM
+  /usr/local/jdk-1.7.0/jre/lib/{libarch}
+  /usr/local/jre-1.7.0/lib/{libarch}
+  /usr/local/jdk-1.6.0/jre/lib/{libarch}
+  /usr/local/jre-1.6.0/lib/{libarch}
+  # SuSE specific paths for default JVM
+  /usr/lib64/jvm/java/jre/lib/{libarch}
+  /usr/lib64/jvm/jre/lib/{libarch}
+  )
+
+set(JAVA_JVM_LIBRARY_DIRECTORIES)
+foreach(dir ${JAVA_AWT_LIBRARY_DIRECTORIES})
+  list(APPEND JAVA_JVM_LIBRARY_DIRECTORIES
+    "${dir}"
+    "${dir}/client"
+    "${dir}/server"
+    # IBM SDK, Java Technology Edition, specific paths
+    "${dir}/j9vm"
+    "${dir}/default"
+    )
+endforeach()
+
+set(JAVA_AWT_INCLUDE_DIRECTORIES)
+if(_JAVA_HOME)
+  list(APPEND JAVA_AWT_INCLUDE_DIRECTORIES ${_JAVA_HOME}/include)
+endif()
+list(APPEND JAVA_AWT_INCLUDE_DIRECTORIES
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.4;JavaHome]/include"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\1.3;JavaHome]/include"
+  "[HKEY_LOCAL_MACHINE\\SOFTWARE\\JavaSoft\\Java Development Kit\\${java_install_version};JavaHome]/include"
+  ${_JAVA_HOME}/include
+  /usr/include
+  /usr/java/include
+  /usr/local/include
+  /usr/lib/java/include
+  /usr/lib64/java/include
+  /usr/local/lib/java/include
+  /usr/lib/jvm/java/include
+  /usr/lib64/jvm/java/include
+  /usr/lib/jvm/java-6-sun/include
+  /usr/lib/jvm/java-1.5.0-sun/include
+  /usr/lib/jvm/java-6-sun-1.6.0.00/include       # can this one be removed according to #8821 ? Alex
+  /usr/lib/jvm/java-6-openjdk/include
+  /usr/lib/jvm/java-7-openjdk/include
+  /usr/lib/jvm/java-7-openjdk-i386/include
+  /usr/lib/jvm/java-7-openjdk-amd64/include
+  /usr/lib64/jvm/java-7-openjdk/include
+  /usr/lib64/jvm/java-7-openjdk-amd64/include
+  /usr/local/share/java/include
+  /usr/lib/j2sdk1.4-sun/include
+  /usr/lib/j2sdk1.5-sun/include
+  /opt/sun-jdk-1.5.0.04/include
+  # Debian specific path for default JVM
+  /usr/lib/jvm/default-java/include
+  # OpenBSD specific path for default JVM
+  /usr/local/jdk-1.7.0/include
+  /usr/local/jdk-1.6.0/include
+  # SuSE specific paths for default JVM
+  /usr/lib64/jvm/java/include
+  )
+
+foreach(JAVA_PROG "${JAVA_RUNTIME}" "${JAVA_COMPILE}" "${JAVA_ARCHIVE}")
+  get_filename_component(jpath "${JAVA_PROG}" PATH)
+  foreach(JAVA_INC_PATH ../include ../java/include ../share/java/include)
+    if(EXISTS ${jpath}/${JAVA_INC_PATH})
+      list(APPEND JAVA_AWT_INCLUDE_DIRECTORIES "${jpath}/${JAVA_INC_PATH}")
+    endif()
+  endforeach()
+  foreach(JAVA_LIB_PATH
+    ../lib ../jre/lib ../jre/lib/i386
+    ../java/lib ../java/jre/lib ../java/jre/lib/i386
+    ../share/java/lib ../share/java/jre/lib ../share/java/jre/lib/i386)
+    if(EXISTS ${jpath}/${JAVA_LIB_PATH})
+      list(APPEND JAVA_AWT_LIBRARY_DIRECTORIES "${jpath}/${JAVA_LIB_PATH}")
+    endif()
+  endforeach()
+endforeach()
+
+if(APPLE)
+  if(CMAKE_FIND_FRAMEWORK STREQUAL "ONLY")
+    set(_JNI_SEARCHES FRAMEWORK)
+  elseif(CMAKE_FIND_FRAMEWORK STREQUAL "NEVER")
+    set(_JNI_SEARCHES NORMAL)
+  elseif(CMAKE_FIND_FRAMEWORK STREQUAL "LAST")
+    set(_JNI_SEARCHES NORMAL FRAMEWORK)
+  else()
+    set(_JNI_SEARCHES FRAMEWORK NORMAL)
+  endif()
+  set(_JNI_FRAMEWORK_JVM NAMES JavaVM)
+  set(_JNI_FRAMEWORK_JAWT "${_JNI_FRAMEWORK_JVM}")
+else()
+  set(_JNI_SEARCHES NORMAL)
+endif()
+
+set(_JNI_NORMAL_JVM
+  NAMES jvm
+  PATHS ${JAVA_JVM_LIBRARY_DIRECTORIES}
+  )
+
+set(_JNI_NORMAL_JAWT
+  NAMES jawt
+  PATHS ${JAVA_AWT_LIBRARY_DIRECTORIES}
+  )
+
+foreach(search ${_JNI_SEARCHES})
+  find_library(JAVA_JVM_LIBRARY ${_JNI_${search}_JVM})
+  find_library(JAVA_AWT_LIBRARY ${_JNI_${search}_JAWT})
+  if(JAVA_JVM_LIBRARY)
+    break()
+  endif()
+endforeach()
+unset(_JNI_SEARCHES)
+unset(_JNI_FRAMEWORK_JVM)
+unset(_JNI_FRAMEWORK_JAWT)
+unset(_JNI_NORMAL_JVM)
+unset(_JNI_NORMAL_JAWT)
+
+# Find headers matching the library.
+if("${JAVA_JVM_LIBRARY};${JAVA_AWT_LIBRARY};" MATCHES "(/JavaVM.framework|-framework JavaVM);")
+  set(CMAKE_FIND_FRAMEWORK ONLY)
+else()
+  set(CMAKE_FIND_FRAMEWORK NEVER)
+endif()
+
+# add in the include path
+find_path(JAVA_INCLUDE_PATH jni.h
+  ${JAVA_AWT_INCLUDE_DIRECTORIES}
+)
+
+find_path(JAVA_INCLUDE_PATH2 jni_md.h
+  ${JAVA_INCLUDE_PATH}
+  ${JAVA_INCLUDE_PATH}/darwin
+  ${JAVA_INCLUDE_PATH}/win32
+  ${JAVA_INCLUDE_PATH}/linux
+  ${JAVA_INCLUDE_PATH}/freebsd
+  ${JAVA_INCLUDE_PATH}/openbsd
+  ${JAVA_INCLUDE_PATH}/solaris
+  ${JAVA_INCLUDE_PATH}/hp-ux
+  ${JAVA_INCLUDE_PATH}/alpha
+)
+
+find_path(JAVA_AWT_INCLUDE_PATH jawt.h
+  ${JAVA_INCLUDE_PATH}
+)
+
+# Restore CMAKE_FIND_FRAMEWORK
+if(DEFINED _JNI_CMAKE_FIND_FRAMEWORK)
+  set(CMAKE_FIND_FRAMEWORK ${_JNI_CMAKE_FIND_FRAMEWORK})
+  unset(_JNI_CMAKE_FIND_FRAMEWORK)
+else()
+  unset(CMAKE_FIND_FRAMEWORK)
+endif()
+
+#include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
+INCLUDE (FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(JNI  DEFAULT_MSG  JAVA_AWT_LIBRARY JAVA_JVM_LIBRARY
+                                                    JAVA_INCLUDE_PATH  JAVA_INCLUDE_PATH2 JAVA_AWT_INCLUDE_PATH)
+
+mark_as_advanced(
+  JAVA_AWT_LIBRARY
+  JAVA_JVM_LIBRARY
+  JAVA_AWT_INCLUDE_PATH
+  JAVA_INCLUDE_PATH
+  JAVA_INCLUDE_PATH2
+)
+
+set(JNI_LIBRARIES
+  ${JAVA_AWT_LIBRARY}
+  ${JAVA_JVM_LIBRARY}
+)
+
+set(JNI_INCLUDE_DIRS
+  ${JAVA_INCLUDE_PATH}
+  ${JAVA_INCLUDE_PATH2}
+  ${JAVA_AWT_INCLUDE_PATH}
+)
+
+message ("JNI_LIBRARIES=${JNI_LIBRARIES}")
+message ("JNI_INCLUDE_DIRS=${JNI_INCLUDE_DIRS}")
diff --git a/config/cmake/README.txt.cmake.in b/config/cmake/README.txt.cmake.in
index ec40abe..4c4ffd5 100644
--- a/config/cmake/README.txt.cmake.in
+++ b/config/cmake/README.txt.cmake.in
@@ -9,6 +9,7 @@ It was built with the following options:
     -- @LIB_TYPE@ C/C++/Fortran libraries
     -- SZIP (encoder enabled) and ZLIB
     -- @LIB_TYPE@ HDF5 tools
+    -- Java
 
 The contents of this directory are:
 
diff --git a/config/cmake/UseJava.cmake b/config/cmake/UseJava.cmake
new file mode 100644
index 0000000..d694517
--- /dev/null
+++ b/config/cmake/UseJava.cmake
@@ -0,0 +1,1290 @@
+#.rst:
+# UseJava
+# -------
+#
+# Use Module for Java
+#
+# This file provides functions for Java.  It is assumed that
+# FindJava.cmake has already been loaded.  See FindJava.cmake for
+# information on how to load Java into your CMake project.
+#
+# ::
+#
+#  add_jar(target_name
+#          [SOURCES] source1 [source2 ...] [resource1 ...]
+#          [INCLUDE_JARS jar1 [jar2 ...]]
+#          [ENTRY_POINT entry]
+#          [VERSION version]
+#          [OUTPUT_NAME name]
+#          [OUTPUT_DIR dir]
+#          )
+#
+# This command creates a <target_name>.jar.  It compiles the given
+# source files (source) and adds the given resource files (resource) to
+# the jar file.  Source files can be java files or listing files
+# (prefixed by '@').  If only resource files are given then just a jar file
+# is created.  The list of include jars are added to the classpath when
+# compiling the java sources and also to the dependencies of the target.
+# INCLUDE_JARS also accepts other target names created by add_jar.  For
+# backwards compatibility, jar files listed as sources are ignored (as
+# they have been since the first version of this module).
+#
+# The default OUTPUT_DIR can also be changed by setting the variable
+# CMAKE_JAVA_TARGET_OUTPUT_DIR.
+#
+# Additional instructions:
+#
+# ::
+#
+#    To add compile flags to the target you can set these flags with
+#    the following variable:
+#
+#
+#
+# ::
+#
+#        set(CMAKE_JAVA_COMPILE_FLAGS -nowarn)
+#
+#
+#
+# ::
+#
+#    To add a path or a jar file to the class path you can do this
+#    with the CMAKE_JAVA_INCLUDE_PATH variable.
+#
+#
+#
+# ::
+#
+#        set(CMAKE_JAVA_INCLUDE_PATH /usr/share/java/shibboleet.jar)
+#
+#
+#
+# ::
+#
+#    To use a different output name for the target you can set it with:
+#
+#
+#
+# ::
+#
+#        add_jar(foobar foobar.java OUTPUT_NAME shibboleet.jar)
+#
+#
+#
+# ::
+#
+#    To use a different output directory than CMAKE_CURRENT_BINARY_DIR
+#    you can set it with:
+#
+#
+#
+# ::
+#
+#        add_jar(foobar foobar.java OUTPUT_DIR ${PROJECT_BINARY_DIR}/bin)
+#
+#
+#
+# ::
+#
+#    To define an entry point in your jar you can set it with the ENTRY_POINT
+#    named argument:
+#
+#
+#
+# ::
+#
+#        add_jar(example ENTRY_POINT com/examples/MyProject/Main)
+#
+#
+#
+# ::
+#
+#    To define a custom manifest for the jar, you can set it with the manifest
+#    named argument:
+#
+#
+#
+# ::
+#
+#        add_jar(example MANIFEST /path/to/manifest)
+#
+#
+#
+# ::
+#
+#    To add a VERSION to the target output name you can set it using
+#    the VERSION named argument to add_jar. This will create a jar file with the
+#    name shibboleet-1.0.0.jar and will create a symlink shibboleet.jar
+#    pointing to the jar with the version information.
+#
+#
+#
+# ::
+#
+#        add_jar(shibboleet shibbotleet.java VERSION 1.2.0)
+#
+#
+#
+# ::
+#
+#     If the target is a JNI library, utilize the following commands to
+#     create a JNI symbolic link:
+#
+#
+#
+# ::
+#
+#        set(CMAKE_JNI_TARGET TRUE)
+#        add_jar(shibboleet shibbotleet.java VERSION 1.2.0)
+#        install_jar(shibboleet ${LIB_INSTALL_DIR}/shibboleet)
+#        install_jni_symlink(shibboleet ${JAVA_LIB_INSTALL_DIR})
+#
+#
+#
+# ::
+#
+#     If a single target needs to produce more than one jar from its
+#     java source code, to prevent the accumulation of duplicate class
+#     files in subsequent jars, set/reset CMAKE_JAR_CLASSES_PREFIX prior
+#     to calling the add_jar() function:
+#
+#
+#
+# ::
+#
+#        set(CMAKE_JAR_CLASSES_PREFIX com/redhat/foo)
+#        add_jar(foo foo.java)
+#
+#
+#
+# ::
+#
+#        set(CMAKE_JAR_CLASSES_PREFIX com/redhat/bar)
+#        add_jar(bar bar.java)
+#
+#
+#
+# Target Properties:
+#
+# ::
+#
+#    The add_jar() functions sets some target properties. You can get these
+#    properties with the
+#       get_property(TARGET <target_name> PROPERTY <propery_name>)
+#    command.
+#
+#
+#
+# ::
+#
+#    INSTALL_FILES      The files which should be installed. This is used by
+#                       install_jar().
+#    JNI_SYMLINK        The JNI symlink which should be installed.
+#                       This is used by install_jni_symlink().
+#    JAR_FILE           The location of the jar file so that you can include
+#                       it.
+#    CLASS_DIR          The directory where the class files can be found. For
+#                       example to use them with javah.
+#
+# ::
+#
+#  find_jar(<VAR>
+#           name | NAMES name1 [name2 ...]
+#           [PATHS path1 [path2 ... ENV var]]
+#           [VERSIONS version1 [version2]]
+#           [DOC "cache documentation string"]
+#           )
+#
+# This command is used to find a full path to the named jar.  A cache
+# entry named by <VAR> is created to stor the result of this command.
+# If the full path to a jar is found the result is stored in the
+# variable and the search will not repeated unless the variable is
+# cleared.  If nothing is found, the result will be <VAR>-NOTFOUND, and
+# the search will be attempted again next time find_jar is invoked with
+# the same variable.  The name of the full path to a file that is
+# searched for is specified by the names listed after NAMES argument.
+# Additional search locations can be specified after the PATHS argument.
+# If you require special a version of a jar file you can specify it with
+# the VERSIONS argument.  The argument after DOC will be used for the
+# documentation string in the cache.
+#
+# ::
+#
+#  install_jar(target_name destination)
+#  install_jar(target_name DESTINATION destination [COMPONENT component])
+#
+# This command installs the TARGET_NAME files to the given DESTINATION.
+# It should be called in the same scope as add_jar() or it will fail.
+#
+# ::
+#
+#  install_jni_symlink(target_name destination)
+#  install_jni_symlink(target_name DESTINATION destination [COMPONENT component])
+#
+# This command installs the TARGET_NAME JNI symlinks to the given
+# DESTINATION.  It should be called in the same scope as add_jar() or it
+# will fail.
+#
+# ::
+#
+#  create_javadoc(<VAR>
+#                 PACKAGES pkg1 [pkg2 ...]
+#                 [SOURCEPATH <sourcepath>]
+#                 [CLASSPATH <classpath>]
+#                 [INSTALLPATH <install path>]
+#                 [DOCTITLE "the documentation title"]
+#                 [WINDOWTITLE "the title of the document"]
+#                 [AUTHOR TRUE|FALSE]
+#                 [USE TRUE|FALSE]
+#                 [VERSION TRUE|FALSE]
+#                 )
+#
+# Create java documentation based on files or packages.  For more
+# details please read the javadoc manpage.
+#
+# There are two main signatures for create_javadoc.  The first signature
+# works with package names on a path with source files:
+#
+# ::
+#
+#    Example:
+#    create_javadoc(my_example_doc
+#      PACKAGES com.exmaple.foo com.example.bar
+#      SOURCEPATH "${CMAKE_CURRENT_SOURCE_DIR}"
+#      CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
+#      WINDOWTITLE "My example"
+#      DOCTITLE "<h1>My example</h1>"
+#      AUTHOR TRUE
+#      USE TRUE
+#      VERSION TRUE
+#    )
+#
+#
+#
+# The second signature for create_javadoc works on a given list of
+# files.
+#
+# ::
+#
+#    create_javadoc(<VAR>
+#                   FILES file1 [file2 ...]
+#                   [CLASSPATH <classpath>]
+#                   [INSTALLPATH <install path>]
+#                   [DOCTITLE "the documentation title"]
+#                   [WINDOWTITLE "the title of the document"]
+#                   [AUTHOR TRUE|FALSE]
+#                   [USE TRUE|FALSE]
+#                   [VERSION TRUE|FALSE]
+#                  )
+#
+#
+#
+# Example:
+#
+# ::
+#
+#    create_javadoc(my_example_doc
+#      FILES ${example_SRCS}
+#      CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
+#      WINDOWTITLE "My example"
+#      DOCTITLE "<h1>My example</h1>"
+#      AUTHOR TRUE
+#      USE TRUE
+#      VERSION TRUE
+#    )
+#
+#
+#
+# Both signatures share most of the options.  These options are the same
+# as what you can find in the javadoc manpage.  Please look at the
+# manpage for CLASSPATH, DOCTITLE, WINDOWTITLE, AUTHOR, USE and VERSION.
+#
+# The documentation will be by default installed to
+#
+# ::
+#
+#    ${CMAKE_INSTALL_PREFIX}/share/javadoc/<VAR>
+#
+#
+#
+# if you don't set the INSTALLPATH.
+#
+# ::
+#
+#  create_javah(TARGET <target>
+#               GENERATED_FILES <VAR>
+#               CLASSES <class>...
+#               [CLASSPATH <classpath>...]
+#               [DEPENDS <depend>...]
+#               [OUTPUT_NAME <path>|OUTPUT_DIR <path>]
+#               )
+#
+# Create C header files from java classes. These files provide the connective glue
+# that allow your Java and C code to interact.
+#
+# There are two main signatures for create_javah.  The first signature
+# returns generated files throught variable specified by GENERATED_FILES option:
+#
+# ::
+#
+#    Example:
+#    Create_javah(GENERATED_FILES files_headers
+#      CLASSES org.cmake.HelloWorld
+#      CLASSPATH hello.jar
+#    )
+#
+#
+#
+# The second signature for create_javah creates a target which encapsulates
+# header files generation.
+#
+# ::
+#
+#    Example:
+#    Create_javah(TARGET target_headers
+#      CLASSES org.cmake.HelloWorld
+#      CLASSPATH hello.jar
+#    )
+#
+#
+#
+# Both signatures share same options.
+#
+#  ``CLASSES <class>...``
+#    Specifies Java classes used to generate headers.
+#
+#  ``CLASSPATH <classpath>...``
+#    Specifies various paths to look up classes. Here .class files, jar files or targets
+#    created by command add_jar can be used.
+#
+#  ``DEPENDS <depend>...``
+#    Targets on which the javah target depends
+#
+#  ``OUTPUT_NAME <path>``
+#    Concatenates the resulting header files for all the classes listed by option CLASSES
+#    into <path>. Same behavior as option '-o' of javah tool.
+#
+#  ``OUTPUT_DIR <path>``
+#    Sets the directory where the header files will be generated. Same behavior as option
+#    '-d' of javah tool. If not specified, ${CMAKE_CURRENT_BINARY_DIR} is used as output directory.
+
+#=============================================================================
+# Copyright 2013 OpenGamma Ltd. <graham@opengamma.com>
+# Copyright 2010-2011 Andreas schneider <asn@redhat.com>
+# Copyright 2010-2013 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+include(CMakeParseArguments)
+
+function (__java_copy_file src dest comment)
+    add_custom_command(
+        OUTPUT  ${dest}
+        COMMAND cmake -E copy_if_different
+        ARGS    ${src}
+                ${dest}
+        DEPENDS ${src}
+        COMMENT ${comment})
+endfunction ()
+
+# define helper scripts
+set(_JAVA_CLASS_FILELIST_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJavaClassFilelist.cmake)
+set(_JAVA_SYMLINK_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJavaSymlinks.cmake)
+
+function(add_jar _TARGET_NAME)
+
+    cmake_parse_arguments(_add_jar
+      ""
+      "VERSION;OUTPUT_DIR;OUTPUT_NAME;ENTRY_POINT;MANIFEST"
+      "SOURCES;INCLUDE_JARS"
+      ${ARGN}
+    )
+
+    # In CMake < 2.8.12, add_jar used variables which were set prior to calling
+    # add_jar for customizing the behavior of add_jar. In order to be backwards
+    # compatible, check if any of those variables are set, and use them to
+    # initialize values of the named arguments. (Giving the corresponding named
+    # argument will override the value set here.)
+    #
+    # New features should use named arguments only.
+    if(NOT DEFINED _add_jar_VERSION AND DEFINED CMAKE_JAVA_TARGET_VERSION)
+        set(_add_jar_VERSION "${CMAKE_JAVA_TARGET_VERSION}")
+    endif()
+    if(NOT DEFINED _add_jar_OUTPUT_DIR AND DEFINED CMAKE_JAVA_TARGET_OUTPUT_DIR)
+        set(_add_jar_OUTPUT_DIR "${CMAKE_JAVA_TARGET_OUTPUT_DIR}")
+    endif()
+    if(NOT DEFINED _add_jar_OUTPUT_NAME AND DEFINED CMAKE_JAVA_TARGET_OUTPUT_NAME)
+        set(_add_jar_OUTPUT_NAME "${CMAKE_JAVA_TARGET_OUTPUT_NAME}")
+        # reset
+        set(CMAKE_JAVA_TARGET_OUTPUT_NAME)
+    endif()
+    if(NOT DEFINED _add_jar_ENTRY_POINT AND DEFINED CMAKE_JAVA_JAR_ENTRY_POINT)
+        set(_add_jar_ENTRY_POINT "${CMAKE_JAVA_JAR_ENTRY_POINT}")
+    endif()
+
+    set(_JAVA_SOURCE_FILES ${_add_jar_SOURCES} ${_add_jar_UNPARSED_ARGUMENTS})
+
+    if (NOT DEFINED _add_jar_OUTPUT_DIR)
+        set(_add_jar_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
+
+    if (_add_jar_ENTRY_POINT)
+        set(_ENTRY_POINT_OPTION e)
+        set(_ENTRY_POINT_VALUE ${_add_jar_ENTRY_POINT})
+    endif ()
+
+    if (_add_jar_MANIFEST)
+        set(_MANIFEST_OPTION m)
+        set(_MANIFEST_VALUE ${_add_jar_MANIFEST})
+    endif ()
+
+    if (LIBRARY_OUTPUT_PATH)
+        set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_PATH})
+    else ()
+        set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${_add_jar_OUTPUT_DIR})
+    endif ()
+
+    set(CMAKE_JAVA_INCLUDE_PATH
+        ${CMAKE_JAVA_INCLUDE_PATH}
+        ${CMAKE_CURRENT_SOURCE_DIR}
+        ${CMAKE_JAVA_OBJECT_OUTPUT_PATH}
+        ${CMAKE_JAVA_LIBRARY_OUTPUT_PATH}
+    )
+
+    if (CMAKE_HOST_WIN32 AND NOT CYGWIN AND CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
+        set(CMAKE_JAVA_INCLUDE_FLAG_SEP ";")
+    else ()
+        set(CMAKE_JAVA_INCLUDE_FLAG_SEP ":")
+    endif()
+
+    foreach (JAVA_INCLUDE_DIR ${CMAKE_JAVA_INCLUDE_PATH})
+       set(CMAKE_JAVA_INCLUDE_PATH_FINAL "${CMAKE_JAVA_INCLUDE_PATH_FINAL}${CMAKE_JAVA_INCLUDE_FLAG_SEP}${JAVA_INCLUDE_DIR}")
+    endforeach()
+
+    set(CMAKE_JAVA_CLASS_OUTPUT_PATH "${_add_jar_OUTPUT_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir")
+
+    set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}.jar")
+    if (_add_jar_OUTPUT_NAME AND _add_jar_VERSION)
+        set(_JAVA_TARGET_OUTPUT_NAME "${_add_jar_OUTPUT_NAME}-${_add_jar_VERSION}.jar")
+        set(_JAVA_TARGET_OUTPUT_LINK "${_add_jar_OUTPUT_NAME}.jar")
+    elseif (_add_jar_VERSION)
+        set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}-${_add_jar_VERSION}.jar")
+        set(_JAVA_TARGET_OUTPUT_LINK "${_TARGET_NAME}.jar")
+    elseif (_add_jar_OUTPUT_NAME)
+        set(_JAVA_TARGET_OUTPUT_NAME "${_add_jar_OUTPUT_NAME}.jar")
+    endif ()
+
+    set(_JAVA_CLASS_FILES)
+    set(_JAVA_COMPILE_FILES)
+    set(_JAVA_COMPILE_FILELISTS)
+    set(_JAVA_DEPENDS)
+    set(_JAVA_COMPILE_DEPENDS)
+    set(_JAVA_RESOURCE_FILES)
+    set(_JAVA_RESOURCE_FILES_RELATIVE)
+    foreach(_JAVA_SOURCE_FILE ${_JAVA_SOURCE_FILES})
+        get_filename_component(_JAVA_EXT ${_JAVA_SOURCE_FILE} EXT)
+        get_filename_component(_JAVA_FILE ${_JAVA_SOURCE_FILE} NAME_WE)
+        get_filename_component(_JAVA_PATH ${_JAVA_SOURCE_FILE} PATH)
+        get_filename_component(_JAVA_FULL ${_JAVA_SOURCE_FILE} ABSOLUTE)
+
+        if (_JAVA_SOURCE_FILE MATCHES "^@(.+)$")
+            get_filename_component(_JAVA_FULL ${CMAKE_MATCH_1} ABSOLUTE)
+            list(APPEND _JAVA_COMPILE_FILELISTS ${_JAVA_FULL})
+
+        elseif (_JAVA_EXT MATCHES ".java")
+            file(RELATIVE_PATH _JAVA_REL_BINARY_PATH ${_add_jar_OUTPUT_DIR} ${_JAVA_FULL})
+            file(RELATIVE_PATH _JAVA_REL_SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${_JAVA_FULL})
+            string(LENGTH ${_JAVA_REL_BINARY_PATH} _BIN_LEN)
+            string(LENGTH ${_JAVA_REL_SOURCE_PATH} _SRC_LEN)
+            if (${_BIN_LEN} LESS ${_SRC_LEN})
+                set(_JAVA_REL_PATH ${_JAVA_REL_BINARY_PATH})
+            else ()
+                set(_JAVA_REL_PATH ${_JAVA_REL_SOURCE_PATH})
+            endif ()
+            get_filename_component(_JAVA_REL_PATH ${_JAVA_REL_PATH} PATH)
+
+            list(APPEND _JAVA_COMPILE_FILES ${_JAVA_SOURCE_FILE})
+            set(_JAVA_CLASS_FILE "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_REL_PATH}/${_JAVA_FILE}.class")
+            set(_JAVA_CLASS_FILES ${_JAVA_CLASS_FILES} ${_JAVA_CLASS_FILE})
+
+        elseif (_JAVA_EXT MATCHES ".jar"
+                OR _JAVA_EXT MATCHES ".war"
+                OR _JAVA_EXT MATCHES ".ear"
+                OR _JAVA_EXT MATCHES ".sar")
+            # Ignored for backward compatibility
+
+        elseif (_JAVA_EXT STREQUAL "")
+            list(APPEND CMAKE_JAVA_INCLUDE_PATH ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}} ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}_CLASSPATH})
+            list(APPEND _JAVA_DEPENDS ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}})
+
+        else ()
+            __java_copy_file(${CMAKE_CURRENT_SOURCE_DIR}/${_JAVA_SOURCE_FILE}
+                             ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_SOURCE_FILE}
+                             "Copying ${_JAVA_SOURCE_FILE} to the build directory")
+            list(APPEND _JAVA_RESOURCE_FILES ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_SOURCE_FILE})
+            list(APPEND _JAVA_RESOURCE_FILES_RELATIVE ${_JAVA_SOURCE_FILE})
+        endif ()
+    endforeach()
+
+    foreach(_JAVA_INCLUDE_JAR ${_add_jar_INCLUDE_JARS})
+        if (TARGET ${_JAVA_INCLUDE_JAR})
+            get_target_property(_JAVA_JAR_PATH ${_JAVA_INCLUDE_JAR} JAR_FILE)
+            if (_JAVA_JAR_PATH)
+                set(CMAKE_JAVA_INCLUDE_PATH_FINAL "${CMAKE_JAVA_INCLUDE_PATH_FINAL}${CMAKE_JAVA_INCLUDE_FLAG_SEP}${_JAVA_JAR_PATH}")
+                list(APPEND CMAKE_JAVA_INCLUDE_PATH ${_JAVA_JAR_PATH})
+                list(APPEND _JAVA_DEPENDS ${_JAVA_INCLUDE_JAR})
+                list(APPEND _JAVA_COMPILE_DEPENDS ${_JAVA_INCLUDE_JAR})
+            else ()
+                message(SEND_ERROR "add_jar: INCLUDE_JARS target ${_JAVA_INCLUDE_JAR} is not a jar")
+            endif ()
+        else ()
+            set(CMAKE_JAVA_INCLUDE_PATH_FINAL "${CMAKE_JAVA_INCLUDE_PATH_FINAL}${CMAKE_JAVA_INCLUDE_FLAG_SEP}${_JAVA_INCLUDE_JAR}")
+            list(APPEND CMAKE_JAVA_INCLUDE_PATH "${_JAVA_INCLUDE_JAR}")
+            list(APPEND _JAVA_DEPENDS "${_JAVA_INCLUDE_JAR}")
+            list(APPEND _JAVA_COMPILE_DEPENDS "${_JAVA_INCLUDE_JAR}")
+        endif ()
+    endforeach()
+
+    # create an empty java_class_filelist
+    if (NOT EXISTS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist)
+        file(WRITE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist "")
+    endif()
+
+    if (_JAVA_COMPILE_FILES OR _JAVA_COMPILE_FILELISTS)
+        set (_JAVA_SOURCES_FILELISTS)
+
+        if (_JAVA_COMPILE_FILES)
+            # Create the list of files to compile.
+            set(_JAVA_SOURCES_FILE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_sources)
+            string(REPLACE ";" "\"\n\"" _JAVA_COMPILE_STRING "\"${_JAVA_COMPILE_FILES}\"")
+            file(WRITE ${_JAVA_SOURCES_FILE} ${_JAVA_COMPILE_STRING})
+            list (APPEND _JAVA_SOURCES_FILELISTS "@${_JAVA_SOURCES_FILE}")
+        endif()
+        if (_JAVA_COMPILE_FILELISTS)
+            foreach (_JAVA_FILELIST IN LISTS _JAVA_COMPILE_FILELISTS)
+                list (APPEND _JAVA_SOURCES_FILELISTS "@${_JAVA_FILELIST}")
+            endforeach()
+        endif()
+
+        # Compile the java files and create a list of class files
+        add_custom_command(
+            # NOTE: this command generates an artificial dependency file
+            OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
+            COMMAND ${Java_JAVAC_EXECUTABLE}
+                ${CMAKE_JAVA_COMPILE_FLAGS}
+                -classpath "${CMAKE_JAVA_INCLUDE_PATH_FINAL}"
+                -d ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
+                ${_JAVA_SOURCES_FILELISTS}
+            COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
+            DEPENDS ${_JAVA_COMPILE_FILES} ${_JAVA_COMPILE_FILELISTS} ${_JAVA_COMPILE_DEPENDS}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+            COMMENT "Building Java objects for ${_TARGET_NAME}.jar"
+        )
+        add_custom_command(
+            OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
+            COMMAND ${CMAKE_COMMAND}
+                -DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH}
+                -DCMAKE_JAR_CLASSES_PREFIX="${CMAKE_JAR_CLASSES_PREFIX}"
+                -P ${_JAVA_CLASS_FILELIST_SCRIPT}
+            DEPENDS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+    endif ()
+
+    # create the jar file
+    set(_JAVA_JAR_OUTPUT_PATH
+      ${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_NAME})
+    if (CMAKE_JNI_TARGET)
+        add_custom_command(
+            OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
+            COMMAND ${Java_JAR_EXECUTABLE}
+                -cf${_ENTRY_POINT_OPTION}${_MANIFEST_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE} ${_MANIFEST_VALUE}
+                ${_JAVA_RESOURCE_FILES_RELATIVE} @java_class_filelist
+            COMMAND ${CMAKE_COMMAND}
+                -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
+                -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
+                -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
+                -P ${_JAVA_SYMLINK_SCRIPT}
+            COMMAND ${CMAKE_COMMAND}
+                -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
+                -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_JAR_OUTPUT_PATH}
+                -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
+                -P ${_JAVA_SYMLINK_SCRIPT}
+            DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
+            WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
+            COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
+        )
+    else ()
+        add_custom_command(
+            OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
+            COMMAND ${Java_JAR_EXECUTABLE}
+                -cf${_ENTRY_POINT_OPTION}${_MANIFEST_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE} ${_MANIFEST_VALUE}
+                ${_JAVA_RESOURCE_FILES_RELATIVE} @java_class_filelist
+            COMMAND ${CMAKE_COMMAND}
+                -D_JAVA_TARGET_DIR=${_add_jar_OUTPUT_DIR}
+                -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
+                -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
+                -P ${_JAVA_SYMLINK_SCRIPT}
+            WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
+            DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
+            COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
+        )
+    endif ()
+
+    # Add the target and make sure we have the latest resource files.
+    add_custom_target(${_TARGET_NAME} ALL DEPENDS ${_JAVA_JAR_OUTPUT_PATH})
+
+    set_property(
+        TARGET
+            ${_TARGET_NAME}
+        PROPERTY
+            INSTALL_FILES
+                ${_JAVA_JAR_OUTPUT_PATH}
+    )
+
+    if (_JAVA_TARGET_OUTPUT_LINK)
+        set_property(
+            TARGET
+                ${_TARGET_NAME}
+            PROPERTY
+                INSTALL_FILES
+                    ${_JAVA_JAR_OUTPUT_PATH}
+                    ${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
+        )
+
+        if (CMAKE_JNI_TARGET)
+            set_property(
+                TARGET
+                    ${_TARGET_NAME}
+                PROPERTY
+                    JNI_SYMLINK
+                        ${_add_jar_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
+            )
+        endif ()
+    endif ()
+
+    set_property(
+        TARGET
+            ${_TARGET_NAME}
+        PROPERTY
+            JAR_FILE
+                ${_JAVA_JAR_OUTPUT_PATH}
+    )
+
+    set_property(
+        TARGET
+            ${_TARGET_NAME}
+        PROPERTY
+            CLASSDIR
+                ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
+    )
+
+endfunction()
+
+function(INSTALL_JAR _TARGET_NAME)
+    if (ARGC EQUAL 2)
+      set (_DESTINATION ${ARGV1})
+    else()
+      cmake_parse_arguments(_install_jar
+        ""
+        "DESTINATION;COMPONENT"
+        ""
+        ${ARGN})
+      if (_install_jar_DESTINATION)
+        set (_DESTINATION ${_install_jar_DESTINATION})
+      else()
+        message(SEND_ERROR "install_jar: ${_TARGET_NAME}: DESTINATION must be specified.")
+      endif()
+
+      if (_install_jar_COMPONENT)
+        set (_COMPONENT COMPONENT ${_install_jar_COMPONENT})
+      endif()
+    endif()
+
+    get_property(__FILES
+        TARGET
+            ${_TARGET_NAME}
+        PROPERTY
+            INSTALL_FILES
+    )
+
+    if (__FILES)
+        install(
+            FILES
+                ${__FILES}
+            DESTINATION
+                ${_DESTINATION}
+            ${_COMPONENT}
+        )
+    else ()
+        message(SEND_ERROR "install_jar: The target ${_TARGET_NAME} is not known in this scope.")
+    endif ()
+endfunction()
+
+function(INSTALL_JNI_SYMLINK _TARGET_NAME)
+    if (ARGC EQUAL 2)
+      set (_DESTINATION ${ARGV1})
+    else()
+      cmake_parse_arguments(_install_jni_symlink
+        ""
+        "DESTINATION;COMPONENT"
+        ""
+        ${ARGN})
+      if (_install_jni_symlink_DESTINATION)
+        set (_DESTINATION ${_install_jni_symlink_DESTINATION})
+      else()
+        message(SEND_ERROR "install_jni_symlink: ${_TARGET_NAME}: DESTINATION must be specified.")
+      endif()
+
+      if (_install_jni_symlink_COMPONENT)
+        set (_COMPONENT COMPONENT ${_install_jni_symlink_COMPONENT})
+      endif()
+    endif()
+
+    get_property(__SYMLINK
+        TARGET
+            ${_TARGET_NAME}
+        PROPERTY
+            JNI_SYMLINK
+    )
+
+    if (__SYMLINK)
+        install(
+            FILES
+                ${__SYMLINK}
+            DESTINATION
+                ${_DESTINATION}
+            ${_COMPONENT}
+        )
+    else ()
+        message(SEND_ERROR "install_jni_symlink: The target ${_TARGET_NAME} is not known in this scope.")
+    endif ()
+endfunction()
+
+function (find_jar VARIABLE)
+    set(_jar_names)
+    set(_jar_files)
+    set(_jar_versions)
+    set(_jar_paths
+        /usr/share/java/
+        /usr/local/share/java/
+        ${Java_JAR_PATHS})
+    set(_jar_doc "NOTSET")
+
+    set(_state "name")
+
+    foreach (arg ${ARGN})
+        if (${_state} STREQUAL "name")
+            if (${arg} STREQUAL "VERSIONS")
+                set(_state "versions")
+            elseif (${arg} STREQUAL "NAMES")
+                set(_state "names")
+            elseif (${arg} STREQUAL "PATHS")
+                set(_state "paths")
+            elseif (${arg} STREQUAL "DOC")
+                set(_state "doc")
+            else ()
+                set(_jar_names ${arg})
+                if (_jar_doc STREQUAL "NOTSET")
+                    set(_jar_doc "Finding ${arg} jar")
+                endif ()
+            endif ()
+        elseif (${_state} STREQUAL "versions")
+            if (${arg} STREQUAL "NAMES")
+                set(_state "names")
+            elseif (${arg} STREQUAL "PATHS")
+                set(_state "paths")
+            elseif (${arg} STREQUAL "DOC")
+                set(_state "doc")
+            else ()
+                set(_jar_versions ${_jar_versions} ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "names")
+            if (${arg} STREQUAL "VERSIONS")
+                set(_state "versions")
+            elseif (${arg} STREQUAL "PATHS")
+                set(_state "paths")
+            elseif (${arg} STREQUAL "DOC")
+                set(_state "doc")
+            else ()
+                set(_jar_names ${_jar_names} ${arg})
+                if (_jar_doc STREQUAL "NOTSET")
+                    set(_jar_doc "Finding ${arg} jar")
+                endif ()
+            endif ()
+        elseif (${_state} STREQUAL "paths")
+            if (${arg} STREQUAL "VERSIONS")
+                set(_state "versions")
+            elseif (${arg} STREQUAL "NAMES")
+                set(_state "names")
+            elseif (${arg} STREQUAL "DOC")
+                set(_state "doc")
+            else ()
+                set(_jar_paths ${_jar_paths} ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "doc")
+            if (${arg} STREQUAL "VERSIONS")
+                set(_state "versions")
+            elseif (${arg} STREQUAL "NAMES")
+                set(_state "names")
+            elseif (${arg} STREQUAL "PATHS")
+                set(_state "paths")
+            else ()
+                set(_jar_doc ${arg})
+            endif ()
+        endif ()
+    endforeach ()
+
+    if (NOT _jar_names)
+        message(FATAL_ERROR "find_jar: No name to search for given")
+    endif ()
+
+    foreach (jar_name ${_jar_names})
+        foreach (version ${_jar_versions})
+            set(_jar_files ${_jar_files} ${jar_name}-${version}.jar)
+        endforeach ()
+        set(_jar_files ${_jar_files} ${jar_name}.jar)
+    endforeach ()
+
+    find_file(${VARIABLE}
+        NAMES   ${_jar_files}
+        PATHS   ${_jar_paths}
+        DOC     ${_jar_doc}
+        NO_DEFAULT_PATH)
+endfunction ()
+
+function(create_javadoc _target)
+    set(_javadoc_packages)
+    set(_javadoc_files)
+    set(_javadoc_sourcepath)
+    set(_javadoc_classpath)
+    set(_javadoc_installpath "${CMAKE_INSTALL_PREFIX}/share/javadoc")
+    set(_javadoc_doctitle)
+    set(_javadoc_windowtitle)
+    set(_javadoc_author FALSE)
+    set(_javadoc_version FALSE)
+    set(_javadoc_use FALSE)
+
+    set(_state "package")
+
+    foreach (arg ${ARGN})
+        if (${_state} STREQUAL "package")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "CLASSPATH")
+                set(_state "classpath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                set(_javadoc_packages ${arg})
+                set(_state "packages")
+            endif ()
+        elseif (${_state} STREQUAL "packages")
+            if (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "CLASSPATH")
+                set(_state "classpath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                list(APPEND _javadoc_packages ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "files")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "CLASSPATH")
+                set(_state "classpath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                list(APPEND _javadoc_files ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "sourcepath")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "CLASSPATH")
+                set(_state "classpath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                list(APPEND _javadoc_sourcepath ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "classpath")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                list(APPEND _javadoc_classpath ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "installpath")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                set(_javadoc_installpath ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "doctitle")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "CLASSPATH")
+                set(_state "classpath")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                set(_javadoc_doctitle ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "windowtitle")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "CLASSPATH")
+                set(_state "classpath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                set(_javadoc_windowtitle ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "author")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "CLASSPATH")
+                set(_state "classpath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                set(_javadoc_author ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "use")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "CLASSPATH")
+                set(_state "classpath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                set(_javadoc_use ${arg})
+            endif ()
+        elseif (${_state} STREQUAL "version")
+            if (${arg} STREQUAL "PACKAGES")
+                set(_state "packages")
+            elseif (${arg} STREQUAL "FILES")
+                set(_state "files")
+            elseif (${arg} STREQUAL "SOURCEPATH")
+                set(_state "sourcepath")
+            elseif (${arg} STREQUAL "CLASSPATH")
+                set(_state "classpath")
+            elseif (${arg} STREQUAL "INSTALLPATH")
+                set(_state "installpath")
+            elseif (${arg} STREQUAL "DOCTITLE")
+                set(_state "doctitle")
+            elseif (${arg} STREQUAL "WINDOWTITLE")
+                set(_state "windowtitle")
+            elseif (${arg} STREQUAL "AUTHOR")
+                set(_state "author")
+            elseif (${arg} STREQUAL "USE")
+                set(_state "use")
+            elseif (${arg} STREQUAL "VERSION")
+                set(_state "version")
+            else ()
+                set(_javadoc_version ${arg})
+            endif ()
+        endif ()
+    endforeach ()
+
+    set(_javadoc_builddir ${CMAKE_CURRENT_BINARY_DIR}/javadoc/${_target})
+    set(_javadoc_options -d ${_javadoc_builddir})
+
+    if (_javadoc_sourcepath)
+        set(_start TRUE)
+        foreach(_path ${_javadoc_sourcepath})
+            if (_start)
+                set(_sourcepath ${_path})
+                set(_start FALSE)
+            else ()
+                set(_sourcepath ${_sourcepath}:${_path})
+            endif ()
+        endforeach()
+        set(_javadoc_options ${_javadoc_options} -sourcepath ${_sourcepath})
+    endif ()
+
+    if (_javadoc_classpath)
+        set(_start TRUE)
+        foreach(_path ${_javadoc_classpath})
+            if (_start)
+                set(_classpath ${_path})
+                set(_start FALSE)
+            else ()
+                set(_classpath ${_classpath}:${_path})
+            endif ()
+        endforeach()
+        set(_javadoc_options ${_javadoc_options} -classpath "${_classpath}")
+    endif ()
+
+    if (_javadoc_doctitle)
+        set(_javadoc_options ${_javadoc_options} -doctitle '${_javadoc_doctitle}')
+    endif ()
+
+    if (_javadoc_windowtitle)
+        set(_javadoc_options ${_javadoc_options} -windowtitle '${_javadoc_windowtitle}')
+    endif ()
+
+    if (_javadoc_author)
+        set(_javadoc_options ${_javadoc_options} -author)
+    endif ()
+
+    if (_javadoc_use)
+        set(_javadoc_options ${_javadoc_options} -use)
+    endif ()
+
+    if (_javadoc_version)
+        set(_javadoc_options ${_javadoc_options} -version)
+    endif ()
+
+    add_custom_target(${_target}_javadoc ALL
+        COMMAND ${Java_JAVADOC_EXECUTABLE} ${_javadoc_options}
+                            ${_javadoc_files}
+                            ${_javadoc_packages}
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+
+    install(
+        DIRECTORY ${_javadoc_builddir}
+        DESTINATION ${_javadoc_installpath}
+    )
+endfunction()
+
+function (create_javah)
+    cmake_parse_arguments(_create_javah
+      ""
+      "TARGET;GENERATED_FILES;OUTPUT_NAME;OUTPUT_DIR"
+      "CLASSES;CLASSPATH;DEPENDS"
+      ${ARGN})
+
+    # ckeck parameters
+    if (NOT _create_javah_TARGET AND NOT _create_javah_GENERATED_FILES)
+      message (FATAL_ERROR "create_javah: TARGET or GENERATED_FILES must be specified.")
+    endif()
+    if (_create_javah_OUTPUT_NAME AND _create_javah_OUTPUT_DIR)
+      message (FATAL_ERROR "create_javah: OUTPUT_NAME and OUTPUT_DIR are mutually exclusive.")
+    endif()
+
+    if (NOT _create_javah_CLASSES)
+      message (FATAL_ERROR "create_javah: CLASSES is a required parameter.")
+    endif()
+
+    set (_output_files)
+    if (WIN32 AND NOT CYGWIN AND CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
+      set(_classpath_sep ";")
+    else ()
+      set(_classpath_sep ":")
+    endif()
+
+    # handle javah options
+    set (_javah_options)
+
+    if (_create_javah_CLASSPATH)
+      # CLASSPATH can specify directories, jar files or targets created with add_jar command
+      set (_classpath)
+      foreach (_path IN LISTS _create_javah_CLASSPATH)
+        if (TARGET ${_path})
+          get_target_property (_jar_path ${_path} JAR_FILE)
+          if (_jar_path)
+            list (APPEND _classpath "${_jar_path}")
+            list (APPEND _create_javah_DEPENDS "${_path}")
+          else()
+            message(SEND_ERROR "create_javah: CLASSPATH target ${_path} is not a jar.")
+          endif()
+        elseif (EXISTS "${_path}")
+          list (APPEND _classpath "${_path}")
+          if (NOT IS_DIRECTORY "${_path}")
+            list (APPEND _create_javah_DEPENDS "${_path}")
+          endif()
+        else()
+          message(SEND_ERROR "create_javah: CLASSPATH entry ${_path} does not exist.")
+        endif()
+      endforeach()
+      string (REPLACE ";" "${_classpath_sep}" _classpath "${_classpath}")
+      list (APPEND _javah_options -classpath ${_classpath})
+    endif()
+
+    if (_create_javah_OUTPUT_DIR)
+      list (APPEND _javah_options -d "${_create_javah_OUTPUT_DIR}")
+    endif()
+
+    if (_create_javah_OUTPUT_NAME)
+      list (APPEND _javah_options -o "${_create_javah_OUTPUT_NAME}")
+      set (_output_files "${_create_javah_OUTPUT_NAME}")
+
+      get_filename_component (_create_javah_OUTPUT_DIR "${_create_javah_OUTPUT_NAME}" DIRECTORY)
+      get_filename_component (_create_javah_OUTPUT_DIR "${_create_javah_OUTPUT_DIR}" ABSOLUTE)
+    endif()
+
+    if (NOT _create_javah_OUTPUT_DIR)
+      set (_create_javah_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+    endif()
+
+    if (NOT _create_javah_OUTPUT_NAME)
+      # compute output names
+      foreach (_class IN LISTS _create_javah_CLASSES)
+        string (REPLACE "." "_" _c_header "${_class}")
+        set (_c_header  "${_create_javah_OUTPUT_DIR}/${_c_header}.h")
+        list (APPEND _output_files "${_c_header}")
+      endforeach()
+    endif()
+
+    # finalize custom command arguments
+    if (_create_javah_DEPENDS)
+      list (INSERT _create_javah_DEPENDS 0 DEPENDS)
+    endif()
+
+    add_custom_command (OUTPUT ${_output_files}
+      COMMAND "${Java_JAVAH_EXECUTABLE}" ${_javah_options} -jni ${_create_javah_CLASSES}
+      ${_create_javah_DEPENDS}
+      WORKING_DIRECTORY ${_create_javah_OUTPUT_DIR}
+      COMMENT "Building C header files from classes...")
+
+    if (_create_javah_TARGET)
+      add_custom_target (${_create_javah_TARGET} ALL DEPENDS ${_output_files})
+    endif()
+    if (_create_javah_GENERATED_FILES)
+      set (${_create_javah_GENERATED_FILES} ${_output_files} PARENT_SCOPE)
+    endif()
+endfunction()
diff --git a/config/cmake/UseJavaClassFilelist.cmake b/config/cmake/UseJavaClassFilelist.cmake
new file mode 100644
index 0000000..e8e6f01
--- /dev/null
+++ b/config/cmake/UseJavaClassFilelist.cmake
@@ -0,0 +1,58 @@
+#.rst:
+# UseJavaClassFilelist
+# --------------------
+#
+#
+#
+#
+#
+# This script create a list of compiled Java class files to be added to
+# a jar file.  This avoids including cmake files which get created in
+# the binary directory.
+
+#=============================================================================
+# Copyright 2010-2011 Andreas schneider <asn@redhat.com>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+if (CMAKE_JAVA_CLASS_OUTPUT_PATH)
+    if (EXISTS "${CMAKE_JAVA_CLASS_OUTPUT_PATH}")
+
+        set(_JAVA_GLOBBED_FILES)
+        if (CMAKE_JAR_CLASSES_PREFIX)
+            foreach(JAR_CLASS_PREFIX ${CMAKE_JAR_CLASSES_PREFIX})
+                message(STATUS "JAR_CLASS_PREFIX: ${JAR_CLASS_PREFIX}")
+
+                file(GLOB_RECURSE _JAVA_GLOBBED_TMP_FILES "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${JAR_CLASS_PREFIX}/*.class")
+                if (_JAVA_GLOBBED_TMP_FILES)
+                    list(APPEND _JAVA_GLOBBED_FILES ${_JAVA_GLOBBED_TMP_FILES})
+                endif ()
+            endforeach()
+        else()
+            file(GLOB_RECURSE _JAVA_GLOBBED_FILES "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/*.class")
+        endif ()
+
+        set(_JAVA_CLASS_FILES)
+        # file(GLOB_RECURSE foo RELATIVE) is broken so we need this.
+        foreach(_JAVA_GLOBBED_FILE ${_JAVA_GLOBBED_FILES})
+            file(RELATIVE_PATH _JAVA_CLASS_FILE ${CMAKE_JAVA_CLASS_OUTPUT_PATH} ${_JAVA_GLOBBED_FILE})
+            set(_JAVA_CLASS_FILES ${_JAVA_CLASS_FILES}${_JAVA_CLASS_FILE}\n)
+        endforeach()
+
+        # write to file
+        file(WRITE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist ${_JAVA_CLASS_FILES})
+
+    else ()
+        message(SEND_ERROR "FATAL: Java class output path doesn't exist")
+    endif ()
+else ()
+    message(SEND_ERROR "FATAL: Can't find CMAKE_JAVA_CLASS_OUTPUT_PATH")
+endif ()
diff --git a/config/cmake/UseJavaSymlinks.cmake b/config/cmake/UseJavaSymlinks.cmake
new file mode 100644
index 0000000..90ffdd5
--- /dev/null
+++ b/config/cmake/UseJavaSymlinks.cmake
@@ -0,0 +1,38 @@
+#.rst:
+# UseJavaSymlinks
+# ---------------
+#
+#
+#
+#
+#
+# Helper script for UseJava.cmake
+
+#=============================================================================
+# Copyright 2010-2011 Andreas schneider <asn@redhat.com>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+if (UNIX AND _JAVA_TARGET_OUTPUT_LINK)
+    if (_JAVA_TARGET_OUTPUT_NAME)
+        find_program(LN_EXECUTABLE
+            NAMES
+                ln
+        )
+
+        execute_process(
+            COMMAND ${LN_EXECUTABLE} -sf "${_JAVA_TARGET_OUTPUT_NAME}" "${_JAVA_TARGET_OUTPUT_LINK}"
+            WORKING_DIRECTORY ${_JAVA_TARGET_DIR}
+        )
+    else ()
+        message(SEND_ERROR "FATAL: Can't find _JAVA_TARGET_OUTPUT_NAME")
+    endif ()
+endif ()
diff --git a/config/cmake/hdf5-config.cmake.in b/config/cmake/hdf5-config.cmake.in
index 3577e40..3f95d76 100644
--- a/config/cmake/hdf5-config.cmake.in
+++ b/config/cmake/hdf5-config.cmake.in
@@ -14,6 +14,7 @@ set (${HDF5_PACKAGE_NAME}_VALID_COMPONENTS
     HL
     CXX_HL
     Fortran_HL
+    Java
     Tools
 )
 
@@ -23,6 +24,7 @@ set (${HDF5_PACKAGE_NAME}_VALID_COMPONENTS
 set (${HDF5_PACKAGE_NAME}_ENABLE_PARALLEL @HDF5_ENABLE_PARALLEL@)
 set (${HDF5_PACKAGE_NAME}_BUILD_FORTRAN   @HDF5_BUILD_FORTRAN@)
 set (${HDF5_PACKAGE_NAME}_BUILD_CPP_LIB   @HDF5_BUILD_CPP_LIB@)
+set (${HDF5_PACKAGE_NAME}_BUILD_JAVA      @HDF5_BUILD_JAVA@)
 set (${HDF5_PACKAGE_NAME}_BUILD_TOOLS     @HDF5_BUILD_TOOLS@)
 set (${HDF5_PACKAGE_NAME}_BUILD_HL_LIB    @HDF5_BUILD_HL_LIB@)
 set (${HDF5_PACKAGE_NAME}_ENABLE_Z_LIB_SUPPORT @HDF5_ENABLE_Z_LIB_SUPPORT@)
@@ -40,6 +42,16 @@ if (${HDF5_PACKAGE_NAME}_ENABLE_PARALLEL)
   set (${HDF5_PACKAGE_NAME}_MPI_C_LIBRARIES    "@MPI_C_LIBRARIES@")
 endif ()
 
+if (${HDF5_PACKAGE_NAME}_BUILD_JAVA)
+  set (${HDF5_PACKAGE_NAME}_JAVA_INCLUDE_DIRS
+      @PACKAGE_CURRENT_BUILD_DIR@/lib/jarhdf5-@HDF5_VERSION_STRING@.jar
+      @PACKAGE_CURRENT_BUILD_DIR@/lib/slf4j-api-1.7.5.jar
+      @PACKAGE_CURRENT_BUILD_DIR@/lib/slf4j-nop-1.7.5.jar
+  )
+  set (${HDF5_PACKAGE_NAME}_JAVA_LIBRARY "@PACKAGE_CURRENT_BUILD_DIR@/lib")
+  set (${HDF5_PACKAGE_NAME}_JAVA_LIBRARIES "${${HDF5_PACKAGE_NAME}_JAVA_LIBRARY}")
+endif()
+
 #-----------------------------------------------------------------------------
 # Directories
 #-----------------------------------------------------------------------------
@@ -123,6 +135,8 @@ foreach (libtype IN LISTS ${HDF5_PACKAGE_NAME}_LIB_TYPE)
       set (hdf5_comp "hdf5_hl")
     elseif (${comp} STREQUAL "CXX_HL")
       set (hdf5_comp "hdf5_hl_cpp")
+    elseif (${comp} STREQUAL "Java")
+      set (hdf5_comp "hdf5_java")
     elseif (${comp} STREQUAL "Tools")
       set (hdf5_comp "hdf5_tools")
     elseif (${comp} STREQUAL "Fortran")
diff --git a/config/cmake/jrunTest.cmake b/config/cmake/jrunTest.cmake
new file mode 100644
index 0000000..7a92867
--- /dev/null
+++ b/config/cmake/jrunTest.cmake
@@ -0,0 +1,212 @@
+# runTest.cmake executes a command and captures the output in a file. File is then compared
+# against a reference file. Exit status of command can also be compared.
+cmake_policy(SET CMP0007 NEW)
+
+# arguments checking
+if (NOT TEST_TESTER)
+  message (FATAL_ERROR "Require TEST_TESTER to be defined")
+endif (NOT TEST_TESTER)
+if (NOT TEST_PROGRAM)
+  message (FATAL_ERROR "Require TEST_PROGRAM to be defined")
+endif (NOT TEST_PROGRAM)
+if (NOT TEST_LIBRARY_DIRECTORY)
+  message (STATUS "Require TEST_LIBRARY_DIRECTORY to be defined")
+endif (NOT TEST_LIBRARY_DIRECTORY)
+if (NOT TEST_FOLDER)
+  message ( FATAL_ERROR "Require TEST_FOLDER to be defined")
+endif (NOT TEST_FOLDER)
+if (NOT TEST_OUTPUT)
+  message (FATAL_ERROR "Require TEST_OUTPUT to be defined")
+endif (NOT TEST_OUTPUT)
+if (NOT TEST_CLASSPATH)
+  message (STATUS "Require TEST_CLASSPATH to be defined")
+endif (NOT TEST_CLASSPATH)
+if (NOT TEST_REFERENCE)
+  message (FATAL_ERROR "Require TEST_REFERENCE to be defined")
+endif (NOT TEST_REFERENCE)
+
+if (NOT TEST_ERRREF)
+  set (ERROR_APPEND 1)
+endif (NOT TEST_ERRREF)
+
+if (NOT TEST_LOG_LEVEL)
+  set (LOG_LEVEL "info")
+else (NOT TEST_LOG_LEVEL)
+  set (LOG_LEVEL "${TEST_LOG_LEVEL}")
+endif (NOT TEST_LOG_LEVEL)
+
+message (STATUS "COMMAND: ${TEST_TESTER} -Xmx1024M -Dorg.slf4j.simpleLogger.defaultLog=${LOG_LEVEL} -Djava.library.path=\"${TEST_LIBRARY_DIRECTORY}\" -cp \"${TEST_CLASSPATH}\" ${TEST_ARGS} ${TEST_PROGRAM} ${ARGN}")
+
+if (WIN32 AND NOT MINGW)
+  set (ENV{PATH} "$ENV{PATH}\\;${TEST_LIBRARY_DIRECTORY}")
+endif (WIN32 AND NOT MINGW)
+
+# run the test program, capture the stdout/stderr and the result var
+execute_process (
+    COMMAND ${TEST_TESTER} -Xmx1024M
+    -Dorg.slf4j.simpleLogger.defaultLogLevel=${LOG_LEVEL}
+    -Djava.library.path=${TEST_LIBRARY_DIRECTORY}
+    -cp "${TEST_CLASSPATH}" ${TEST_ARGS} ${TEST_PROGRAM}
+    ${ARGN}
+    WORKING_DIRECTORY ${TEST_FOLDER}
+    RESULT_VARIABLE TEST_RESULT
+    OUTPUT_FILE ${TEST_OUTPUT}
+    ERROR_FILE ${TEST_OUTPUT}.err
+    ERROR_VARIABLE TEST_ERROR
+)
+
+message (STATUS "COMMAND Result: ${TEST_RESULT}")
+
+if (EXISTS ${TEST_FOLDER}/${TEST_OUTPUT}.err)
+  file (READ ${TEST_FOLDER}/${TEST_OUTPUT}.err TEST_STREAM)
+  if (TEST_MASK_FILE)
+    STRING(REGEX REPLACE "CurrentDir is [^\n]+\n" "CurrentDir is (dir name)\n" TEST_STREAM "${TEST_STREAM}") 
+  endif (TEST_MASK_FILE)
+
+  if (ERROR_APPEND)
+    file (APPEND ${TEST_FOLDER}/${TEST_OUTPUT} "${TEST_STREAM}") 
+  else (ERROR_APPEND)
+    file (WRITE ${TEST_FOLDER}/${TEST_OUTPUT}.err "${TEST_STREAM}")
+  endif (ERROR_APPEND)
+endif (EXISTS ${TEST_FOLDER}/${TEST_OUTPUT}.err)
+
+if (TEST_MASK_ERROR)
+  if (NOT TEST_ERRREF)
+    file (READ ${TEST_FOLDER}/${TEST_OUTPUT} TEST_STREAM)
+  else (NOT TEST_ERRREF)
+    file (READ ${TEST_FOLDER}/${TEST_OUTPUT}.err TEST_STREAM)
+  endif (NOT TEST_ERRREF)
+  string (REGEX REPLACE "Time:[^\n]+\n" "Time:  XXXX\n" TEST_STREAM "${TEST_STREAM}") 
+  string (REGEX REPLACE "thread [0-9]*:" "thread (IDs):" TEST_STREAM "${TEST_STREAM}") 
+  string (REGEX REPLACE ": ([^\n]*)[.]c " ": (file name) " TEST_STREAM "${TEST_STREAM}") 
+  string (REGEX REPLACE " line [0-9]*" " line (number)" TEST_STREAM "${TEST_STREAM}") 
+  #string (REGEX REPLACE "v[1-9]*[.][0-9]*[.]" "version (number)." TEST_STREAM "${TEST_STREAM}") 
+  string (REGEX REPLACE "HDF5 .[1-9]*[.][0-9]*[.][0-9]*[^)]*" "HDF5 (version (number)" TEST_STREAM "${TEST_STREAM}") 
+  string (REGEX REPLACE "H5Eget_auto[1-2]*" "H5Eget_auto(1 or 2)" TEST_STREAM "${TEST_STREAM}") 
+  string (REGEX REPLACE "H5Eset_auto[1-2]*" "H5Eset_auto(1 or 2)" TEST_STREAM "${TEST_STREAM}") 
+  if (NOT TEST_ERRREF)
+    file (WRITE ${TEST_FOLDER}/${TEST_OUTPUT} "${TEST_STREAM}")
+  else (NOT TEST_ERRREF)
+    file (WRITE ${TEST_FOLDER}/${TEST_OUTPUT}.err "${TEST_STREAM}")
+  endif (NOT TEST_ERRREF)
+endif (TEST_MASK_ERROR)
+
+# if the return value is !=0 bail out
+if (NOT ${TEST_RESULT} STREQUAL ${TEST_EXPECT})
+  message (STATUS "ERROR OUTPUT: ${TEST_STREAM}")
+  message (FATAL_ERROR "Failed: Test program ${TEST_PROGRAM} exited != 0.\n${TEST_ERROR}")
+endif (NOT ${TEST_RESULT} STREQUAL ${TEST_EXPECT})
+
+message (STATUS "COMMAND Error: ${TEST_ERROR}")
+
+if (NOT TEST_SKIP_COMPARE)
+  if (WIN32 AND NOT MINGW)
+    file (READ ${TEST_FOLDER}/${TEST_REFERENCE} TEST_STREAM)
+    file (WRITE ${TEST_FOLDER}/${TEST_REFERENCE} "${TEST_STREAM}")
+  endif (WIN32 AND NOT MINGW)
+
+  # now compare the output with the reference
+  execute_process (
+      COMMAND ${CMAKE_COMMAND} -E compare_files ${TEST_FOLDER}/${TEST_OUTPUT} ${TEST_FOLDER}/${TEST_REFERENCE}
+      RESULT_VARIABLE TEST_RESULT
+  )
+  if (NOT ${TEST_RESULT} STREQUAL 0)
+  set (TEST_RESULT 0)
+  file (STRINGS ${TEST_FOLDER}/${TEST_OUTPUT} test_act)
+  list (LENGTH test_act len_act)
+  file (STRINGS ${TEST_FOLDER}/${TEST_REFERENCE} test_ref)
+  list (LENGTH test_ref len_ref)
+  if (NOT ${len_act} STREQUAL "0")
+    MATH (EXPR _FP_LEN "${len_ref} - 1")
+    foreach (line RANGE 0 ${_FP_LEN})
+      list (GET test_act ${line} str_act)
+      list (GET test_ref ${line} str_ref)
+      if (NOT "${str_act}" STREQUAL "${str_ref}")
+        if (NOT "${str_act}" STREQUAL "")
+          set (TEST_RESULT 1)
+          message ("line = ${line}\n***ACTUAL: ${str_act}\n****REFER: ${str_ref}\n")
+         endif (NOT "${str_act}" STREQUAL "")
+      endif (NOT "${str_act}" STREQUAL "${str_ref}")
+    endforeach (line RANGE 0 ${_FP_LEN})
+  endif (NOT ${len_act} STREQUAL "0")
+  if (NOT ${len_act} STREQUAL ${len_ref})
+    set (TEST_RESULT 1)
+  endif (NOT ${len_act} STREQUAL ${len_ref})
+  endif (NOT ${TEST_RESULT} STREQUAL 0)
+
+  message (STATUS "COMPARE Result: ${TEST_RESULT}")
+
+  # again, if return value is !=0 scream and shout
+  if (NOT ${TEST_RESULT} STREQUAL 0)
+    message (FATAL_ERROR "Failed: The output of ${TEST_OUTPUT} did not match ${TEST_REFERENCE}")
+  endif (NOT ${TEST_RESULT} STREQUAL 0)
+  
+  if (TEST_ERRREF)
+    if (WIN32 AND NOT MINGW)
+      file (READ ${TEST_FOLDER}/${TEST_ERRREF} TEST_STREAM)
+      file (WRITE ${TEST_FOLDER}/${TEST_ERRREF} "${TEST_STREAM}")
+    endif (WIN32 AND NOT MINGW)
+
+    # now compare the error output with the error reference
+    execute_process (
+        COMMAND ${CMAKE_COMMAND} -E compare_files ${TEST_FOLDER}/${TEST_OUTPUT}.err ${TEST_FOLDER}/${TEST_ERRREF}
+        RESULT_VARIABLE TEST_RESULT
+    )
+    if (NOT ${TEST_RESULT} STREQUAL 0)
+    set (TEST_RESULT 0)
+    file (STRINGS ${TEST_FOLDER}/${TEST_OUTPUT}.err test_act)
+    list (LENGTH test_act len_act)
+    file (STRINGS ${TEST_FOLDER}/${TEST_ERRREF} test_ref)
+    list (LENGTH test_ref len_ref)
+    MATH (EXPR _FP_LEN "${len_ref} - 1")
+    if (NOT ${len_act} STREQUAL "0")
+      MATH (EXPR _FP_LEN "${len_ref} - 1")
+      foreach (line RANGE 0 ${_FP_LEN})
+        list (GET test_act ${line} str_act)
+        list (GET test_ref ${line} str_ref)
+        if (NOT "${str_act}" STREQUAL "${str_ref}")
+          if (NOT "${str_act}" STREQUAL "")
+            set (TEST_RESULT 1)
+            message ("line = ${line}\n***ACTUAL: ${str_act}\n****REFER: ${str_ref}\n")
+           endif (NOT "${str_act}" STREQUAL "")
+        endif (NOT "${str_act}" STREQUAL "${str_ref}")
+      endforeach (line RANGE 0 ${_FP_LEN})
+    endif (NOT ${len_act} STREQUAL "0")
+    if (NOT ${len_act} STREQUAL ${len_ref})
+      set (TEST_RESULT 1)
+    endif (NOT ${len_act} STREQUAL ${len_ref})
+    endif (NOT ${TEST_RESULT} STREQUAL 0)
+
+    message (STATUS "COMPARE Result: ${TEST_RESULT}")
+
+    # again, if return value is !=0 scream and shout
+    if (NOT ${TEST_RESULT} STREQUAL 0)
+      message (FATAL_ERROR "Failed: The error output of ${TEST_OUTPUT}.err did not match ${TEST_ERRREF}")
+    endif (NOT ${TEST_RESULT} STREQUAL 0)
+  endif (TEST_ERRREF)
+endif (NOT TEST_SKIP_COMPARE)
+
+if (TEST_GREP_COMPARE)
+  # now grep the output with the reference
+  file (READ ${TEST_FOLDER}/${TEST_OUTPUT} TEST_STREAM)
+
+  # TEST_REFERENCE should always be matched
+  string (REGEX MATCH "${TEST_REFERENCE}" TEST_MATCH ${TEST_STREAM}) 
+  string (COMPARE EQUAL "${TEST_REFERENCE}" "${TEST_MATCH}" TEST_RESULT) 
+  if (${TEST_RESULT} STREQUAL "0")
+    message (FATAL_ERROR "Failed: The output of ${TEST_PROGRAM} did not contain ${TEST_REFERENCE}")
+  endif (${TEST_RESULT} STREQUAL "0")
+
+  string (REGEX MATCH "${TEST_FILTER}" TEST_MATCH ${TEST_STREAM}) 
+  if (${TEST_EXPECT} STREQUAL "1")
+    # TEST_EXPECT (1) interperts TEST_FILTER as NOT to match
+    string (LENGTH "${TEST_MATCH}" TEST_RESULT) 
+    if (NOT ${TEST_RESULT} STREQUAL "0")
+      message (FATAL_ERROR "Failed: The output of ${TEST_PROGRAM} did contain ${TEST_FILTER}")
+    endif (NOT ${TEST_RESULT} STREQUAL "0")
+  endif (${TEST_EXPECT} STREQUAL "0")
+endif (TEST_GREP_COMPARE)
+
+# everything went fine...
+message ("${TEST_PROGRAM} Passed")
+
diff --git a/config/cmake/libhdf5.settings.cmake.in b/config/cmake/libhdf5.settings.cmake.in
index cc6ae3e..8348af0 100644
--- a/config/cmake/libhdf5.settings.cmake.in
+++ b/config/cmake/libhdf5.settings.cmake.in
@@ -1,43 +1,50 @@
-      SUMMARY OF THE HDF5 CONFIGURATION
-      =================================
+	    SUMMARY OF THE HDF5 CONFIGURATION
+	    =================================
 
 General Information:
 -------------------
                    HDF5 Version: @HDF5_PACKAGE_VERSION_STRING@
                   Configured on: @CONFIG_DATE@
                   Configured by: @CMAKE_GENERATOR@
-                 Configure mode: CMAKE @CMAKE_VERSION@
                     Host system: @CMAKE_HOST_SYSTEM@
               Uname information: @CMAKE_SYSTEM_NAME@
                        Byte sex: @BYTESEX@
-                      Libraries: @BUILD_NAME_EXT@
              Installation point: @CMAKE_INSTALL_PREFIX@
 
 Compiling Options:
 ------------------
-               Compilation Mode: @CMAKE_BUILD_TYPE@
-                     C Compiler: @CMAKE_C_COMPILER@
-                         CFLAGS: @CMAKE_C_FLAGS@
-                      H5_CFLAGS: @H5_CFLAGS@
-                      AM_CFLAGS: @AM_CFLAGS@
-                       CPPFLAGS: @CPPFLAGS@
-                    H5_CPPFLAGS: @H5_CPPFLAGS@
-                    AM_CPPFLAGS: @AM_CPPFLAGS@
-               Shared C Library: @H5_ENABLE_SHARED_LIB@
-               Static C Library: @H5_ENABLE_STATIC_LIB@
+                     Build Mode: @CMAKE_BUILD_TYPE@
+              Debugging Symbols: @SYMBOLS@
+                        Asserts: @ASSERTS@
+                      Profiling: @PROFILING@
+             Optimization Level: @OPTIMIZATION@
+
+Linking Options:
+----------------
+                      Libraries: @BUILD_NAME_EXT@
   Statically Linked Executables: @BUILD_STATIC_EXECS@
                         LDFLAGS: @CMAKE_SHARED_LINKER_FLAGS@
+                     H5_LDFLAGS: @H5_LDFLAGS@
                      AM_LDFLAGS: @AM_LDFLAGS@
                 Extra libraries: @LINK_LIBS@
                        Archiver: @CMAKE_AR@
                          Ranlib: @CMAKE_RANLIB@
-              Debugged Packages: @DEBUG_PKG@
-                    API Tracing: @HDF5_ENABLE_TRACE@
 
 Languages:
 ----------
+                              C: yes
+                     C Compiler: @CMAKE_C_COMPILER@ @CMAKE_C_COMPILER_VERSION@
+                       CPPFLAGS: @CPPFLAGS@
+                    H5_CPPFLAGS: @H5_CPPFLAGS@
+                    AM_CPPFLAGS: @AM_CPPFLAGS@
+                         CFLAGS: @CMAKE_C_FLAGS@
+                      H5_CFLAGS: @H5_CFLAGS@
+                      AM_CFLAGS: @AM_CFLAGS@
+               Shared C Library: @H5_ENABLE_SHARED_LIB@
+               Static C Library: YES
+
                         Fortran: @HDF5_BUILD_FORTRAN@
-@BUILD_FORTRAN_CONDITIONAL_TRUE@               Fortran Compiler: @CMAKE_Fortran_COMPILER@
+@BUILD_FORTRAN_CONDITIONAL_TRUE@               Fortran Compiler: @CMAKE_Fortran_COMPILER@ @CMAKE_Fortran_COMPILER_VERSION@
 @BUILD_FORTRAN_CONDITIONAL_TRUE@                  Fortran Flags: @CMAKE_Fortran_FLAGS@
 @BUILD_FORTRAN_CONDITIONAL_TRUE@               H5 Fortran Flags: @H5_FCFLAGS@
 @BUILD_FORTRAN_CONDITIONAL_TRUE@               AM Fortran Flags: @AM_FCFLAGS@
@@ -45,27 +52,32 @@ Languages:
 @BUILD_FORTRAN_CONDITIONAL_TRUE@         Static Fortran Library: YES
 
                             C++: @HDF5_BUILD_CPP_LIB@
-@BUILD_CXX_CONDITIONAL_TRUE@                   C++ Compiler: @CMAKE_CXX_COMPILER@
+@BUILD_CXX_CONDITIONAL_TRUE@                   C++ Compiler: @CMAKE_CXX_COMPILER@ @CMAKE_CXX_COMPILER_VERSION@
 @BUILD_CXX_CONDITIONAL_TRUE@                      C++ Flags: @CMAKE_CXX_FLAGS@
 @BUILD_CXX_CONDITIONAL_TRUE@                   H5 C++ Flags: @H5_CXXFLAGS@
 @BUILD_CXX_CONDITIONAL_TRUE@                   AM C++ Flags: @AM_CXXFLAGS@
 @BUILD_CXX_CONDITIONAL_TRUE@             Shared C++ Library: @H5_ENABLE_SHARED_LIB@
 @BUILD_CXX_CONDITIONAL_TRUE@             Static C++ Library: YES
 
+                            JAVA: @HDF5_BUILD_JAVA@
+@BUILD_JAVA_CONDITIONAL_TRUE@                   JAVA Compiler: @CMAKE_Java_COMPILER@ @Java_VERSION@
+
 Features:
 ---------
                   Parallel HDF5: @HDF5_ENABLE_PARALLEL@
-             High Level library: @HDF5_BUILD_HL_LIB@
+             High-level library: @HDF5_BUILD_HL_LIB@
                    Threadsafety: @HDF5_ENABLE_THREADSAFE@
-            Default API Mapping: @DEFAULT_API_VERSION@
- With Deprecated Public Symbols: @HDF5_ENABLE_DEPRECATED_SYMBOLS@
+            Default API mapping: @DEFAULT_API_VERSION@
+ With deprecated public symbols: @HDF5_ENABLE_DEPRECATED_SYMBOLS@
          I/O filters (external): @EXTERNAL_FILTERS@
                             MPE: @H5_HAVE_LIBLMPE@
                      Direct VFD: @H5_HAVE_DIRECT@
                         dmalloc: @H5_HAVE_LIBDMALLOC@
-Clear file buffers before write: @HDF5_Enable_Clear_File_Buffers@
+ Packages w/ extra debug output: @INTERNAL_DEBUG_OUTPUT@
+                    API Tracing: @HDF5_ENABLE_TRACE@
            Using memory checker: @HDF5_ENABLE_USING_MEMCHECKER@
 Memory allocation sanity checks: @HDF5_MEMORY_ALLOC_SANITY_CHECK@
+            Metadata trace file: @METADATATRACEFILE@
          Function Stack Tracing: @HDF5_ENABLE_CODESTACK@
       Strict File Format Checks: @HDF5_STRICT_FORMAT_CHECKS@
    Optimization Instrumentation: @HDF5_Enable_Instrument@
diff --git a/config/commence.am b/config/commence.am
index 554c9fb..1a26a85 100644
--- a/config/commence.am
+++ b/config/commence.am
@@ -37,6 +37,7 @@ LIBH5TEST=$(top_builddir)/test/libh5test.la
 LIBH5F=$(top_builddir)/fortran/src/libhdf5_fortran.la
 LIBH5FTEST=$(top_builddir)/fortran/test/libh5test_fortran.la
 LIBH5CPP=$(top_builddir)/c++/src/libhdf5_cpp.la
+LIBH5JNI=$(top_builddir)/java/src/jni/libhdf5_java.la
 LIBH5TOOLS=$(top_builddir)/tools/lib/libh5tools.la
 LIBH5_HL=$(top_builddir)/hl/src/libhdf5_hl.la
 LIBH5F_HL=$(top_builddir)/hl/fortran/src/libhdf5hl_fortran.la