Merge lp:~zorba-coders/zorba/util-jvm_core_module into lp:zorba

[Chris Hillery]

Moves the util-jvm module into the core.

[Cezar Andrei (cezar-andrei)]

modules/ExternalModules.conf file needs to be updated. If the line with util-jvm is left there is build error.

Also, the modules that depend on it have to be fixed too, right now they don't find util-jvm:

-- --- Module: nosqldb ---
-- Zorba's util-jvm module not found; skipping nosqldb module.
-- --- End module: nosqldb ---
-- --- Module: read-pdf ---
-- Zorba's util-jvm module not found; skipping read-pdf module.
-- --- End module: read-pdf ---
-- ******** BEGIN Configuring module Data-Formatting ********
-- Zorba's util-jvm module not found; skipping data-formatting module.
-- ******** END Configuring module Data-Formatting ********

-- Zorba's util-jvm module not found; skipping schema-tools module.

review: Needs Fixing

[Chris Hillery (ceejatec)]

Fixing ExternalModules.conf should be trivial.

As to the other modules, we'll have to update them after merging this proposal. If we remove the FIND_PACKAGE() from them first, they'll have build errors. If we leave them as-is and merge this one first, then they will quietly get skipped by the remote queue, which is better. We'll just need to immediately commit changes to each of them after the main merge.

[Cezar Andrei (cezar-andrei)]

Agreed, but we need to have them working before e check anything in.
 On May 1, 2013 5:31 PM, "Chris Hillery" <email address hidden>
wrote:

> Fixing ExternalModules.conf should be trivial.
>
> As to the other modules, we'll have to update them after merging this
> proposal. If we remove the FIND_PACKAGE() from them first, they'll have
> build errors. If we leave them as-is and merge this one first, then they
> will quietly get skipped by the remote queue, which is better. We'll just
> need to immediately commit changes to each of them after the main merge.
> --
>
> https://code.launchpad.net/~zorba-coders/zorba/util-jvm_core_module/+merge/161854
> You are reviewing the proposed merge of
> lp:~zorba-coders/zorba/util-jvm_core_module into lp:zorba.
>

[Chris Hillery (ceejatec)]

Did you have any other comments, Cezar?

I want to think a bit about the ExternalModuleConfig.cmake that's included here; it looks like it might be redundant with the one in the Zorba trunk, plus I'm not sure it's the right solution to the problem anyway.

[lp:~zorba-coders/zorba/util-jvm_core_module]

11390. By Chris Hillery on 2013-05-03

Merge from trunk.

[Chris Hillery (ceejatec)]

I think we can simplify this quite a bit. All Java modules really need are:

1. The macros in UtilJavaUse.cmake (or the location of that file to INCLUDE() it).
2. The location of JavaVMSingleton.h.
3. The location of libutil-java.so (or whatever the dynamic library is called).

We can add those variables directly to the main ZorbaConfig.cmake which is exported from the Zorba project, with appropriate NOTFOUND values if Java support wasn't built into Zorba. Then modules will only need to FIND_PACKAGE(zorba) and check for those variables having valid settings. We can eliminate the entire util-jvm/config directory except for UtilJavaUse.cmake. I believe we can actually eliminate util-jvm.xq too; there's no purpose to the XQuery module that I can see.

[Chris Hillery (ceejatec)]

This has grown stale and I think it probably needs to be done differently. We will update the branch and re-propose in future.

Unmerged revisions

11390. By Chris Hillery on 2013-05-03

Merge from trunk.

11389. By Juan Zacarias on 2013-04-18

Added util-jvm as core module

=== modified file 'modules/CMakeLists.txt'
--- modules/CMakeLists.txt	2013-02-07 17:24:36 +0000
+++ modules/CMakeLists.txt	2013-05-03 09:36:26 +0000
@@ -16,6 +16,7 @@
 ADD_SUBDIRECTORY(org)
 ADD_SUBDIRECTORY(functx)
 ADD_SUBDIRECTORY(xqxq)
+ADD_SUBDIRECTORY(util-jvm)
 ADD_SUBDIRECTORY(w3c)
 
 # Add external module projects - any subdirectories of a directory

