..
/
download
#ifndef __linux__
#ifndef __APPLE__
//#include "stdafx.h"
#include <Tchar.h>
#endif
#endif
//#include "stdafx.h"
#include "SaxonProcessor.h"
#include "XdmValue.h"
#include "XdmItem.h"
#include "XdmNode.h"
#include "XdmAtomicValue.h"
//#define DEBUG
#ifdef DEBUG
#include <signal.h>
#endif
#include <stdio.h>
//jobject cpp;
const char * failure;
sxnc_environment * SaxonProcessor::sxn_environ = 0;
int SaxonProcessor::refCount = 0;
int SaxonProcessor::jvmCreatedCPP=0;
bool SaxonProcessor::exceptionOccurred(){
bool found = SaxonProcessor::sxn_environ->env->ExceptionCheck();
if(!found){
if( exception != NULL){
bool result = exception->count() > 1;
return result;
} else {return false;}
} else {
return found;
}
}
const char* SaxonProcessor::checkException(jobject cpp) {
const char * message = NULL;
if(exception == NULL) {
message = checkForException(sxn_environ, cpp);
} else {
message = exception->getErrorMessages();
}
return message;
}
void SaxonProcessor::checkAndCreateException(jclass cppClass){
exception = NULL;
if(exceptionOccurred()) {
if(exception != NULL) {
delete exception;
}
exception = checkForExceptionCPP(SaxonProcessor::sxn_environ->env, cppClass, NULL);
#ifdef DEBUG
SaxonProcessor::sxn_environ->env->ExceptionDescribe();
#endif
exceptionClear(false);
}
}
void SaxonProcessor::exceptionClear(bool clearCPPException){
SaxonProcessor::sxn_environ->env->ExceptionClear();
if(exception != NULL && clearCPPException) {
delete exception;
}
}
SaxonApiException * SaxonProcessor::getException(){
return exception;
}
SaxonProcessor::SaxonProcessor() {
licensei = false;
SaxonProcessor(licensei);
}
SaxonApiException * SaxonProcessor::checkForExceptionCPP(JNIEnv* env, jclass callingClass, jobject callingObject){
if(exception != NULL) {
delete exception;
}
if (env->ExceptionCheck()) {
std::string result1 = "";
std::string errorCode = "";
jthrowable exc = env->ExceptionOccurred();
#ifdef DEBUG
env->ExceptionDescribe();
#endif
jclass exccls(env->GetObjectClass(exc));
jclass clscls(env->FindClass("java/lang/Class"));
jmethodID getName(env->GetMethodID(clscls, "getName", "()Ljava/lang/String;"));
jstring name(static_cast<jstring>(env->CallObjectMethod(exccls, getName)));
char const* utfName(env->GetStringUTFChars(name, 0));
result1 = (std::string(utfName));
//env->ReleaseStringUTFChars(name, utfName);
jmethodID getMessage(env->GetMethodID(exccls, "getMessage", "()Ljava/lang/String;"));
if(getMessage) {
jstring message(static_cast<jstring>(env->CallObjectMethod(exc, getMessage)));
char const* utfMessage = NULL;
if(!message) {
utfMessage = "";
return NULL;
} else {
utfMessage = (env->GetStringUTFChars(message, 0));
}
if(utfMessage != NULL) {
result1 = (result1 + " : ") + utfMessage;
}
//env->ReleaseStringUTFChars(message,utfMessage);
if(callingObject != NULL && result1.compare(0,36, "net.sf.saxon.option.cpp.SaxonCException", 36) == 0){
jmethodID getErrorCodeID(env->GetMethodID(callingClass, "getExceptions", "()[Lnet/sf/saxon/option/cpp/SaxonCException;"));
jclass saxonExceptionClass(env->FindClass("net/sf/saxon/option/cpp/SaxonCException"));
if(getErrorCodeID){
jobjectArray saxonExceptionObject((jobjectArray)(env->CallObjectMethod(callingObject, getErrorCodeID)));
if(saxonExceptionObject) {
jmethodID lineNumID = env->GetMethodID(saxonExceptionClass, "getLinenumber", "()I");
jmethodID ecID = env->GetMethodID(saxonExceptionClass, "getErrorCode", "()Ljava/lang/String;");
jmethodID emID = env->GetMethodID(saxonExceptionClass, "getErrorMessage", "()Ljava/lang/String;");
jmethodID typeID = env->GetMethodID(saxonExceptionClass, "isTypeError", "()Z");
jmethodID staticID = env->GetMethodID(saxonExceptionClass, "isStaticError", "()Z");
jmethodID globalID = env->GetMethodID(saxonExceptionClass, "isGlobalError", "()Z");
int exLength = (int)env->GetArrayLength(saxonExceptionObject);
SaxonApiException * saxonExceptions = new SaxonApiException();
for(int i=0; i<exLength;i++){
jobject exObj = env->GetObjectArrayElement(saxonExceptionObject, i);
jstring errCode = (jstring)(env->CallObjectMethod(exObj, ecID));
jstring errMessage = (jstring)(env->CallObjectMethod(exObj, emID));
jboolean isType = (env->CallBooleanMethod(exObj, typeID));
jboolean isStatic = (env->CallBooleanMethod(exObj, staticID));
jboolean isGlobal = (env->CallBooleanMethod(exObj, globalID));
saxonExceptions->add((errCode ? env->GetStringUTFChars(errCode,0) : NULL ) ,(errMessage ? env->GetStringUTFChars(errMessage,0) : NULL),(int)(env->CallIntMethod(exObj, lineNumID)), (bool)isType, (bool)isStatic, (bool)isGlobal);
//env->ExceptionDescribe();
}
//env->ExceptionDescribe();
env->ExceptionClear();
return saxonExceptions;
}
}
}
}
SaxonApiException * saxonExceptions = new SaxonApiException(NULL, result1.c_str());
//env->ExceptionDescribe();
env->ExceptionClear();
return saxonExceptions;
}
return NULL;
}
SaxonProcessor::SaxonProcessor(bool l){
cwd="";
licensei = l;
versionStr = NULL;
SaxonProcessor::refCount++;
exception = NULL;
if(SaxonProcessor::jvmCreatedCPP == 0){
SaxonProcessor::jvmCreatedCPP=1;
SaxonProcessor::sxn_environ= new sxnc_environment;//(sxnc_environment *)malloc(sizeof(sxnc_environment));
/*
* First of all, load required component.
* By the time of JET initialization, all components should be loaded.
*/
/*SaxonProcessor::sxn_environ->myDllHandle = loadDefaultDll ();*/
/*
* Initialize JET run-time.
* The handle of loaded component is used to retrieve Invocation API.
*/
initDefaultJavaRT (SaxonProcessor::sxn_environ);
} else {
#ifdef DEBUG
std::cerr<<"SaxonProc constructor: jvm exists! jvmCreatedCPP="<<jvmCreatedCPP<<std::endl;
#endif
}
versionClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/Version");
procClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/Processor");
saxonCAPIClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/option/cpp/SaxonCAPI");
proc = createSaxonProcessor (SaxonProcessor::sxn_environ->env, procClass, "(Z)V", NULL, licensei);
if(!proc) {
std::cout<<"proc is NULL in SaxonProcessor constructor"<<std::endl;
}
xdmAtomicClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmAtomicValue");
#ifdef DEBUG
jmethodID debugMID = SaxonProcessor::sxn_environ->env->GetStaticMethodID(saxonCAPIClass, "setDebugMode", "(Z)V");
SaxonProcessor::sxn_environ->env->CallStaticVoidMethod(saxonCAPIClass, debugMID, (jboolean)true);
#endif
}
SaxonProcessor::SaxonProcessor(const char * configFile){
cwd="";
versionStr = NULL;
SaxonProcessor::refCount++;
exception = NULL;
if(SaxonProcessor::jvmCreatedCPP == 0){
SaxonProcessor::jvmCreatedCPP=1;
//SaxonProcessor::sxn_environ= new sxnc_environment;
SaxonProcessor::sxn_environ= (sxnc_environment *)malloc(sizeof(sxnc_environment));
/*
* First of all, load required component.
* By the time of JET initialization, all components should be loaded.
*/
/*SaxonProcessor::sxn_environ->myDllHandle = loadDefaultDll ();*/
/*
* Initialize JET run-time.
* The handle of loaded component is used to retrieve Invocation API.
*/
initDefaultJavaRT (SaxonProcessor::sxn_environ);
}
versionClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/Version");
procClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/Processor");
saxonCAPIClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/option/cpp/SaxonCAPI");
static jmethodID mIDcreateProc = (jmethodID)SaxonProcessor::sxn_environ->env->GetStaticMethodID(saxonCAPIClass,"createSaxonProcessor",
"(Ljava/lang/String;)Lnet/sf/saxon/s9api/Processor;");
if (!mIDcreateProc) {
std::cerr << "Error: SaxonDll." << "getPrimitiveTypeName"
<< " not found\n" << std::endl;
return ;
}
proc = SaxonProcessor::sxn_environ->env->CallStaticObjectMethod(saxonCAPIClass, mIDcreateProc,SaxonProcessor::sxn_environ->env->NewStringUTF(configFile));
if(!proc) {
checkAndCreateException(saxonCAPIClass);
std::cerr << "Error: "<<getDllname() << ". processor is NULL in constructor(configFile)"<< std::endl;
return ;
}
licensei = true;
#ifdef DEBUG
std::cerr<<"SaxonProc constructor(configFile)"<<std::endl;
#endif
xdmAtomicClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmAtomicValue");
}
SaxonProcessor::~SaxonProcessor(){
clearConfigurationProperties();
if(versionStr != NULL) {
delete versionStr;
}
SaxonProcessor::refCount--; //This might be redundant due to the bug fix 2670
}
bool SaxonProcessor::isSchemaAwareProcessor(){
if(!licensei) {
return false;
} else {
static jmethodID MID_schema = (jmethodID)SaxonProcessor::sxn_environ->env->GetMethodID(procClass, "isSchemaAware", "()Z");
if (!MID_schema) {
std::cerr<<"\nError: Saxonc "<<"SaxonProcessor.isSchemaAware()"<<" not found"<<std::endl;
return false;
}
licensei = (jboolean)(SaxonProcessor::sxn_environ->env->CallBooleanMethod(proc, MID_schema));
return licensei;
}
}
void SaxonProcessor::applyConfigurationProperties(){
if(configProperties.size()>0) {
int size = configProperties.size();
jclass stringClass = lookForClass(SaxonProcessor::sxn_environ->env, "java/lang/String");
jobjectArray stringArray1 = SaxonProcessor::sxn_environ->env->NewObjectArray( (jint)size, stringClass, 0 );
jobjectArray stringArray2 = SaxonProcessor::sxn_environ->env->NewObjectArray( (jint)size, stringClass, 0 );
static jmethodID mIDappConfig = NULL;
if(mIDappConfig == NULL) {
mIDappConfig = (jmethodID) SaxonProcessor::sxn_environ->env->GetStaticMethodID(saxonCAPIClass,"applyToConfiguration",
"(Lnet/sf/saxon/s9api/Processor;[Ljava/lang/String;[Ljava/lang/String;)V");
if (!mIDappConfig) {
std::cerr << "Error: SaxonDll." << "applyToConfiguration"
<< " not found\n" << std::endl;
return;
}
}
int i=0;
std::map<std::string, std::string >::iterator iter =configProperties.begin();
for(iter=configProperties.begin(); iter!=configProperties.end(); ++iter, i++) {
SaxonProcessor::sxn_environ->env->SetObjectArrayElement( stringArray1, i, SaxonProcessor::sxn_environ->env->NewStringUTF( (iter->first).c_str() ));
SaxonProcessor::sxn_environ->env->SetObjectArrayElement( stringArray2, i, SaxonProcessor::sxn_environ->env->NewStringUTF((iter->second).c_str()) );
}
SaxonProcessor::sxn_environ->env->CallStaticObjectMethod(saxonCAPIClass, mIDappConfig,proc, stringArray1,stringArray2);
if (exceptionOccurred()) {
checkAndCreateException(saxonCAPIClass);
exceptionClear(false);
}
SaxonProcessor::sxn_environ->env->DeleteLocalRef(stringArray1);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(stringArray2);
}
}
jobjectArray SaxonProcessor::createJArray(XdmValue ** values, int length){
jobjectArray valueArray = NULL;
jclass xdmValueClass = lookForClass(SaxonProcessor::sxn_environ->env,
"net/sf/saxon/s9api/XdmValue");
valueArray = SaxonProcessor::sxn_environ->env->NewObjectArray((jint) length,
xdmValueClass, 0);
for (int i=0; i<length; i++) {
#ifdef DEBUG
std::string s1 = typeid(values[i]).name();
std::cerr<<"In createJArray\nType of itr:"<<s1<<std::endl;
jobject xx = values[i]->getUnderlyingValue();
if(xx == NULL) {
std::cerr<<"value failed"<<std::endl;
} else {
std::cerr<<"Type of value:"<<(typeid(xx).name())<<std::endl;
}
if(values[i]->getUnderlyingValue() == NULL) {
std::cerr<<"value["<<i<<"]->getUnderlyingValue() is NULL"<<std::endl;
}
#endif
SaxonProcessor::sxn_environ->env->SetObjectArrayElement(valueArray, i,values[i]->getUnderlyingValue());
}
return valueArray;
}
JParameters SaxonProcessor::createParameterJArray(std::map<std::string,XdmValue*> parameters, std::map<std::string,std::string> properties){
JParameters comboArrays;
comboArrays.stringArray = NULL;
comboArrays.objectArray = NULL;
jclass objectClass = lookForClass(SaxonProcessor::sxn_environ->env,
"java/lang/Object");
jclass stringClass = lookForClass(SaxonProcessor::sxn_environ->env,
"java/lang/String");
int size = parameters.size() + properties.size();
#ifdef DEBUG
std::cerr<<"Properties size: "<<properties.size()<<std::endl;
std::cerr<<"Parameter size: "<<parameters.size()<<std::endl;
#endif
if (size > 0) {
comboArrays.objectArray = SaxonProcessor::sxn_environ->env->NewObjectArray((jint) size,
objectClass, 0);
comboArrays.stringArray = SaxonProcessor::sxn_environ->env->NewObjectArray((jint) size,
stringClass, 0);
int i = 0;
for (std::map<std::string, XdmValue*>::iterator iter =
parameters.begin(); iter != parameters.end(); ++iter, i++) {
#ifdef DEBUG
std::cerr<<"map 1"<<std::endl;
std::cerr<<"iter->first"<<(iter->first).c_str()<<std::endl;
#endif
SaxonProcessor::sxn_environ->env->SetObjectArrayElement(comboArrays.stringArray, i,
SaxonProcessor::sxn_environ->env->NewStringUTF(
(iter->first).c_str()));
#ifdef DEBUG
std::string s1 = typeid(iter->second).name();
std::cerr<<"Type of itr:"<<s1<<std::endl;
if((iter->second) == NULL) {std::cerr<<"iter->second is null"<<std::endl;
} else {
std::cerr<<"getting underlying value"<<std::endl;
jobject xx = (iter->second)->getUnderlyingValue();
if(xx == NULL) {
std::cerr<<"value failed"<<std::endl;
} else {
std::cerr<<"Type of value:"<<(typeid(xx).name())<<std::endl;
}
if((iter->second)->getUnderlyingValue() == NULL) {
std::cerr<<"(iter->second)->getUnderlyingValue() is NULL"<<std::endl;
}}
#endif
SaxonProcessor::sxn_environ->env->SetObjectArrayElement(comboArrays.objectArray, i,
(iter->second)->getUnderlyingValue());
}
for (std::map<std::string, std::string>::iterator iter =
properties.begin(); iter != properties.end(); ++iter, i++) {
SaxonProcessor::sxn_environ->env->SetObjectArrayElement(comboArrays.stringArray, i,
SaxonProcessor::sxn_environ->env->NewStringUTF(
(iter->first).c_str()));
SaxonProcessor::sxn_environ->env->SetObjectArrayElement(comboArrays.objectArray, i,
SaxonProcessor::sxn_environ->env->NewStringUTF(
(iter->second).c_str()));
}
return comboArrays;
} else {
return comboArrays;
}
}
SaxonProcessor& SaxonProcessor::operator=( const SaxonProcessor& other ){
versionClass = other.versionClass;
procClass = other.procClass;
saxonCAPIClass = other.saxonCAPIClass;
cwd = other.cwd;
proc = other.proc;
//SaxonProcessor::sxn_environ= other.environ;
parameters = other.parameters;
configProperties = other.configProperties;
licensei = other.licensei;
exception = other.exception;
return *this;
}
XsltProcessor * SaxonProcessor::newXsltProcessor(){
applyConfigurationProperties();
return (new XsltProcessor(this, cwd));
}
Xslt30Processor * SaxonProcessor::newXslt30Processor(){
applyConfigurationProperties();
return (new Xslt30Processor(this, cwd));
}
XQueryProcessor * SaxonProcessor::newXQueryProcessor(){
applyConfigurationProperties();
return (new XQueryProcessor(this,cwd));
}
XPathProcessor * SaxonProcessor::newXPathProcessor(){
applyConfigurationProperties();
return (new XPathProcessor(this, cwd));
}
SchemaValidator * SaxonProcessor::newSchemaValidator(){
if(licensei) {
applyConfigurationProperties();
return (new SchemaValidator(this, cwd));
} else {
std::cerr<<"\nError: Processor is not licensed for schema processing!"<<std::endl;
return NULL;
}
}
const char * SaxonProcessor::version() {
if(versionStr == NULL) {
static jmethodID MID_version = (jmethodID)SaxonProcessor::sxn_environ->env->GetStaticMethodID(saxonCAPIClass, "getProductVersion", "(Lnet/sf/saxon/s9api/Processor;)Ljava/lang/String;");
if (!MID_version) {
std::cerr<<"\nError: MyClassInDll "<<"SaxonCAPI.getProductVersion()"<<" not found"<<std::endl;
return NULL;
}
jstring jstr = (jstring)(SaxonProcessor::sxn_environ->env->CallStaticObjectMethod(saxonCAPIClass, MID_version, proc));
const char * tempVersionStr = SaxonProcessor::sxn_environ->env->GetStringUTFChars(jstr, NULL);
int verLen = strlen(tempVersionStr)+22+strlen(CVERSION)+1;
versionStr =new char [verLen];
snprintf(versionStr, verLen, "Saxon/C %s %s %s", CVERSION, "running with", tempVersionStr);
//delete tempVersionStr;
}
return versionStr;
}
void SaxonProcessor::setcwd(const char* dir){
cwd = std::string(dir);
}
const char* SaxonProcessor::getcwd(){
return cwd.c_str();
}
void SaxonProcessor::setResourcesDirectory(const char* dir){
//memset(&resources_dir[0], 0, sizeof(resources_dir));
#if defined(__linux__) || defined (__APPLE__)
strncat(_getResourceDirectory(), dir, strlen(dir));
#else
int destSize = strlen(dir) + strlen(dir);
strncat_s(_getResourceDirectory(), destSize,dir, strlen(dir));
#endif
}
void SaxonProcessor::setCatalog(const char* catalogFile, bool isTracing){
jclass xmlResolverClass = lookForClass(SaxonProcessor::sxn_environ->env, "Lnet/sf/saxon/trans/XmlCatalogResolver;");
static jmethodID catalogMID = SaxonProcessor::sxn_environ->env->GetStaticMethodID(xmlResolverClass, "setCatalog", "(Ljava/lang/String;Lnet/sf/saxon/Configuration;Z)V");
if (!catalogMID) {
std::cerr<<"\nError: Saxonc."<<"setCatalog()"<<" not found"<<std::endl;
return;
}
if(catalogFile == NULL) {
return;
}
static jmethodID configMID = SaxonProcessor::sxn_environ->env->GetMethodID(procClass, "getUnderlyingConfiguration", "()Lnet/sf/saxon/Configuration;");
if (!configMID) {
std::cerr<<"\nError: Saxonc."<<"getUnderlyingConfiguration()"<<" not found"<<std::endl;
return;
}
if(!proc) {
std::cout<<"proc is NULL in SaxonProcessorsetCatalog"<<std::endl;
return;
}
jobject configObj = SaxonProcessor::sxn_environ->env->CallObjectMethod(proc, configMID);
if(!configObj) {
std::cout<<"proc is NULL in SaxonProcessor setcatalog - config obj"<<std::endl;
return;
}
SaxonProcessor::sxn_environ->env->CallStaticVoidMethod(xmlResolverClass, catalogMID, SaxonProcessor::sxn_environ->env->NewStringUTF(catalogFile), configObj ,(jboolean)isTracing);
#ifdef DEBUG
SaxonProcessor::sxn_environ->env->ExceptionDescribe();
#endif
}
const char * SaxonProcessor::getResourcesDirectory(){
return _getResourceDirectory();
}
XdmNode * SaxonProcessor::parseXmlFromString(const char* source){
jmethodID mID = (jmethodID)SaxonProcessor::sxn_environ->env->GetStaticMethodID(saxonCAPIClass, "parseXmlString", "(Lnet/sf/saxon/s9api/Processor;Lnet/sf/saxon/s9api/SchemaValidator;Ljava/lang/String;)Lnet/sf/saxon/s9api/XdmNode;");
if (!mID) {
std::cerr<<"\nError: Saxonc."<<"parseXmlString()"<<" not found"<<std::endl;
return NULL;
}
//TODO SchemaValidator
jobject xdmNodei = SaxonProcessor::sxn_environ->env->CallStaticObjectMethod(saxonCAPIClass, mID, proc, NULL, SaxonProcessor::sxn_environ->env->NewStringUTF(source));
if(xdmNodei) {
XdmNode * value = new XdmNode(xdmNodei);
value->setProcessor(this);
return value;
} else if (exceptionOccurred()) {
checkAndCreateException(saxonCAPIClass);
exceptionClear(false);
}
#ifdef DEBUG
SaxonProcessor::sxn_environ->env->ExceptionDescribe();
#endif
return NULL;
}
int SaxonProcessor::getNodeKind(jobject obj){
jclass xdmNodeClass = lookForClass(SaxonProcessor::sxn_environ->env, "Lnet/sf/saxon/s9api/XdmNode;");
static jmethodID nodeKindMID = (jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(xdmNodeClass,"getNodeKind", "()Lnet/sf/saxon/s9api/XdmNodeKind;");
if (!nodeKindMID) {
std::cerr << "Error: MyClassInDll." << "getNodeKind" << " not found\n"
<< std::endl;
return 0;
}
jobject nodeKindObj = (SaxonProcessor::sxn_environ->env->CallObjectMethod(obj, nodeKindMID));
if(!nodeKindObj) {
return 0;
}
jclass xdmUtilsClass = lookForClass(SaxonProcessor::sxn_environ->env, "Lnet/sf/saxon/option/cpp/XdmUtils;");
jmethodID mID2 = (jmethodID) SaxonProcessor::sxn_environ->env->GetStaticMethodID(xdmUtilsClass,"convertNodeKindType", "(Lnet/sf/saxon/s9api/XdmNodeKind;)I");
if (!mID2) {
std::cerr << "Error: MyClassInDll." << "convertNodeKindType" << " not found\n"
<< std::endl;
return 0;
}
if(!nodeKindObj){
return 0;
}
int nodeKind = (int)(SaxonProcessor::sxn_environ->env->CallStaticIntMethod(xdmUtilsClass, mID2, nodeKindObj));
return nodeKind;
}
XdmNode * SaxonProcessor::parseXmlFromFile(const char* source){
jmethodID mID = (jmethodID)SaxonProcessor::sxn_environ->env->GetStaticMethodID(saxonCAPIClass, "parseXmlFile", "(Lnet/sf/saxon/s9api/Processor;Ljava/lang/String;Lnet/sf/saxon/s9api/SchemaValidator;Ljava/lang/String;)Lnet/sf/saxon/s9api/XdmNode;");
if (!mID) {
std::cerr<<"\nError: Saxonc.Dll "<<"parseXmlFile()"<<" not found"<<std::endl;
return NULL;
}
//TODO SchemaValidator
jobject xdmNodei = SaxonProcessor::sxn_environ->env->CallStaticObjectMethod(saxonCAPIClass, mID, proc, SaxonProcessor::sxn_environ->env->NewStringUTF(cwd.c_str()), NULL, SaxonProcessor::sxn_environ->env->NewStringUTF(source));
if(exceptionOccurred()) {
checkAndCreateException(saxonCAPIClass);
exceptionClear(false);
} else {
XdmNode * value = new XdmNode(xdmNodei);
value->setProcessor(this);
return value;
}
return NULL;
}
XdmNode * SaxonProcessor::parseXmlFromUri(const char* source){
jmethodID mID = (jmethodID)SaxonProcessor::sxn_environ->env->GetStaticMethodID(saxonCAPIClass, "parseXmlFile", "(Lnet/sf/saxon/s9api/Processor;Ljava/lang/String;Ljava/lang/String;)Lnet/sf/saxon/s9api/XdmNode;");
if (!mID) {
std::cerr<<"\nError: Saxonc.Dll "<<"parseXmlFromUri()"<<" not found"<<std::endl;
return NULL;
}
jobject xdmNodei = SaxonProcessor::sxn_environ->env->CallStaticObjectMethod(saxonCAPIClass, mID, proc, SaxonProcessor::sxn_environ->env->NewStringUTF(""), SaxonProcessor::sxn_environ->env->NewStringUTF(source));
if(exceptionOccurred()) {
checkAndCreateException(saxonCAPIClass);
} else {
XdmNode * value = new XdmNode(xdmNodei);
value->setProcessor(this);
return value;
}
return NULL;
}
/**
* Set a configuration property.
*
* @param name of the property
* @param value of the property
*/
void SaxonProcessor::setConfigurationProperty(const char * name, const char * value){
if(name != NULL){
configProperties.insert(std::pair<std::string, std::string>(std::string(name), std::string((value == NULL ? "" : value))));
}
}
void SaxonProcessor::clearConfigurationProperties(){
configProperties.clear();
}
void SaxonProcessor::release(){
if(SaxonProcessor::jvmCreatedCPP!=0) {
SaxonProcessor::jvmCreatedCPP =0;
//std::cerr<<"SaxonProc: JVM finalized calling !"<<std::endl;
finalizeJavaRT (SaxonProcessor::sxn_environ->jvm);
//delete SaxonProcessor::sxn_environ;
/*clearParameters();
clearProperties();*/
} else {
#ifdef DEBUG
std::cerr<<"SaxonProc: JVM finalize not called!"<<std::endl;
#endif
}
}
/* ========= Factory method for Xdm ======== */
XdmAtomicValue * SaxonProcessor::makeStringValue(const char * str){
jobject obj = getJavaStringValue(SaxonProcessor::sxn_environ, str);
jmethodID mID_atomic = (jmethodID)(SaxonProcessor::sxn_environ->env->GetMethodID (xdmAtomicClass, "<init>", "(Ljava/lang/String;)V"));
jobject obj2 = (jobject)(SaxonProcessor::sxn_environ->env->NewObject(xdmAtomicClass, mID_atomic, obj));
XdmAtomicValue * value = new XdmAtomicValue(obj2, "xs:string");
value->setProcessor(this);
return value;
}
XdmAtomicValue * SaxonProcessor::makeStringValue(std::string str){
jobject obj = getJavaStringValue(SaxonProcessor::sxn_environ, str.c_str());
jmethodID mID_atomic = (jmethodID)(SaxonProcessor::sxn_environ->env->GetMethodID (xdmAtomicClass, "<init>", "(Ljava/lang/String;)V"));
jobject obj2 = (jobject)(SaxonProcessor::sxn_environ->env->NewObject(xdmAtomicClass, mID_atomic, obj));
XdmAtomicValue * value = new XdmAtomicValue(obj2, "xs:string");
value->setProcessor(this);
return value;
}
XdmAtomicValue * SaxonProcessor::makeIntegerValue(int i){
//jobject obj = integerValue(*SaxonProcessor::sxn_environ, i);
jmethodID mID_atomic = (jmethodID)(SaxonProcessor::sxn_environ->env->GetMethodID (xdmAtomicClass, "<init>", "(J)V"));
jobject obj = (jobject)(SaxonProcessor::sxn_environ->env->NewObject(xdmAtomicClass, mID_atomic, (jlong)i));
XdmAtomicValue * value = new XdmAtomicValue(obj, "Q{http://www.w3.org/2001/XMLSchema}integer");
value->setProcessor(this);
return value;
}
XdmAtomicValue * SaxonProcessor::makeDoubleValue(double d){
//jobject obj = doubleValue(*SaxonProcessor::sxn_environ, d);
jmethodID mID_atomic = (jmethodID)(SaxonProcessor::sxn_environ->env->GetMethodID (xdmAtomicClass, "<init>", "(D)V"));
jobject obj = (jobject)(SaxonProcessor::sxn_environ->env->NewObject(xdmAtomicClass, mID_atomic, (jdouble)d));
XdmAtomicValue * value = new XdmAtomicValue(obj, "Q{http://www.w3.org/2001/XMLSchema}double");
value->setProcessor(this);
return value;
}
XdmAtomicValue * SaxonProcessor::makeFloatValue(float d){
//jobject obj = doubleValue(*SaxonProcessor::sxn_environ, d);
jmethodID mID_atomic = (jmethodID)(SaxonProcessor::sxn_environ->env->GetMethodID (xdmAtomicClass, "<init>", "(F)V"));
jobject obj = (jobject)(SaxonProcessor::sxn_environ->env->NewObject(xdmAtomicClass, mID_atomic, (jfloat)d));
XdmAtomicValue * value = new XdmAtomicValue(obj, "Q{http://www.w3.org/2001/XMLSchema}float");
value->setProcessor(this);
return value;
}
XdmAtomicValue * SaxonProcessor::makeLongValue(long l){
//jobject obj = longValue(*SaxonProcessor::sxn_environ, l);
jmethodID mID_atomic = (jmethodID)(SaxonProcessor::sxn_environ->env->GetMethodID (xdmAtomicClass, "<init>", "(J)V"));
jobject obj = (jobject)(SaxonProcessor::sxn_environ->env->NewObject(xdmAtomicClass, mID_atomic, (jlong)l));
XdmAtomicValue * value = new XdmAtomicValue(obj, "Q{http://www.w3.org/2001/XMLSchema}long");
value->setProcessor(this);
return value;
}
XdmAtomicValue * SaxonProcessor::makeBooleanValue(bool b){
//jobject obj = booleanValue(*SaxonProcessor::sxn_environ, b);
jmethodID mID_atomic = (jmethodID)(SaxonProcessor::sxn_environ->env->GetMethodID (xdmAtomicClass, "<init>", "(Z)V"));
jobject obj = (jobject)(SaxonProcessor::sxn_environ->env->NewObject(xdmAtomicClass, mID_atomic, (jboolean)b));
XdmAtomicValue * value = new XdmAtomicValue(obj, "Q{http://www.w3.org/2001/XMLSchema}boolean");
value->setProcessor(this);
return value;
}
XdmAtomicValue * SaxonProcessor::makeQNameValue(const char* str){
jobject val = xdmValueAsObj(SaxonProcessor::sxn_environ, "QName", str);
XdmAtomicValue * value = new XdmAtomicValue(val, "QName");
value->setProcessor(this);
return value;
}
XdmAtomicValue * SaxonProcessor::makeAtomicValue(const char * typei, const char * strValue){
jobject obj = xdmValueAsObj(SaxonProcessor::sxn_environ, typei, strValue);
XdmAtomicValue * value = new XdmAtomicValue(obj, typei);
value->setProcessor(this);
return value;
}
const char * SaxonProcessor::getStringValue(XdmItem * item){
const char *result = stringValue(SaxonProcessor::sxn_environ, item->getUnderlyingValue());
#ifdef DEBUG
if(result == NULL) {
std::cout<<"getStringValue of XdmItem is NULL"<<std::endl;
} else {
std::cout<<"getStringValue of XdmItem is OK"<<std::endl;
}
#endif
return result;
}
gopher://khzae.net/0/s1000d/s1kd-tools/src/tools/s1kd-brexcheck/saxon/Saxon.C.API/SaxonProcessor.cpp