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 : [email protected] Unsubscribe : https://launchpad.net/~zorba-coders More help : https://help.launchpad.net/ListHelp