=== added directory 'modules/util-jvm'
=== added file 'modules/util-jvm/CMakeLists.txt'
--- modules/util-jvm/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ modules/util-jvm/CMakeLists.txt	2013-05-03 09:36:26 +0000
@@ -0,0 +1,88 @@
+# Copyright 2006-2010 The FLWOR Foundation.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# missing 
+# share use file for other modules
+
+#
+# JAVA
+#
+IF (ZORBA_SUPPRESS_JAVA)
+  MESSAGE (STATUS "ZORBA_SUPPRESS_JAVA is true - not searching for Java")
+ELSE (ZORBA_SUPPRESS_JAVA)
+  #include util-jvm macros
+  INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/config/UtilJavaUse.cmake)
+  MESSAGE(STATUS "-- util-jvm module --")
+  #find packages
+  MESSAGE (STATUS "Looking for JNI")
+  ZORBA_FIND_JNI()
+  MESSAGE (STATUS "Looking for Java")
+  FIND_PACKAGE(Java)
+
+  IF (JNI_FOUND)
+    SET (UTIL_JVM_VERSION 1.0)
+
+    # Export this include directory by setting ZORBA_PROJECT_INCLUDE_DIRS
+    SET (ZORBA_PROJECT_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/include")
+    INCLUDE_DIRECTORIES ("${ZORBA_PROJECT_INCLUDE_DIRS}")
+    INSTALL (FILES include/JavaVMSingleton.h DESTINATION include)
+    
+    INCLUDE (CMakeJavaInformation )
+    MESSAGE(STATUS "Using Java API")
+    EXECUTE_PROCESS (
+      COMMAND ${JAVA_RUNTIME} -version
+      RESULT_VARIABLE JAVA_VERSION
+      OUTPUT_QUIET
+      ERROR_QUIET)
+
+    MESSAGE (STATUS "JNI found at    :${JAVA_INCLUDE_PATH}")
+    MESSAGE (STATUS "Java Library at :${JAVA_JVM_LIBRARY}")
+
+    INCLUDE_DIRECTORIES (${JAVA_INCLUDE_PATH} ${JAVA_INCLUDE_PATH2})
+    INCLUDE_DIRECTORIES (${JAVA_INCLUDE_PATH})
+
+    # For now, we still have a module, but it actually does nothing at all.
+    DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/util-jvm"
+      VERSION 1.0 FILE "util-jvm.xq")
+
+    # The important stuff is the library, which we install in Zorba's
+    # default lib directory.
+    ADD_LIBRARY(util-jvm SHARED util-jvm.cpp JavaVMSingleton.cpp)
+    TARGET_LINK_LIBRARIES(util-jvm "${JAVA_JVM_LIBRARY}" zorba_${ZORBA_STORE_NAME})
+    INSTALL(TARGETS util-jvm 
+      RUNTIME DESTINATION bin
+      LIBRARY DESTINATION lib${LIB_SUFFIX}
+      ARCHIVE DESTINATION lib)
+
+    ADD_SUBDIRECTORY(config)
+    # MAC OS X only property
+    # this is required to make sure that the library has the correct install name after
+    # installation such that dependent modules always find it
+    #SET_TARGET_PROPERTIES(util-jvm PROPERTIES INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib")
+
+    # Set this in the parent scope so it will be put into our Config.cmake file.
+    # As with many other things, this doesn't work when the module is installed.
+    #SET(ZORBA_PROJECT_LIBRARIES util-jvm PARENT_SCOPE)
+
+  ELSE (JNI_FOUND)
+    MESSAGE(STATUS "Building Zorba without util-jvm module.")
+  ENDIF (JNI_FOUND)
+  MESSAGE(STATUS "---")
+  MESSAGE(STATUS "")
+ENDIF(ZORBA_SUPPRESS_JAVA)
+
+# Cache these variables for ease of packages depending on us
+SET (JAVA_FOUND "${JAVA_FOUND}" CACHE BOOL "Whether Java was found" FORCE)
+SET (JNI_FOUND "${JNI_FOUND}" CACHE BOOL "Whether JNI was found" FORCE)
+

