Chris Hillery has proposed merging lp:~zorba-coders/zorba/util-jvm_core_module 
into lp:zorba.

Requested reviews:
  Chris Hillery (ceejatec)
  Cezar Andrei (cezar-andrei)

For more details, see:
https://code.launchpad.net/~zorba-coders/zorba/util-jvm_core_module/+merge/161854

Moves the util-jvm module into the core.
-- 
https://code.launchpad.net/~zorba-coders/zorba/util-jvm_core_module/+merge/161854
Your team Zorba Coders is subscribed to branch lp:zorba.
=== modified file 'modules/CMakeLists.txt'
--- modules/CMakeLists.txt	2013-02-07 17:24:36 +0000
+++ modules/CMakeLists.txt	2013-05-01 15:42:31 +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-01 15:42:31 +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-01 15:42:31 +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-01 15:42:31 +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-01 15:42:31 +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-01 15:42:31 +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-01 15:42:31 +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-01 15:42:31 +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-01 15:42:31 +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";
+

-- 
Mailing list: https://launchpad.net/~zorba-coders
Post to     : zorba-coders@lists.launchpad.net
Unsubscribe : https://launchpad.net/~zorba-coders
More help   : https://help.launchpad.net/ListHelp

Reply via email to