| /** \file internal_jedii_engine.cpp . |
| ----------------------------------------------------------------------------- |
| |
| |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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. |
| |
| ----------------------------------------------------------------------------- |
| |
| Description: |
| |
| ----------------------------------------------------------------------------- |
| |
| |
| -------------------------------------------------------------------------- */ |
| |
| //#define DEBUG_VERBOSE |
| /* ----------------------------------------------------------------------- */ |
| /* Include dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| #include "uima/pragmas.hpp" |
| |
| #include "uima/trace.hpp" |
| #include "uima/envvar.hpp" |
| #include "uima/macros.h" |
| #include "uima/macros.h" |
| |
| #include "uima/stltools.hpp" |
| #include "uima/msg.h" |
| #include "uima/internal_jedii_engine.hpp" |
| #include "uima/internal_casserializer.hpp" |
| #include "uima/internal_casdeserializer.hpp" |
| #include "uima/annotator_context.hpp" |
| #include "uima/resmgr.hpp" |
| /* ----------------------------------------------------------------------- */ |
| /* Constants */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Forward declarations */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Types / Classes */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* |
| There's a lot of JNI code in here. If you are interested in the details you should |
| consult some book or go to |
| http://java.sun.com/j2se/1.3/docs/guide/jni/spec/jniTOC.doc.html |
| */ |
| using namespace std; |
| namespace uima { |
| namespace internal { |
| |
| UIMA_EXC_CLASSIMPLEMENT(JavaException, Exception); |
| |
| #define USED_JAVA_VERSION JNI_VERSION_1_2 |
| |
| // not NLS enabled !!!!!!! |
| icu::UnicodeString javaErrorToString(jint res) { |
| switch (res) { |
| case JNI_OK: |
| return "no error"; |
| case JNI_ERR: |
| return "unknown error"; |
| case JNI_EDETACHED: |
| return "thread detached from the VM"; |
| case JNI_EVERSION: |
| return "JNI version error"; |
| case JNI_ENOMEM: |
| return "not enough memory"; |
| case JNI_EEXIST: |
| return "VM already created"; |
| case JNI_EINVAL: |
| return "invalid arguments"; |
| default: |
| char buf[2056]; |
| sprintf(buf, "%d", res); |
| return icu::UnicodeString(buf); |
| } |
| } |
| |
| JEDIIEngine::JEDIIEngine(AnnotatorContext & anc, bool bOwnsANC, |
| bool bOwnsTAESpecififer, uima::internal::CASDefinition & casdef, bool ownsCasDef) |
| : EngineBase(anc, bOwnsANC, bOwnsTAESpecififer, casdef, ownsCasDef), |
| iv_vm(NULL), |
| iv_env(NULL), |
| iv_obj(NULL), |
| iv_createdVM(false), |
| iv_initializeMethod(NULL), |
| iv_processMethod(NULL), |
| iv_destroyMethod(NULL), |
| iv_getLastExceptionStringMethod(NULL), |
| iv_getHeapMethod(NULL), |
| iv_getIndexedFSsMethod(NULL), |
| iv_getStringTableMethod(NULL), |
| iv_getVersionMethod(NULL), |
| iv_isPrimitive(0), |
| iv_JVMDllLoader(NULL), |
| iv_createJavaVMFunc(NULL), |
| iv_getCreatedJavaVMsFunc(NULL) { |
| } |
| |
| |
| JEDIIEngine::~JEDIIEngine() { |
| destroyIfNeeded(); |
| } |
| |
| |
| void JEDIIEngine::checkForUnexpectedJNIException() { |
| jthrowable exc = iv_env->ExceptionOccurred(); |
| if (exc != NULL) { |
| #ifndef NDEBUG |
| iv_env->ExceptionDescribe(); |
| #endif |
| // if exception was thrown, get class name of exception plus the message |
| // and throw a C++ exception |
| |
| // don't check for JNI exceptions in these calls because exception is already thrown |
| jclass throwableClass = iv_env->FindClass("java/lang/Throwable"); |
| jmethodID getClassID = iv_env->GetMethodID(throwableClass, "getClass", "()Ljava/lang/Class;"); |
| assert( getClassID != NULL); |
| jclass classClass = iv_env->FindClass("java/lang/Class"); |
| assert( classClass != NULL); |
| jmethodID getNameID = iv_env->GetMethodID(classClass, "getName", "()Ljava/lang/String;"); |
| assert( getNameID != NULL ); |
| jobject classObject = iv_env->CallObjectMethod(exc, getClassID); |
| assert ( classObject != NULL ); |
| jstring msg = (jstring) iv_env->CallObjectMethod(classObject, getNameID); |
| jboolean copied; |
| jchar const * jc = iv_env->GetStringChars(msg, &copied); |
| assert( jc != NULL ); |
| size_t len = iv_env->GetStringLength(msg); |
| icu::UnicodeString usMsg((UChar const *)jc, len); |
| iv_env->ReleaseStringChars(msg, jc); |
| // msg now contains the class name |
| |
| // add getMessage() of the throwable |
| assert( throwableClass != NULL ); |
| jmethodID getMessageID = iv_env->GetMethodID(throwableClass, "getMessage", "()Ljava/lang/String;"); |
| assert ( getMessageID != NULL ); |
| msg = (jstring) iv_env->CallObjectMethod(exc, getMessageID); |
| if ( msg != NULL ) { |
| usMsg.append(": "); |
| jc = iv_env->GetStringChars(msg, &copied); |
| len = iv_env->GetStringLength(msg); |
| usMsg.append( icu::UnicodeString((UChar const *)jc, len) ); |
| iv_env->ReleaseStringChars(msg, jc); |
| } |
| |
| UIMA_EXC_THROW_NEW(JavaException, |
| UIMA_ERR_JAVA_EXCEPTION, |
| ErrorMessage(UIMA_MSG_ID_EXC_UNKNOWN_JAVA_EXCEPTION, usMsg), |
| UIMA_MSG_ID_EXCON_PROCESSING_JAVA_TAE, |
| ErrorInfo::unrecoverable); |
| } |
| } |
| |
| |
| // create a new Java int[] from a C++ vector |
| jintArray JEDIIEngine::createJIntArray(vector<internal::SerializedCAS::TyNum> const & v) { |
| jintArray result = iv_env->NewIntArray(v.size()); |
| checkForUnexpectedJNIException(); |
| size_t i; |
| for (i=0; i<v.size(); ++i) { |
| jint n = v[i]; |
| iv_env->SetIntArrayRegion(result, i,1, &n ); |
| checkForUnexpectedJNIException(); |
| #ifndef NDEBUG |
| jint m; |
| iv_env->GetIntArrayRegion(result, i, 1, &m ); |
| checkForUnexpectedJNIException(); |
| assert( n == m ); |
| #endif |
| } |
| return result; |
| } |
| |
| // create a new Java byte[] from a C++ vector |
| jbyteArray JEDIIEngine::createJByteArray(vector<char> const & v) { |
| jbyteArray result = iv_env->NewByteArray(v.size()); |
| checkForUnexpectedJNIException(); |
| size_t i; |
| for (i=0; i<v.size(); ++i) { |
| jbyte n = v[i]; |
| iv_env->SetByteArrayRegion(result, i,1, &n ); |
| checkForUnexpectedJNIException(); |
| #ifndef NDEBUG |
| jbyte m; |
| iv_env->GetByteArrayRegion(result, i, 1, &m ); |
| checkForUnexpectedJNIException(); |
| assert( n == m ); |
| #endif |
| } |
| return result; |
| } |
| |
| // create a new Java short[] from a C++ vector |
| jshortArray JEDIIEngine::createJShortArray(vector<short> const & v) { |
| jshortArray result = iv_env->NewShortArray(v.size()); |
| checkForUnexpectedJNIException(); |
| size_t i; |
| for (i=0; i<v.size(); ++i) { |
| jshort n = v[i]; |
| iv_env->SetShortArrayRegion(result, i,1, &n ); |
| checkForUnexpectedJNIException(); |
| #ifndef NDEBUG |
| jshort m; |
| iv_env->GetShortArrayRegion(result, i, 1, &m ); |
| checkForUnexpectedJNIException(); |
| assert( n == m ); |
| #endif |
| } |
| return result; |
| } |
| |
| // create a new Java long[] from a C++ vector |
| jlongArray JEDIIEngine::createJLongArray(vector<INT64> const & v) { |
| jlongArray result = iv_env->NewLongArray(v.size()); |
| checkForUnexpectedJNIException(); |
| size_t i; |
| for (i=0; i<v.size(); ++i) { |
| jlong n = v[i]; |
| iv_env->SetLongArrayRegion(result, i,1, &n ); |
| checkForUnexpectedJNIException(); |
| #ifndef NDEBUG |
| jlong m; |
| iv_env->GetLongArrayRegion(result, i, 1, &m ); |
| checkForUnexpectedJNIException(); |
| assert( n == m ); |
| #endif |
| } |
| return result; |
| } |
| |
| |
| |
| // create a new Object[] (which all contains java.lang.Strings) from a C++ vector |
| jobjectArray JEDIIEngine::createJStringArray(vector<UnicodeStringRef> const & v) { |
| jclass stringClass = iv_env->FindClass("java/lang/String"); |
| checkForUnexpectedJNIException(); |
| jobjectArray result = iv_env->NewObjectArray(v.size(), stringClass, NULL); |
| checkForUnexpectedJNIException(); |
| size_t i; |
| for (i=0; i<v.size(); ++i) { |
| assertWithMsg(sizeof(UChar) == sizeof(jchar), "Port required"); |
| jstring str = iv_env->NewString( (const jchar*)v[i].getBuffer(), v[i].length() ); |
| checkForUnexpectedJNIException(); |
| iv_env->SetObjectArrayElement(result, i, str); |
| checkForUnexpectedJNIException(); |
| } |
| return result; |
| } |
| |
| // create a java.lang.String from a C++ unicode string |
| jstring JEDIIEngine::createJString(UnicodeStringRef const & ref) { |
| assertWithMsg(sizeof(UChar) == sizeof(jchar), "Port required"); |
| jstring result = iv_env->NewString((jchar const *) ref.getBuffer(), ref.length()); |
| checkForUnexpectedJNIException(); |
| return result; |
| } |
| |
| // create a C++ vector from a Java int[] |
| void JEDIIEngine::createIntVector(jintArray ar, vector<internal::SerializedCAS::TyNum>& result) { |
| result.clear(); |
| jsize len = iv_env->GetArrayLength(ar); |
| checkForUnexpectedJNIException(); |
| jint* tempAr = new jint[len]; |
| iv_env->GetIntArrayRegion(ar, 0, len, tempAr); |
| checkForUnexpectedJNIException(); |
| |
| result.reserve(len); |
| int i; |
| for (i=0; i<len; ++i) { |
| result.push_back(tempAr[i]); |
| } |
| |
| delete[] tempAr; |
| } |
| |
| // create a C++ string vector from a java.lang.String[] |
| void JEDIIEngine::createStringVector(jobjectArray ar, vector<UnicodeStringRef>& result, vector<icu::UnicodeString> & pool) { |
| pool.clear(); |
| result.clear(); |
| jsize len = iv_env->GetArrayLength(ar); |
| checkForUnexpectedJNIException(); |
| result.reserve(len); |
| pool.reserve(len); // with this reserve, the vector will never be re-allocated, thus the internal pointer in the UnicodeString objects remain valid throughout this method! |
| int i; |
| for (i=0; i<len; ++i) { |
| jstring js = (jstring) iv_env->GetObjectArrayElement(ar, i); |
| checkForUnexpectedJNIException(); |
| if (js != NULL) { |
| jboolean isCopy; |
| jchar const * jc = iv_env->GetStringChars(js, &isCopy); |
| checkForUnexpectedJNIException(); |
| jsize strLen = iv_env->GetStringLength(js); |
| checkForUnexpectedJNIException(); |
| icu::UnicodeString us((UChar const *) jc, (size_t) strLen); |
| iv_env->ReleaseStringChars(js, jc); |
| checkForUnexpectedJNIException(); |
| pool.push_back(us); |
| |
| icu::UnicodeString const & poolString = pool.back(); |
| UnicodeStringRef uref( poolString.getBuffer(), poolString.length() ); |
| result.push_back(uref); |
| } else { |
| UnicodeStringRef emptyURef; |
| result.push_back(emptyURef); |
| } |
| iv_env->DeleteLocalRef(js); |
| } |
| } |
| |
| // create a C++ vector from a Java byte[] |
| void JEDIIEngine::createByteVector(jbyteArray ar, vector<char>& result) { |
| result.clear(); |
| jsize len = iv_env->GetArrayLength(ar); |
| checkForUnexpectedJNIException(); |
| jbyte* tempAr = new jbyte[len]; |
| iv_env->GetByteArrayRegion(ar, 0, len, tempAr); |
| checkForUnexpectedJNIException(); |
| |
| result.reserve(len); |
| int i; |
| for (i=0; i<len; ++i) { |
| result.push_back(tempAr[i]); |
| } |
| |
| delete[] tempAr; |
| } |
| |
| |
| // create a C++ vector from a Java short[] |
| void JEDIIEngine::createShortVector(jshortArray ar, vector<short>& result) { |
| result.clear(); |
| jsize len = iv_env->GetArrayLength(ar); |
| checkForUnexpectedJNIException(); |
| jshort* tempAr = new jshort[len]; |
| iv_env->GetShortArrayRegion(ar, 0, len, tempAr); |
| checkForUnexpectedJNIException(); |
| |
| result.reserve(len); |
| int i; |
| for (i=0; i<len; ++i) { |
| result.push_back(tempAr[i]); |
| } |
| |
| delete[] tempAr; |
| } |
| |
| // create a C++ vector from a Java short[] |
| void JEDIIEngine::createLongVector(jlongArray ar, vector<long>& result) { |
| result.clear(); |
| jsize len = iv_env->GetArrayLength(ar); |
| checkForUnexpectedJNIException(); |
| jlong* tempAr = new jlong[len]; |
| iv_env->GetLongArrayRegion(ar, 0, len, tempAr); |
| checkForUnexpectedJNIException(); |
| |
| result.reserve(len); |
| int i; |
| for (i=0; i<len; ++i) { |
| result.push_back(tempAr[i]); |
| } |
| |
| delete[] tempAr; |
| } |
| |
| template <class T> |
| void printVector(ostream& os, char const * c, vector<T> const & v) { |
| os << __FILE__ << __LINE__ << ": " << c << endl; |
| size_t i; |
| for (i=0; i<v.size(); ++i) { |
| os << v[i] << " "; |
| } |
| os << endl; |
| } |
| |
| |
| bool JEDIIEngine::isPrimitive() const { |
| assert( iv_isPrimitive == 1 || iv_isPrimitive == 2); |
| if (iv_isPrimitive == 1) { |
| return true; |
| } |
| return false; |
| } |
| |
| |
| void JEDIIEngine::handleEngineProxyError(jint rc) { |
| if (rc != JNI_OK) { |
| // some error occurred in the JEDIIEngine object |
| jobject excStringObj = iv_env->CallObjectMethod(iv_obj, iv_getLastExceptionStringMethod); |
| checkForUnexpectedJNIException(); |
| jstring excString = (jstring) excStringObj; |
| jboolean isCopy; |
| jchar const * jc = iv_env->GetStringChars(excString, &isCopy); |
| checkForUnexpectedJNIException(); |
| jsize js = iv_env->GetStringLength(excString); |
| checkForUnexpectedJNIException(); |
| icu::UnicodeString us((UChar const *) jc, (size_t) js); |
| iv_env->ReleaseStringChars(excString, jc); |
| checkForUnexpectedJNIException(); |
| |
| handleJNIError(rc, us); |
| } |
| } |
| |
| |
| void JEDIIEngine::handleJNIError(jint rc, icu::UnicodeString const & us) { |
| if (rc != JNI_OK) { |
| ErrorMessage msg(UIMA_MSG_ID_EXC_JAVA_EXCEPTION); |
| msg.addParam( javaErrorToString(rc) ); |
| msg.addParam( us); |
| UIMA_EXC_THROW_NEW(JavaException, |
| UIMA_ERR_JAVA_EXCEPTION, |
| msg, |
| UIMA_MSG_ID_EXCON_PROCESSING_JAVA_TAE, |
| ErrorInfo::unrecoverable); |
| } |
| } |
| |
| |
| void JEDIIEngine::handleJNIError(jint rc) { |
| if (rc != JNI_OK) { |
| ErrorMessage msg(UIMA_MSG_ID_EXC_JNI_CALL_FAILED); |
| msg.addParam( javaErrorToString(rc) ); |
| UIMA_EXC_THROW_NEW(JavaException, |
| UIMA_ERR_JAVA_EXCEPTION, |
| msg, |
| UIMA_MSG_ID_EXCON_PROCESSING_JAVA_TAE, |
| ErrorInfo::unrecoverable); |
| } |
| } |
| |
| void JEDIIEngine::initializeJVMFunctions() { |
| /* |
| If we linked against the jvm DLL, the following three lines would do the trick: |
| iv_createJavaVMFunc = (TyCreateJavaVMFunc) JNI_CreateJavaVM; |
| iv_getCreatedJavaVMsFunc = (TyGetCreatedJavaVMsFunc) JNI_GetCreatedJavaVMs; |
| return ; |
| */ |
| // names of the JVM library on the different platforms |
| // (APR should add the appropriate suffix) |
| #if defined(WIN32) |
| #define JVMDLL_FILE_NAME "jvm" |
| #else |
| #define JVMDLL_FILE_NAME "libjvm" |
| #endif |
| |
| // dynamically load jvm DLL |
| util::Filename jvmDll(JVMDLL_FILE_NAME); |
| |
| assert( iv_JVMDllLoader == NULL ); |
| iv_JVMDllLoader = new util::DllProcLoaderFile(jvmDll); |
| assert( EXISTS(iv_JVMDllLoader) ); |
| |
| if (!iv_JVMDllLoader->isValid()) { |
| delete iv_JVMDllLoader; |
| iv_JVMDllLoader = NULL; |
| UIMA_EXC_THROW_NEW(JavaException, |
| UIMA_ERR_COULD_NOT_LOAD_JAVA_DLL, |
| UIMA_MSG_ID_EXC_COULD_NOT_LOAD_JAVA_DLL, |
| UIMA_MSG_ID_EXCON_PROCESSING_JAVA_TAE, |
| ErrorInfo::unrecoverable); |
| } else { |
| // get function pointers |
| iv_createJavaVMFunc = (TyCreateJavaVMFunc) iv_JVMDllLoader->getProcedure( "JNI_CreateJavaVM"); |
| if ( iv_createJavaVMFunc == NULL ) { |
| UIMA_EXC_THROW_NEW(JavaException, |
| UIMA_ERR_COULD_NOT_LOAD_JAVA_DLL, |
| UIMA_MSG_ID_EXC_COULD_NOT_LOAD_JAVA_DLL, |
| UIMA_MSG_ID_EXCON_PROCESSING_JAVA_TAE, |
| ErrorInfo::unrecoverable); |
| |
| } |
| iv_getCreatedJavaVMsFunc = (TyGetCreatedJavaVMsFunc) iv_JVMDllLoader->getProcedure("JNI_GetCreatedJavaVMs"); |
| if ( iv_getCreatedJavaVMsFunc == NULL ) { |
| UIMA_EXC_THROW_NEW(JavaException, |
| UIMA_ERR_COULD_NOT_LOAD_JAVA_DLL, |
| UIMA_MSG_ID_EXC_COULD_NOT_LOAD_JAVA_DLL, |
| UIMA_MSG_ID_EXCON_PROCESSING_JAVA_TAE, |
| ErrorInfo::unrecoverable); |
| } |
| |
| } |
| |
| } |
| |
| void JEDIIEngine::destroyJVMFunctions() { |
| if (iv_JVMDllLoader != NULL) { |
| assert( EXISTS(iv_JVMDllLoader) ); |
| delete iv_JVMDllLoader; |
| iv_createJavaVMFunc = NULL; |
| iv_getCreatedJavaVMsFunc = NULL; |
| } |
| } |
| |
| |
| void JEDIIEngine::initializeJavaVM() { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| |
| JavaVM* vms[1]; |
| vms[0] = NULL; |
| jsize existingVMs = 0; |
| iv_createdVM = false; |
| |
| UIMA_TPRINT("check if VM exists"); |
| assert( EXISTS(iv_getCreatedJavaVMsFunc) ); |
| jint existingVMsRes = (*iv_getCreatedJavaVMsFunc)(vms, 1, & existingVMs); |
| UIMA_TPRINT("JNI return code of getCreatedVMs: " << existingVMsRes); |
| if (existingVMsRes != JNI_OK) { |
| handleJNIError(existingVMsRes); |
| } |
| UIMA_TPRINT("existing VMs: " << existingVMs); |
| |
| // if we don't already run within a Java context |
| if (existingVMs == 0) { |
| UIMA_TPRINT("new VM must be created"); |
| iv_createdVM = true; |
| // get classpath from environment |
| util::EnvironmentVariableQueryOnly envVar("CLASSPATH"); |
| char const * classpath = envVar.getValue(); |
| char const * cpOption = "-Djava.class.path="; |
| char const * emptyString = ""; |
| if (classpath == NULL) { |
| classpath = emptyString; |
| } |
| |
| size_t cpBufLen = strlen(classpath) + strlen(cpOption) + 1; |
| auto_array<char> cpBuf( new char[cpBufLen] ); |
| cpBuf[0] = 0; |
| strcat( strcat(cpBuf.get(), cpOption), classpath ); |
| |
| // create and initialize Java VM |
| char * optionStrings[] = { |
| cpBuf.get(), |
| "-Xmx256MB", |
| #ifndef NDEBUG |
| "-Xcheck:jni", |
| "-Xcheck:nabounds", |
| #endif |
| }; |
| |
| JavaVMInitArgs vmArgs; |
| |
| vmArgs.version = USED_JAVA_VERSION; |
| |
| JavaVMOption options[NUMBEROF(optionStrings)]; |
| size_t i; |
| for (i=0; i<NUMBEROF(optionStrings); ++i) { |
| options[i].optionString = optionStrings[i]; |
| } |
| vmArgs.nOptions = NUMBEROF(optionStrings); |
| vmArgs.options = options; |
| |
| vmArgs.ignoreUnrecognized = JNI_FALSE; |
| |
| UIMA_TPRINT("creating VM"); |
| assert( iv_createJavaVMFunc != NULL); |
| jint vmCreationRes = (*iv_createJavaVMFunc)(& iv_vm, (void **)& iv_env, &vmArgs); |
| UIMA_TPRINT("VM created"); |
| if (vmCreationRes != JNI_OK) { |
| clTrace.dump("Java VM could not be created, return code:", vmCreationRes); |
| iv_vm = NULL; |
| iv_env = NULL; |
| UIMA_EXC_THROW_NEW(JavaException, |
| UIMA_ERR_JAVA_EXCEPTION, |
| ErrorMessage(UIMA_MSG_ID_EXC_JAVA_VM_COULD_NOT_BE_CREATED, javaErrorToString(vmCreationRes)), |
| UIMA_MSG_ID_EXCON_PROCESSING_JAVA_TAE, |
| ErrorInfo::unrecoverable); |
| } |
| UIMA_TPRINT("VM created"); |
| } else { |
| // re-use existing VM |
| UIMA_TPRINT("Using existing VM: " << vms[0]); |
| assert( existingVMsRes == JNI_OK ); |
| assert( existingVMs == 1); |
| |
| jint getenvRes = vms[0]->GetEnv((void**) & iv_env, USED_JAVA_VERSION); |
| handleJNIError(getenvRes); |
| assert( getenvRes == JNI_OK ); |
| iv_vm = vms[0]; |
| } |
| |
| assert( EXISTS(iv_env) ); |
| assert( EXISTS(iv_vm) ); |
| |
| } |
| |
| |
| TyErrorId JEDIIEngine::initializeImpl(AnalysisEngineDescription const & specifier) { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| |
| UIMA_TPRINT("initializing JVM DLL"); |
| initializeJVMFunctions(); |
| UIMA_TPRINT("JVM DLL loaded"); |
| |
| assert( iv_createJavaVMFunc != NULL ); |
| assert( iv_getCreatedJavaVMsFunc != NULL ); |
| |
| if (specifier.isPrimitive()) { |
| iv_isPrimitive = 1; |
| } else { |
| iv_isPrimitive = 2; |
| } |
| |
| icu::UnicodeString config; |
| specifier.toXMLBuffer(config); |
| |
| // ofstream ofs("jedii_tmp_specifier.xml"); ofs << config << endl; ofs.close(); |
| |
| UIMA_TPRINT("Initializing Java VM"); |
| initializeJavaVM(); |
| UIMA_TPRINT("VM initialized"); |
| |
| assert( EXISTS(iv_env) ); |
| assert( EXISTS(iv_vm) ); |
| |
| TyErrorId err = UIMA_ERR_NONE; |
| |
| UIMA_TPRINT("setup VM"); |
| // create Java object and initialize method IDs |
| assert( EXISTS(iv_env) ); |
| jclass clazz = iv_env->FindClass("org/apache/uima/uimacpp/CppUimajEngine"); |
| checkForUnexpectedJNIException(); |
| jmethodID constructor = iv_env->GetMethodID(clazz, "<init>", "()V"); |
| checkForUnexpectedJNIException(); |
| |
| iv_initializeMethod = iv_env->GetMethodID(clazz, "initialize", "(" |
| "Ljava/lang/String;" // config, |
| "Ljava/lang/String;" // datapath |
| "[I" // typeInheritance |
| "[I" // typePriorities |
| "[I" // featureDefs |
| "[I" // featureOffset |
| "[Ljava/lang/String;" // typeNames |
| "[Ljava/lang/String;" // featureNames |
| "[I" // stringSubTypes |
| "[Ljava/lang/String;" // stringSubTypeValues |
| "[I" // stringSubTypeValuePos |
| "[Ljava/lang/String;" // indexIDs |
| "[I" // indexKinds |
| "[I" // compStarts |
| "[I" // compDefs |
| ")I"); |
| checkForUnexpectedJNIException(); |
| |
| //check if UIMA Framework version is compatible |
| iv_getVersionMethod = iv_env->GetStaticMethodID(clazz, "getVersion", "()Ljava/lang/String;"); |
| checkForUnexpectedJNIException(); |
| |
| jobject versionStringObj = iv_env->CallStaticObjectMethod(clazz, iv_getVersionMethod); |
| checkForUnexpectedJNIException(); |
| jstring versionString = (jstring) versionStringObj; |
| const TCHAR ** compatibleVersions = gs_compatibleUIMAVersions; |
| if (versionString != NULL) { |
| cout << versionString << endl; |
| jboolean isCopy; |
| jchar const * jc = iv_env->GetStringChars(versionString, &isCopy); |
| checkForUnexpectedJNIException(); |
| jsize js = iv_env->GetStringLength(versionString); |
| checkForUnexpectedJNIException(); |
| icu::UnicodeString uVersion((UChar const *) jc, (size_t) js); |
| cout << uVersion << endl; |
| bool compatible = false; |
| |
| for (int i=0; i < NUM_COMPATIBLE_UIMA_JAVA_VERSIONS; i++) { |
| if (uVersion.compare(compatibleVersions[i]) == 0) { |
| compatible=true; |
| } |
| } |
| |
| if (!compatible) { |
| ErrorMessage msg = ErrorMessage(UIMA_MSG_ID_INCOMPATIBLE_UIMA_JAVA_VERSION); |
| msg.addParam(uVersion); |
| for (int i=0; i < NUM_COMPATIBLE_UIMA_JAVA_VERSIONS; i++) { |
| msg.addParam(compatibleVersions[i]); |
| } |
| UIMA_EXC_THROW_NEW(JavaException, |
| UIMA_ERR_JAVA_EXCEPTION, |
| msg, |
| UIMA_MSG_ID_INCOMPATIBLE_UIMA_JAVA_VERSION, |
| ErrorInfo::unrecoverable); |
| } |
| iv_env->ReleaseStringChars(versionString, jc); |
| checkForUnexpectedJNIException(); |
| } else { |
| ErrorMessage msg = ErrorMessage(UIMA_MSG_ID_INCOMPATIBLE_UIMA_JAVA_VERSION); |
| msg.addParam("could not determine UIMA Java version"); |
| UIMA_EXC_THROW_NEW(JavaException, |
| UIMA_ERR_JAVA_EXCEPTION, |
| msg, |
| UIMA_MSG_ID_INCOMPATIBLE_UIMA_JAVA_VERSION, |
| ErrorInfo::unrecoverable); |
| } |
| |
| |
| |
| |
| iv_processMethod = iv_env->GetMethodID(clazz, "process", "(" |
| "Ljava/lang/String;" // doc |
| "[I" // heap |
| "[I" // fsIndex |
| "[Ljava/lang/String;" // stringTable |
| "[I" // resultSpecTypes |
| "[I" // resultSpecFeatures |
| "I" // sofanum |
| "[B" // byte heap |
| "[S" // short heap |
| "[J" // long heap |
| ")I"); |
| checkForUnexpectedJNIException(); |
| iv_getByteHeapMethod = iv_env->GetMethodID(clazz, "getByteHeap", "()[B"); |
| checkForUnexpectedJNIException(); |
| iv_getShortHeapMethod = iv_env->GetMethodID(clazz, "getShortHeap", "()[S"); |
| checkForUnexpectedJNIException(); |
| iv_getLongHeapMethod = iv_env->GetMethodID(clazz, "getLongHeap", "()[J"); |
| checkForUnexpectedJNIException(); |
| |
| |
| |
| |
| |
| |
| iv_destroyMethod = iv_env->GetMethodID(clazz, "destroy", "()I"); |
| checkForUnexpectedJNIException(); |
| iv_getLastExceptionStringMethod = iv_env->GetMethodID(clazz, "getLastExceptionString", "()Ljava/lang/String;"); |
| checkForUnexpectedJNIException(); |
| iv_getHeapMethod = iv_env->GetMethodID(clazz, "getHeap", "()[I"); |
| checkForUnexpectedJNIException(); |
| iv_getIndexedFSsMethod = iv_env->GetMethodID(clazz, "getIndexedFSs", "()[I"); |
| checkForUnexpectedJNIException(); |
| iv_getStringTableMethod = iv_env->GetMethodID(clazz, "getStringTable", "()[Ljava/lang/String;"); |
| checkForUnexpectedJNIException(); |
| |
| iv_batchProcessCompleteMethod = iv_env->GetMethodID(clazz, "batchProcessComplete", "()I"); |
| checkForUnexpectedJNIException(); |
| |
| iv_collectionProcessCompleteMethod = iv_env->GetMethodID(clazz, "collectionProcessComplete", "()I"); |
| checkForUnexpectedJNIException(); |
| |
| |
| |
| iv_obj = iv_env->NewObject(clazz, constructor); |
| checkForUnexpectedJNIException(); |
| iv_obj = iv_env->NewGlobalRef(iv_obj); |
| checkForUnexpectedJNIException(); |
| UIMA_TPRINT("setup VM complete"); |
| |
| |
| // serialize type system and pass it to the initialize method |
| CASSerializer serializer(true); |
| SerializedCAS serializedCAS; |
| serializer.serializeDefinitions( *iv_casDefinition, serializedCAS); |
| UIMA_TPRINT("definitions serialized"); |
| { |
| jint pushFrameResult = iv_env->PushLocalFrame(serializedCAS.getNumberOfJavaObjectsToBeCreatedDefinitions() ); |
| checkForUnexpectedJNIException(); |
| handleEngineProxyError(pushFrameResult); |
| checkForUnexpectedJNIException(); |
| |
| // prepare arguments for initialize() |
| jintArray typeInheritance = createJIntArray(serializedCAS.getTypeInheritanceTable() ); |
| jintArray typePriorities = createJIntArray(serializedCAS.getTypePriorityTable()); |
| jintArray featureDefs = createJIntArray(serializedCAS.getFeatureDefinitionTable()); |
| jintArray featureOffset = createJIntArray(serializedCAS.getFeatureOffsetTable()); |
| |
| jobjectArray typeNames = createJStringArray(serializedCAS.getTypeSymbolTable()); |
| jobjectArray featureNames = createJStringArray(serializedCAS.getFeatureSymbolTable()); |
| |
| jintArray subStringTypes = createJIntArray(serializedCAS.getStringSubTypes()); |
| jobjectArray subStringTypeValues = createJStringArray(serializedCAS.getStringSubTypeValues()); |
| jintArray subStringTypeValuePos = createJIntArray(serializedCAS.getStringSubTypeValuePos()); |
| |
| jintArray indexKinds = createJIntArray(serializedCAS.getIndexKindTable()); |
| jintArray compStarts = createJIntArray(serializedCAS.getComparatorStartTable()); |
| jintArray compDefs = createJIntArray(serializedCAS.getComparatorDefinitionTable()); |
| jobjectArray indexIDs = createJStringArray(serializedCAS.getIndexIDTable()); |
| |
| jstring conf = iv_env->NewString((jchar const *)config.getBuffer(), config.length()); |
| checkForUnexpectedJNIException(); |
| |
| icu::UnicodeString dataPathUS(uima::ResourceManager::getInstance().getLocationData().getAsCString() ); |
| jstring dataPath = iv_env->NewString((jchar const *)dataPathUS.getBuffer(), dataPathUS.length() ); |
| checkForUnexpectedJNIException(); |
| |
| UIMA_TPRINT("Java args created"); |
| // call initialize on org.apache.uima.uimacpp.CppUimajEngine |
| jint initResult = iv_env->CallIntMethod(iv_obj, iv_initializeMethod, |
| conf, |
| dataPath, |
| |
| typeInheritance, |
| typePriorities, |
| featureDefs, |
| featureOffset, |
| typeNames, |
| featureNames, |
| |
| subStringTypes, |
| subStringTypeValues, |
| subStringTypeValuePos, |
| |
| indexIDs, |
| indexKinds, |
| compStarts, |
| compDefs); |
| checkForUnexpectedJNIException(); |
| handleEngineProxyError(initResult); |
| UIMA_TPRINT("Java initalize called"); |
| |
| iv_env->PopLocalFrame(NULL); |
| checkForUnexpectedJNIException(); |
| } |
| |
| UIMA_TPRINT("result spec initialized"); |
| return err; |
| } |
| |
| |
| TyErrorId JEDIIEngine::reinitTypeSystemImpl() { |
| return initializeImpl(getAnnotatorContext().getTaeSpecifier()); |
| } |
| |
| |
| TyErrorId JEDIIEngine::processImpl(CAS & cas, ResultSpecification const & resultSpec) { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| |
| UIMA_TPRINT("serializing data"); |
| TyErrorId err = UIMA_ERR_NONE; |
| |
| // serialize CAS and pass it to process method |
| CASSerializer serializer(true); |
| SerializedCAS serializedInCAS; |
| // serializer.serializeData( TCAS::promoteCAS(cas), serializedInCAS); |
| serializer.serializeData(cas, serializedInCAS); |
| UIMA_TPRINT("data serialized"); |
| { |
| jint pushFrameRes = iv_env->PushLocalFrame( serializedInCAS.getNumberOfJavaObjectsToBeCreatedData()); |
| checkForUnexpectedJNIException(); |
| handleJNIError(pushFrameRes); |
| // prepare arguments |
| jstring doc = createJString( serializedInCAS.getDocument() ); |
| jintArray inHeap = createJIntArray(serializedInCAS.getFSHeapArray() ); |
| jintArray inIndexedFSs = createJIntArray(serializedInCAS.getIndexedFSs() ); |
| jobjectArray inStrings = createJStringArray(serializedInCAS.getStringSymbolTable()); |
| jbyteArray inByteHeap = createJByteArray(serializedInCAS.getByteHeapArray() ); |
| jshortArray inShortHeap = createJShortArray(serializedInCAS.getShortHeapArray() ); |
| jlongArray inLongHeap = createJLongArray(serializedInCAS.getLongHeapArray() ); |
| vector<internal::SerializedCAS::TyNum> resultSpecTypes; |
| vector<internal::SerializedCAS::TyNum> resultSpecFeatures; |
| |
| CASSerializer::serializeResultSpec(resultSpec, resultSpecTypes, resultSpecFeatures); |
| |
| jintArray inRSTypes = createJIntArray(resultSpecTypes); |
| jintArray inRSFeatures = createJIntArray(resultSpecFeatures); |
| UIMA_TPRINT("args to Java initialize created"); |
| |
| int sofaNum=0; |
| if (cas.isView() ) { |
| sofaNum = cas.getSofaNum(); |
| } |
| |
| // call process() |
| jint result = iv_env->CallIntMethod(iv_obj, iv_processMethod, |
| doc, |
| inHeap, |
| inIndexedFSs, |
| inStrings, |
| inRSTypes, |
| inRSFeatures, |
| sofaNum, |
| inByteHeap, |
| inShortHeap, |
| inLongHeap); |
| checkForUnexpectedJNIException(); |
| handleEngineProxyError(result); |
| UIMA_TPRINT("Java initialize done"); |
| |
| iv_env->PopLocalFrame(NULL); |
| checkForUnexpectedJNIException(); |
| } |
| |
| if (err != UIMA_ERR_NONE) { |
| return err; |
| } |
| |
| UIMA_TPRINT("De-serializing per-document data"); |
| |
| SerializedCAS serializedOutCAS; |
| |
| // get serialized CAS from Java object |
| jintArray outHeapArray = (jintArray) iv_env->CallObjectMethod(iv_obj, iv_getHeapMethod); |
| checkForUnexpectedJNIException(); |
| createIntVector(outHeapArray, serializedOutCAS.iv_vecFSHeapArray ); |
| |
| jbyteArray byteHeapArray = (jbyteArray) iv_env->CallObjectMethod(iv_obj, iv_getByteHeapMethod); |
| checkForUnexpectedJNIException(); |
| createByteVector(byteHeapArray, serializedOutCAS.iv_vecByteHeapArray ); |
| |
| jintArray outIndexedFSsArray = (jintArray) iv_env->CallObjectMethod(iv_obj, iv_getIndexedFSsMethod); |
| checkForUnexpectedJNIException(); |
| createIntVector(outIndexedFSsArray, serializedOutCAS.iv_vecIndexedFSs); |
| |
| jobjectArray outStringsArray = (jobjectArray) iv_env->CallObjectMethod(iv_obj, iv_getStringTableMethod); |
| checkForUnexpectedJNIException(); |
| createStringVector(outStringsArray, serializedOutCAS.iv_vecStringSymbolTable, iv_stringPool); |
| |
| serializedOutCAS.iv_ulstrDocument = serializedInCAS.getDocument(); |
| UIMA_TPRINT("De-serialized data received from Java"); |
| CASDeserializer deSerializer; |
| // deSerializer.deserializeData(serializedOutCAS, TCAS::promoteCAS( cas )); |
| deSerializer.deserializeData(serializedOutCAS, cas); |
| UIMA_TPRINT("data deserialized"); |
| return err; |
| } |
| |
| |
| |
| TyErrorId JEDIIEngine::reconfigureImpl() { |
| util::Trace trace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| // no reconfiguration of the JEDII engine possible yet |
| return UIMA_ERR_NONE; |
| } |
| |
| |
| bool JEDIIEngine::hasNextImpl() { |
| util::Trace trace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| //TODO: |
| return false; |
| } |
| |
| |
| CAS & JEDIIEngine::nextImpl() { |
| util::Trace trace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| //TODO::return iv_pAnnotator->next(); |
| UIMA_EXC_THROW_NEW(ExcInvalidRequest, |
| UIMA_ERR_NOT_YET_IMPLEMENTED, |
| UIMA_MSG_ID_EXC_INVALID_CALL_TO_NEXT, |
| UIMA_MSG_ID_EXC_INVALID_CALL_TO_NEXT, |
| ErrorInfo::unrecoverable); |
| } |
| |
| |
| int JEDIIEngine::getCasInstancesRequiredImpl() { |
| util::Trace trace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| //TODO::return iv_pAnnotator->next(); |
| return 0; |
| } |
| |
| |
| void JEDIIEngine::destroyJavaVM() { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| |
| if (iv_createdVM) { |
| iv_createdVM = false; |
| jint destroyRC = iv_vm->DestroyJavaVM(); |
| checkForUnexpectedJNIException(); |
| if (destroyRC != JNI_OK) { |
| char c[2056]; |
| icu::UnicodeString us = javaErrorToString(destroyRC); |
| us.extract(0, us.length(), c); |
| clTrace.dump("Java VM could not be destroyed, return code: ", c); |
| #ifndef NDEBUG |
| cerr << __FILE__ << __LINE__ << ": Java VM could not be destroyed (return code: " << javaErrorToString(destroyRC) << ")" << endl; |
| #endif |
| |
| } |
| } |
| |
| iv_vm = NULL; |
| iv_env = NULL; |
| } |
| |
| |
| TyErrorId JEDIIEngine::destroyImpl() { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| if (iv_vm != NULL) { |
| assert( iv_env != NULL ); |
| if (iv_obj != NULL) { |
| jint destroyResult = iv_env->CallIntMethod(iv_obj, iv_destroyMethod); |
| checkForUnexpectedJNIException(); |
| handleEngineProxyError(destroyResult); |
| |
| iv_env->DeleteGlobalRef(iv_obj); |
| checkForUnexpectedJNIException(); |
| iv_obj = NULL; |
| } |
| |
| destroyJavaVM(); |
| assert( iv_vm == NULL ); |
| assert( iv_env == NULL ); |
| |
| destroyJVMFunctions(); |
| } |
| return UIMA_ERR_NONE; |
| } |
| |
| |
| TyErrorId JEDIIEngine::batchProcessCompleteImpl() { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| |
| TyErrorId err = UIMA_ERR_NONE; |
| jint result = iv_env->CallIntMethod(iv_obj, iv_batchProcessCompleteMethod); |
| |
| checkForUnexpectedJNIException(); |
| handleEngineProxyError(result); |
| return err; |
| } |
| |
| TyErrorId JEDIIEngine::collectionProcessCompleteImpl() { |
| util::Trace clTrace(util::enTraceDetailLow, UIMA_TRACE_ORIGIN, UIMA_TRACE_COMPID_ENGINE); |
| |
| TyErrorId err = UIMA_ERR_NONE; |
| jint result = iv_env->CallIntMethod(iv_obj, iv_collectionProcessCompleteMethod); |
| |
| checkForUnexpectedJNIException(); |
| handleEngineProxyError(result); |
| return err; |
| } |
| |
| |
| |
| } |
| } |
| |
| |
| |
| |