=== added file 'modules/util-jvm/JavaVMSingleton.cpp'
--- modules/util-jvm/JavaVMSingleton.cpp	1970-01-01 00:00:00 +0000
+++ modules/util-jvm/JavaVMSingleton.cpp	2013-05-03 09:36:26 +0000
@@ -0,0 +1,267 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "JavaVMSingleton.h"
+
+#include <fstream>
+#include <iostream>
+#include <istream>
+#include <string>
+#include <cstdlib>
+#include <cstring>
+#include <sstream>
+
+#include <zorba/util/path.h>
+#include <zorba/util/file.h>
+#include <zorba/zorba.h>
+
+
+namespace zorba { namespace jvm {
+JavaVMSingleton* JavaVMSingleton::instance = NULL;
+
+JavaVMSingleton::JavaVMSingleton(const char* classPath, const char* javaLibPath)
+{
+  memset(&args, 0, sizeof(args));
+  jint r;
+  jint nOptions = NO_OF_JVM_OPTIONS;
+
+  std::string classpathOption;
+  std::ostringstream os;
+  os << "-Djava.class.path=" << classPath;
+  classpathOption = os.str();
+  classPathOption = new char[classpathOption.size() + 1];
+  memset(classPathOption, 0, sizeof(char) * (classpathOption.size() + 1));
+  memcpy(classPathOption, classpathOption.c_str(), classpathOption.size() * sizeof(char));
+
+  std::string lAwtArgStr = "-Djava.awt.headless=true";
+  awtOption = new char[lAwtArgStr.size() + 1];
+  memset(awtOption, 0, sizeof(char) * (lAwtArgStr.size() + 1));
+  memcpy(awtOption, lAwtArgStr.c_str(), sizeof(char) * lAwtArgStr.size());
+  awtOption[lAwtArgStr.size()] = 0;
+
+  // javaLibPath are only base pathes, the full path will be computed at runtime in the Java class
+  std::string jlpStr = "-Djava.library.path=" + std::string(javaLibPath);
+  jlpOption = new char[jlpStr.size() + 1];
+  memset(jlpOption, 0, sizeof(char) * (jlpStr.size() + 1));
+  memcpy(jlpOption, jlpStr.c_str(), sizeof(char) * jlpStr.size());
+  jlpOption[jlpStr.size()] = 0;
+
+  options[0].optionString = classPathOption;
+  options[0].extraInfo = NULL;
+  options[1].optionString = awtOption;
+  options[1].extraInfo = NULL;
+  options[2].optionString = jlpOption;
+  options[2].extraInfo = NULL;
+
+  memset(&args, 0, sizeof(args));
+  args.version  = JNI_VERSION_1_2;
+  args.nOptions = nOptions;
+  args.options  = options;
+  args.ignoreUnrecognized = JNI_FALSE;
+
+  r = JNI_CreateJavaVM(&m_vm, (void **)&m_env, &args);
+  if (r != JNI_OK) {
+    throw VMOpenException();
+  }
+}
+
+JavaVMSingleton::~JavaVMSingleton()
+{
+  if (instance) {
+    delete instance;
+    instance = NULL;
+  }
+  m_vm->DestroyJavaVM();
+  if (awtOption)
+    delete[] awtOption;
+  if (classPathOption)
+    delete[] classPathOption;
+}
+
+/*JavaVMSingleton* JavaVMSingleton::getInstance(const char* classPath)
+{
+  return getInstance(classPath, "");
+}*/
+
+JavaVMSingleton* JavaVMSingleton::getInstance(const char* classPath, const char* javaLibPath)
+{
+//#ifdef WIN32
+//  // If pointer to instance of JavaVMSingleton exists (true) then return instance pointer else look for
+//  // instance pointer in memory mapped pointer. If the instance pointer does not exist in
+//  // memory mapped pointer, return a newly created pointer to an instance of Abc.
+
+//  return instance ?
+//     instance : (instance = (JavaVMSingleton*) MemoryMappedPointers::getPointer("JavaVMSingleton")) ?
+//     instance : (instance = (JavaVMSingleton*) MemoryMappedPointers::createEntry("JavaVMSingleton",(void*)new JavaVMSingleton(classPath)));
+//#else
+
+
+  // If pointer to instance of JavaVMSingleton exists (true) then return instance pointer
+  // else return a newly created pointer to an instance of JavaVMSingleton.
+  if (instance == NULL)
+  {
+    JavaVM *jvms;
+    jsize nVMs;
+    if ( JNI_GetCreatedJavaVMs(&jvms, 1, &nVMs)==0 )
+    {
+      //std::cout << "Got JVMs " << nVMs << "\n"; std::cout.flush();
+      if (nVMs == 1)
+      {
+        JavaVM *jvm = jvms;
+        JNIEnv *env;
+        if( jvm->AttachCurrentThread((void **)&env, NULL) ==0 )
+        {
+          // if there is a jvm opened already by a diffrent dynamic lib
+          // make a singleton for this lib with that jvm
+          instance = new JavaVMSingleton(jvm, env);
+        }
+      }
+    }
+
+    if (instance == NULL)
+    {
+      instance = new JavaVMSingleton(classPath, javaLibPath);
+    }
+  }
+
+  return instance;
+}
+
+
+
+JavaVMSingleton* JavaVMSingleton::getInstance(const zorba::StaticContext* aStaticContext)
+{
+  if (instance == NULL)
+  {
+    String cp = computeClassPath(aStaticContext);
+    String lp = computeLibPath(aStaticContext);
+    return getInstance(cp.c_str(), lp.c_str());
+  }
+
+  return instance;
+}
+
+JavaVM* JavaVMSingleton::getVM()
+{
+  return m_vm;
+}
+
+JNIEnv* JavaVMSingleton::getEnv()
+{
+  return m_env;
+}
+
+
+String JavaVMSingleton::computeClassPath(const zorba::StaticContext* aStaticContext)
+{
+  String cp;
+
+  // get classpath from global Properties
+  PropertiesGlobal * properties = Zorba::getInstance(NULL)->getPropertiesGlobal();
+  std::string globalClassPath;
+  properties->getJVMClassPath(globalClassPath);
+  cp += globalClassPath;
+
+  std::vector<String> lCPV;
+  aStaticContext->getFullLibPath(lCPV);
+
+  String pathSeparator(filesystem_path::get_path_separator());
+  String dirSeparator(filesystem_path::get_directory_separator());
+
+  for (std::vector<String>::iterator lIter = lCPV.begin();
+       lIter != lCPV.end(); ++lIter)
+  {
+    // verify it contains a jars dir
+    const filesystem_path baseFsPath((*lIter).str());
+    const filesystem_path jarsFsPath(std::string("jars"));
+    filesystem_path jarsDirPath(baseFsPath, jarsFsPath);
+
+    file jarsDir(jarsDirPath);
+
+    if ( jarsDir.exists() && jarsDir.is_directory())
+    {
+      std::vector<std::string> list;
+      jarsDir.lsdir(list);
+
+      for (std::vector<std::string>::iterator itemIter = list.begin();
+           itemIter != list.end(); ++itemIter)
+      {
+        filesystem_path itemLocalFS(*itemIter);
+        filesystem_path itemFS(jarsDirPath, itemLocalFS);
+        file itemFile(itemFS);
+        if ( itemFile.exists() && itemFile.is_file() )
+        {
+          std::string itemName = itemFile.get_path();
+          std::string suffix = "-classpath.txt";
+          size_t found;
+          found = itemName.rfind(suffix);
+          if (found!=std::string::npos &&
+              found + suffix.length() == itemName.length() )
+          {
+            std::auto_ptr<std::istream> pathFile;
+            pathFile.reset(new std::ifstream (itemName.c_str ()));
+            if (!pathFile->good() || pathFile->eof() )
+            {
+              std::cerr << "file {" << itemName << "} not found or not readable." << std::endl;
+              throw itemName;
+            }
+
+            // read file
+            char line[1024];
+            while( !pathFile->eof() && !pathFile->bad() && !pathFile->fail())
+            {
+              pathFile->getline(line, sizeof(line));
+              std::string lineStr(line);
+
+              if ( lineStr.size() == 0 )
+                continue;
+
+              const std::string normalizedPath =
+                  filesystem_path::normalize_path( lineStr, jarsDirPath.get_path());
+
+              cp += pathSeparator + normalizedPath;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  properties->setJVMClassPath(cp.str());
+
+  return cp;
+}
+
+
+String JavaVMSingleton::computeLibPath(const zorba::StaticContext* aStaticContext)
+{
+  String lp;
+  std::vector<String> lCPV;
+  String pathSeparator(filesystem_path::get_path_separator());
+
+  aStaticContext->getFullLibPath(lCPV);
+  for (std::vector<String>::iterator lIter = lCPV.begin();
+       lIter != lCPV.end(); ++lIter)
+  {
+    String p = *lIter;
+    lp += pathSeparator + p;
+  }
+
+  return lp;
+}
+
+
+}} // namespace zorba, jvm

=== added directory 'modules/util-jvm/config'
=== added file 'modules/util-jvm/config/CMakeLists.txt'
--- modules/util-jvm/config/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ modules/util-jvm/config/CMakeLists.txt	2013-05-03 09:36:26 +0000
@@ -0,0 +1,44 @@
+# Copyright 2006-2012 The FLWOR Foundation.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# We need to be able to install util-jvm and then build module projects
+# against that. The "auto-config" approach Zorba provides does not
+# support this, so we roll our own here. This should probably be
+# re-thought in the future.
+
+IF (WIN32)
+  SET (UTILJVM_CMAKE_DIR "cmake" CACHE STRING
+    "Relative path to CMake files in util-jvm installation")
+ELSE (WIN32)
+  SET(UTILJVM_CMAKE_DIR "share/cmake/zorba_util-jvm_module" CACHE STRING
+    "Relative path to CMake files in util-jvm installation")
+ENDIF (WIN32)
+
+
+# First, install the Use file. Doesn't need to be configured since it
+# just contains a macro.
+INSTALL (FILES UtilJavaUse.cmake DESTINATION "${UTILJVM_CMAKE_DIR}")
+
+# Anyway, we set all the same variables to what they should be in the 
+# install image, and re-config Zorba's ExternalModuleConfig.cmake.in.
+SET (ZORBA_PROJECT_INCLUDE_DIRS "${CMAKE_INSTALL_PREFIX}/include")
+SET (ZORBA_PROJECT_USE_FILE "${CMAKE_INSTALL_PREFIX}/${UTILJVM_CMAKE_DIR}/UtilJavaUse.cmake")
+GET_TARGET_PROPERTY(_libpath util-jvm LOCATION)
+GET_FILENAME_COMPONENT(_libname "${_libpath}"  NAME)
+SET (ZORBA_PROJECT_LIBRARIES "${CMAKE_INSTALL_PREFIX}/lib/${_libname}")
+
+CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/ExternalModuleConfig.cmake.in"
+  "${PROJECT_BINARY_DIR}/install/zorba_util-jvm_moduleConfig.cmake" @ONLY)
+INSTALL(FILES "${PROJECT_BINARY_DIR}/install/zorba_util-jvm_moduleConfig.cmake"
+  DESTINATION "${UTILJVM_CMAKE_DIR}")

=== added file 'modules/util-jvm/config/ExternalModuleConfig.cmake.in'
--- modules/util-jvm/config/ExternalModuleConfig.cmake.in	1970-01-01 00:00:00 +0000
+++ modules/util-jvm/config/ExternalModuleConfig.cmake.in	2013-05-03 09:36:26 +0000
@@ -0,0 +1,40 @@
+# Copyright 2006-2010 The FLWOR Foundation.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+IF (WIN32)
+  SET (PATH_SEP ",")
+ELSE (WIN32)
+  SET (PATH_SEP ":")
+ENDIF (WIN32)
+
+# Probably should have separate URI and LIB paths here someday; will
+# require testdriver to accept --uri-path and --lib-path args
+# Note that this path is meaningless if the module is installed; see
+# bug 966999.
+SET (DEPENDENCY_MODULE_PATH 
+  "${DEPENDENCY_MODULE_PATH}${PATH_SEP}@PROJECT_BINARY_DIR@/URI_PATH/${PATH_SEP}${DEPENDENCY_LIB_PATH}${PATH_SEP}@PROJECT_BINARY_DIR@/LIB_PATH/")
+
+# Dynamic libraries created by this project to link against
+SET (zorba_util-jvm_module_LIBRARIES @ZORBA_PROJECT_LIBRARIES@ @ZORBA_MODULE_LIBRARIES@)
+
+# Include directories exported by this project
+SET (zorba_util-jvm_module_INCLUDE_DIRS @ZORBA_PROJECT_INCLUDE_DIRS@)
+
+# Offer a "use file" to the user of this module. For most module
+# packages, this is unnecessary. However it can be utilized by
+# advanced packages which wish to, for example, export a C++ header
+# file to dependent packages. As above, note that this currently is
+# non-functional if this module package is installed; this will only
+# work from a project build directory.
+SET (zorba_util-jvm_module_USE_FILE "@ZORBA_PROJECT_USE_FILE@")

=== added file 'modules/util-jvm/config/UtilJavaUse.cmake'
--- modules/util-jvm/config/UtilJavaUse.cmake	1970-01-01 00:00:00 +0000
+++ modules/util-jvm/config/UtilJavaUse.cmake	2013-05-03 09:36:26 +0000
@@ -0,0 +1,129 @@
+# Copyright 2006-2010 The FLWOR Foundation.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Macro to find a Jar file whose filename possibly includes a version
+# number. Some Apache distributions, such as FOP, include dependent jars
+# with version numbers, and CMake's FIND_FILE() doesn't support glob
+# patterns for the filename. This macro will find .jar files with optional
+# patterns like "-1.0" in the basename.
+#
+# This macro operates the similarly to FIND_FILE(), except it only supports
+# NAMES, PATHS, PATH_SUFFIXES, DOC, and NO_CMAKE_PATH. Other differences:
+#   1. NAMES is required, and it should be passed the basename of the
+#     jarfiles without the version number or ".jar" extension.
+#   2. The only search directories will be those on CMAKE_PREFIX_PATH and
+#     those specified by PATHS.
+#
+# For example:
+#  ZORBA_FIND_JAR (FOP_JAR NAMES fop PATHS ${XSL_FOP_HOME} PATH_SUFFIXES build)
+#
+# will find fop.jar, fop-1.0.jar, or fop-23453.1234.jar, in any directory
+# on CMAKE_PREFIX_PATH or in XSL_FOP_HOME, or in any subdirectory named
+# "build" of any of those directories.
+#
+# For the moment this macro does not check the version number or enforce
+# a particular/minimum version.
+MACRO (ZORBA_FIND_JAR JARVARNAME)
+  IF (NOT COMMAND PARSE_ARGUMENTS)
+    MESSAGE (FATAL_ERROR
+      "Please INCLUDE(\${Zorba_USE_FILE}) file "
+      "prior to calling ZORBA_FIND_JAR().")
+  ENDIF (NOT COMMAND PARSE_ARGUMENTS)
+
+  PARSE_ARGUMENTS (ZFINDJAR "PATHS;NAMES;PATH_SUFFIXES" "DOC"
+    "NO_CMAKE_PATH" ${ARGN})
+
+  IF (NOT ZFINDJAR_NAMES)
+    MESSAGE (FATAL_ERROR "'NAMES' argument is required for ZORBA_FIND_JAR")
+  ENDIF (NOT ZFINDJAR_NAMES)
+
+  # If the value is already cached, don't do anything
+  IF (NOT ${JARVARNAME})
+
+    # Form up the set of directories to search in.
+    SET (_paths)
+    IF (NOT ZFINDJAR_NO_CMAKE_PATH)
+      SET (_paths ${CMAKE_PREFIX_PATH})
+    ENDIF (NOT ZFINDJAR_NO_CMAKE_PATH)
+    IF (ZFINDJAR_PATHS)
+      LIST (APPEND _paths ${ZFINDJAR_PATHS})
+    ENDIF (ZFINDJAR_PATHS)
+    IF (NOT _paths)
+      MESSAGE (WARNING "No place to search for ${ZFINDJAR_NAMES} jars! "
+	"Set either CMAKE_PREFIX_PATH or pass PATHS")
+    ENDIF (NOT _paths)
+
+    # Iterate through each directory looking for each filename
+    SET (_jarpath "${JARVARNAME}-NOTFOUND")
+    FOREACH (_path ${_paths})
+      IF (_jarpath)
+	BREAK ()
+      ENDIF (_jarpath)
+
+      # Iterate through each potential jarname
+      FOREACH (_name ${ZFINDJAR_NAMES})
+	IF (_jarpath)
+	  BREAK ()
+	ENDIF (_jarpath)
+
+	# Iterate through current directory and each suffix
+	FOREACH (_dir "" ${ZFINDJAR_PATH_SUFFIXES})
+	  # Form up the final full path
+	  IF (_dir)
+	    SET (_path2 "${_path}/${_dir}")
+	  ELSE (_dir)
+	    SET (_path2 "${_path}")
+	  ENDIF (_dir)
+
+	  # First see if the exact filename exists
+	  IF (EXISTS "${_path2}/${_name}.jar")
+	    SET (_jarpath "${_path2}/${_name}.jar")
+	    BREAK ()
+	  ENDIF (EXISTS "${_path2}/${_name}.jar")
+
+	  # Finally, glob for version variants
+	  FILE (GLOB _jarfiles "${_path2}/${_name}-*.jar")
+	  IF (_jarfiles)
+	    LIST (GET _jarfiles 0 _jarpath)
+	    BREAK ()
+	  ENDIF (_jarfiles)
+
+	ENDFOREACH (_dir)
+      ENDFOREACH (_name)
+    ENDFOREACH (_path)
+
+    # Cache the results
+    SET (${JARVARNAME} "${_jarpath}" CACHE PATH "${ZFINDJAR_DOC}" FORCE)
+
+  ENDIF (NOT ${JARVARNAME})
+
+ENDMACRO (ZORBA_FIND_JAR)
+
+MACRO (ZORBA_FIND_JNI)
+  IF (UNIX AND NOT APPLE)
+    # setting JAVA_HOME to bypass issues in FindJNI.cmake  
+    FIND_FILE(_JAVA_BIN_LOC NAMES java PATHS ENV PATH)
+    IF (_JAVA_BIN_LOC)
+      GET_FILENAME_COMPONENT(_JAVA_BIN_LOC "${_JAVA_BIN_LOC}" REALPATH) 
+      GET_FILENAME_COMPONENT(_JAVA_BIN_DIR ${_JAVA_BIN_LOC} PATH)
+      GET_FILENAME_COMPONENT(_JAVA_HOME "${_JAVA_BIN_DIR}/../.." ABSOLUTE)
+      MESSAGE(
+        STATUS "Generated JAVA_HOME to support FindJNI.cmake: " 
+        ${_JAVA_HOME})
+      SET(ENV{JAVA_HOME} ${_JAVA_HOME})
+    ENDIF()
+  ENDIF()
+
+  FIND_PACKAGE(JNI)
+ENDMACRO (ZORBA_FIND_JNI)

=== added directory 'modules/util-jvm/include'
=== added file 'modules/util-jvm/include/JavaVMSingleton.h'
--- modules/util-jvm/include/JavaVMSingleton.h	1970-01-01 00:00:00 +0000
+++ modules/util-jvm/include/JavaVMSingleton.h	2013-05-03 09:36:26 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JAVA_VM_SINGLETON
+#define JAVA_VM_SINGLETON
+
+#include <jni.h>
+#include <zorba/static_context.h>
+
+# if defined WIN32 || defined CYGWIN
+#   ifdef util_jvm_EXPORTS
+#     ifdef __GNUC__
+#       define UTIL_JVM_DLL_PUBLIC __attribute__((dllexport))
+#     else
+#       define UTIL_JVM_DLL_PUBLIC __declspec(dllexport)
+#     endif /* __GNUC__ */
+#   else /* util_jvm_EXPORTS */
+#     ifdef __GNUC__
+#       define UTIL_JVM_DLL_PUBLIC __attribute__((dllimport))
+#     else
+#       define UTIL_JVM_DLL_PUBLIC __declspec(dllimport)
+#     endif /* __GNUC__ */
+#   endif /* util_jvm_EXPORTS */
+# else
+#   if __GNUC__ >= 4
+#     define UTIL_JVM_DLL_PUBLIC __attribute__ ((visibility("default")))
+#   else
+#     define UTIL_JVM_DLL_PUBLIC
+#   endif
+# endif
+
+namespace zorba { namespace jvm {
+
+#define NO_OF_JVM_OPTIONS 3
+
+
+class VMOpenException {};
+
+class UTIL_JVM_DLL_PUBLIC JavaVMSingleton
+{
+public:
+  //static JavaVMSingleton* getInstance(const char* classPath);
+  static JavaVMSingleton* getInstance(const char* classPath, const char* javaLibPath);
+  static JavaVMSingleton* getInstance(const zorba::StaticContext* aStaticContext);
+
+  virtual ~JavaVMSingleton();
+  JavaVM* getVM();
+  JNIEnv* getEnv();
+
+protected:
+  JavaVMSingleton(const char* classPath, const char* javaLibPath);
+  JavaVMSingleton(JavaVM *jvm, JNIEnv *env) : m_vm(jvm), m_env(env) {}
+  static String computeClassPath(const zorba::StaticContext* aStaticContext);
+  static String computeLibPath(const zorba::StaticContext* aStaticContext);
+
+  static JavaVMSingleton* instance;
+  JavaVM* m_vm;
+  JNIEnv* m_env;
+  JavaVMInitArgs args;
+  JavaVMOption options[NO_OF_JVM_OPTIONS];
+
+  char* classPathOption;
+  char* awtOption;
+  char* jlpOption;
+};
+
+
+}} //namespace zorba, jvm
+
+#endif // JAVA_VM_SINGLETON
+
+
+
+

=== added file 'modules/util-jvm/util-jvm.cpp'
--- modules/util-jvm/util-jvm.cpp	1970-01-01 00:00:00 +0000
+++ modules/util-jvm/util-jvm.cpp	2013-05-03 09:36:26 +0000
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <sstream>
+#include <iostream>
+#include <cstdlib>
+#include <list>
+
+#include <zorba/base64.h>
+#include <zorba/empty_sequence.h>
+#include <zorba/diagnostic_list.h>
+#include <zorba/function.h>
+#include <zorba/external_module.h>
+#include <zorba/user_exception.h>
+#include <zorba/file.h>
+#include <zorba/item_factory.h>
+#include <zorba/serializer.h>
+#include <zorba/singleton_item_sequence.h>
+#include <zorba/vector_item_sequence.h>
+#include <zorba/zorba.h>
+
+#include "JavaVMSingleton.h"
+
+#define UTILJVM_MODULE_NAMESPACE "http://www.zorba-xquery.com/modules/util-jvm"
+#define UTILJVM_OPTIONS_NAMESPACE "http://www.zorba-xquery.com/modules/util-jvm/util-jvm-options"
+
+class JavaException {
+};
+
+#define CHECK_EXCEPTION(env)  if ((lException = env->ExceptionOccurred())) throw JavaException()
+
+namespace zorba
+{
+  namespace utiljvm
+  {
+
+    class UtilJvmModule;
+
+    class UtilJvmModule : public ExternalModule {
+    private:
+
+    public:
+      UtilJvmModule() {}
+
+      virtual ~UtilJvmModule()
+      {}
+
+      virtual String getURI() const
+      {
+	return UTILJVM_MODULE_NAMESPACE;
+      }
+
+      virtual ExternalFunction*
+      getExternalFunction(const String& localName);
+
+      virtual void destroy()
+      {
+	delete this;
+      }
+    };
+
+
+    ExternalFunction*
+    UtilJvmModule::getExternalFunction(const String& localName)
+    {
+      return 0;
+    }
+
+  }}; // namespace zorba, utiljvm
+
+#ifdef WIN32
+#  define DLL_EXPORT __declspec(dllexport)
+#else
+#  define DLL_EXPORT __attribute__ ((visibility("default")))
+#endif
+
+extern "C" DLL_EXPORT zorba::ExternalModule* createModule()
+{
+  return new zorba::utiljvm::UtilJvmModule();
+}

=== added file 'modules/util-jvm/util-jvm.xq'
--- modules/util-jvm/util-jvm.xq	1970-01-01 00:00:00 +0000
+++ modules/util-jvm/util-jvm.xq	2013-05-03 09:36:26 +0000
@@ -0,0 +1,40 @@
+xquery version "1.0";
+
+(:
+ : Copyright 2006-2009 The FLWOR Foundation.
+ :
+ : Licensed under the Apache License, Version 2.0 (the "License");
+ : you may not use this file except in compliance with the License.
+ : You may obtain a copy of the License at
+ :
+ : http://www.apache.org/licenses/LICENSE-2.0
+ :
+ : Unless required by applicable law or agreed to in writing, software
+ : distributed under the License is distributed on an "AS IS" BASIS,
+ : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ : See the License for the specific language governing permissions and
+ : limitations under the License.
+ :)
+
+(:~
+ : This module provides common functionality for modules that use java
+ : implementations. 
+ : <br/>
+ : <br/>
+ : Modules using java implementations must import this module 
+ : to specify the dependency.
+ : <br />
+ : <br />
+ : <b>Note:</b> Since this module has a Java library dependency a JVM is required
+ : to be installed on the system. For Windows: jvm.dll is required on the system
+ : path (usually located in "C:\Program Files\Java\jre\bin\client").
+ :
+ : @author Cezar Andrei
+ : @library <a href="http://www.oracle.com/technetwork/java/javase/downloads/index.html">JDK - Java Development Kit</a>
+ : @project utils/util jvm
+ :)
+module namespace util-jvm = "http://www.zorba-xquery.com/modules/util-jvm";
+
+declare namespace ver = "http://www.zorba-xquery.com/options/versioning";
+declare option ver:module-version "1.0";
+