Project

Profile

Help

Bug #4847 ยป Xslt30Processor.cpp

O'Neil Delpratt, 2020-12-03 11:27

 
// Xslt30Processor.cpp : Defines the exported functions for the DLL application.
//

#include "Xslt30Processor.h"
#include "XdmValue.h"
#include "XdmItem.h"
#include "XdmNode.h"
#include "XdmAtomicValue.h"
#ifdef DEBUG
#include <typeinfo> //used for testing only
#endif

Xslt30Processor::Xslt30Processor() {

SaxonProcessor *p = new SaxonProcessor(false);
Xslt30Processor(p, "");

}

Xslt30Processor::Xslt30Processor(SaxonProcessor * p, std::string curr) {

proc = p;

/*
* Look for class.
*/
cppClass = lookForClass(SaxonProcessor::sxn_environ->env,
"net/sf/saxon/option/cpp/Xslt30Processor");

cppXT = createSaxonProcessor2(SaxonProcessor::sxn_environ->env, cppClass,
"(Lnet/sf/saxon/s9api/Processor;)V", proc->proc);

#ifdef DEBUG
jmethodID debugMID = SaxonProcessor::sxn_environ->env->GetStaticMethodID(cppClass, "setDebugMode", "(Z)V");
SaxonProcessor::sxn_environ->env->CallStaticVoidMethod(cppClass, debugMID, (jboolean)true);

#endif
nodeCreated = false;
tunnel = false;
proc->exception = NULL;
selection = NULL;
selectionV=NULL;
outputfile1 = "";
if(!(proc->cwd.empty()) && curr.empty()){
cwdXT = proc->cwd;
} else if(!curr.empty()){
cwdXT = curr;
}

}

Xslt30Processor::~Xslt30Processor(){
clearProperties();
clearParameters();
if(selectionV != NULL) {
selectionV->decrementRefCount();
if(selectionV->getRefCount() == 0) {
delete selectionV;
}
}

}

bool Xslt30Processor::exceptionOccurred() {
return proc->exceptionOccurred();
}

const char * Xslt30Processor::getErrorCode(int i) {
if(proc->exception == NULL) {return NULL;}
return proc->exception->getErrorCode(i);
}



void Xslt30Processor::setGlobalContextItem(XdmItem * value){
if(value != NULL){
value->incrementRefCount();
parameters["node"] = value;
}
}

void Xslt30Processor::setGlobalContextFromFile(const char * ifile) {
if(ifile != NULL) {
setProperty("s", ifile);
}
}

void Xslt30Processor::setInitialMatchSelection(XdmValue * _selection){
if(_selection != NULL) {
_selection->incrementRefCount();
selectionV = _selection;
selection = _selection->getUnderlyingValue();
}
}


void Xslt30Processor::setInitialMatchSelectionAsFile(const char * filename){
if(filename != NULL) {
selection = SaxonProcessor::sxn_environ->env->NewStringUTF(filename);
}
}

void Xslt30Processor::setOutputFile(const char * ofile) {
outputfile1 = std::string(ofile);
setProperty("o", ofile);
}

void Xslt30Processor::setParameter(const char* name, XdmValue * value, bool _static) {
if(value != NULL && name != NULL){
value->incrementRefCount();
if (_static) {
parameters["sparam:"+std::string(name)] = value;

} else {
parameters["param:"+std::string(name)] = value;
}
}
}

void Xslt30Processor::setInitialTemplateParameters(std::map<std::string,XdmValue*> _itparameters, bool _tunnel){
for(std::map<std::string, XdmValue*>::iterator itr = _itparameters.begin(); itr != _itparameters.end(); itr++){
parameters["itparam:"+std::string(itr->first)] = itr->second;
}
tunnel = _tunnel;
if(tunnel) {
setProperty("tunnel", "true");
}
}

XdmValue* Xslt30Processor::getParameter(const char* name) {
std::map<std::string, XdmValue*>::iterator it;
it = parameters.find("param:"+std::string(name));
if (it != parameters.end())
return it->second;
else {
it = parameters.find("sparam:"+std::string(name));
if (it != parameters.end())
return it->second;
}
return NULL;
}

bool Xslt30Processor::removeParameter(const char* name) {
return (bool)(parameters.erase("param:"+std::string(name)));
}

void Xslt30Processor::setJustInTimeCompilation(bool jit){
static jmethodID jitmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"setJustInTimeCompilation",
"(Z)V");
if (!jitmID) {
std::cerr << "Error: "<<getDllname() << ".setJustInTimeCompilation"
<< " not found\n" << std::endl;
return;
} else {
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, jitmID, jit);

proc->checkAndCreateException(cppClass);
}
}

void Xslt30Processor::setResultAsRawValue(bool option) {
if(option) {
setProperty("outvalue", "yes");
}
}

void Xslt30Processor::setProperty(const char* name, const char* value) {
if(name != NULL) {
properties.insert(std::pair<std::string, std::string>(std::string(name), std::string((value == NULL ? "" : value))));
}
}

const char* Xslt30Processor::getProperty(const char* name) {
std::map<std::string, std::string>::iterator it;
it = properties.find(std::string(name));
if (it != properties.end())
return it->second.c_str();
return NULL;
}

void Xslt30Processor::clearParameters(bool delValues) {
if(delValues){
for(std::map<std::string, XdmValue*>::iterator itr = parameters.begin(); itr != parameters.end(); itr++){

XdmValue * value = itr->second;
value->decrementRefCount();
#ifdef DEBUG
std::cout<<"clearParameter() - XdmValue refCount="<<value->getRefCount()<<std::endl;
#endif
if(value != NULL && value->getRefCount() < 1){
delete value;
}
}

SaxonProcessor::sxn_environ->env->DeleteLocalRef(selection);
selection = NULL;
} else {
for(std::map<std::string, XdmValue*>::iterator itr = parameters.begin(); itr != parameters.end(); itr++){

XdmValue * value = itr->second;
value->decrementRefCount();

}

selection = NULL;
}
parameters.clear();


}

void Xslt30Processor::clearProperties() {
properties.clear();

}



std::map<std::string,XdmValue*>& Xslt30Processor::getParameters(){
std::map<std::string,XdmValue*>& ptr = parameters;
return ptr;
}

std::map<std::string,std::string>& Xslt30Processor::getProperties(){
std::map<std::string,std::string> &ptr = properties;
return ptr;
}

void Xslt30Processor::exceptionClear(){
if(proc->exception != NULL) {
delete proc->exception;
proc->exception = NULL;
SaxonProcessor::sxn_environ->env->ExceptionClear();
}

}

void Xslt30Processor::setcwd(const char* dir){
if (dir!= NULL) {
cwdXT = std::string(dir);
}
}

const char* Xslt30Processor::checkException() {
/*if(proc->exception == NULL) {
proc->exception = proc->checkForException(environi, cpp);
}
return proc->exception;*/
return proc->checkException(cppXT);
}

int Xslt30Processor::exceptionCount(){
if(proc->exception != NULL){
return proc->exception->count();
}
return 0;
}


void Xslt30Processor::compileFromXdmNodeAndSave(XdmNode * node, const char* filename) {
static jmethodID cAndSNodemID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"compileFromXdmNodeAndSave",
"(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;)V");
if (!cAndSNodemID) {
std::cerr << "Error: "<<getDllname() << ".compileFromStringAndSave"
<< " not found\n" << std::endl;

} else {


SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, cAndSNodemID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
node->getUnderlyingValue(), SaxonProcessor::sxn_environ->env->NewStringUTF(filename));

proc->checkAndCreateException(cppClass);

}



}

void Xslt30Processor::compileFromStringAndSave(const char* stylesheetStr, const char* filename){
static jmethodID cAndSStringmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"compileFromStringAndSave",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
if (!cAndSStringmID) {
std::cerr << "Error: "<<getDllname() << ".compileFromStringAndSave"
<< " not found\n" << std::endl;

} else {


SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, cAndSStringmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheetStr), SaxonProcessor::sxn_environ->env->NewStringUTF(filename));

proc->checkAndCreateException(cppClass);

}
}



void Xslt30Processor::compileFromFileAndSave(const char* xslFilename, const char* filename){
static jmethodID cAndFStringmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"compileFromFileAndSave",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
if (!cAndFStringmID) {
std::cerr << "Error: "<<getDllname() << ".compileFromFileAndSave"
<< " not found\n" << std::endl;

} else {


SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, cAndFStringmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
SaxonProcessor::sxn_environ->env->NewStringUTF(xslFilename),SaxonProcessor::sxn_environ->env->NewStringUTF(filename));

proc->checkAndCreateException(cppClass);


}
}

void Xslt30Processor::compileFromString(const char* stylesheetStr) {
static jmethodID cStringmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"createStylesheetFromString",
"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)Lnet/sf/saxon/s9api/XsltExecutable;");
if (!cStringmID) {
std::cerr << "Error: "<<getDllname() << ".createStylesheetFromString"
<< " not found\n" << std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);
stylesheetObject = (jobject)(
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, cStringmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheetStr), comboArrays.stringArray, comboArrays.objectArray));
if (!stylesheetObject) {
proc->checkAndCreateException(cppClass);
}
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
}

}

void Xslt30Processor::compileFromXdmNode(XdmNode * node) {
static jmethodID cNodemID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,"createStylesheetFromXdmNode",
"(Ljava/lang/String;Ljava/lang/Object;[Ljava/lang/String;[Ljava/lang/Object;)Lnet/sf/saxon/s9api/XsltExecutable;");
if (!cNodemID) {
std::cerr << "Error: "<< getDllname() << ".createStylesheetFromXdmNode"
<< " not found\n" << std::endl;

} else {
releaseStylesheet();
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);
stylesheetObject = (jobject)(
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, cNodemID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
node->getUnderlyingValue(), comboArrays.stringArray, comboArrays.objectArray));
if (!stylesheetObject) {
proc->checkAndCreateException(cppClass);
//cout << "Error in compileFromXdmNode" << endl;
}
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
}

}

void Xslt30Processor::compileFromAssociatedFile(const char* source) {
static jmethodID cFilemID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"createStylesheetFromAssoicatedFile",
"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)Lnet/sf/saxon/s9api/XsltExecutable;");
if (!cFilemID) {
std::cerr << "Error: "<<getDllname() << ".createStylesheetFromFile"
<< " not found\n" << std::endl;

} else {
releaseStylesheet();
if(source == NULL) {
std::cerr << "Error in compileFromFile method - The Stylesheet file is NULL" <<std::endl;
return;
}
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);
stylesheetObject = (jobject)(
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, cFilemID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
SaxonProcessor::sxn_environ->env->NewStringUTF(source), comboArrays.stringArray, comboArrays.objectArray));
if (!stylesheetObject) {
proc->checkAndCreateException(cppClass);

}
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
//SaxonProcessor::sxn_environ->env->NewGlobalRef(stylesheetObject);
}

}


void Xslt30Processor::compileFromFile(const char* stylesheet) {
static jmethodID cFilemID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"createStylesheetFromFile",
"(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)Lnet/sf/saxon/s9api/XsltExecutable;");
if (!cFilemID) {
std::cerr << "Error: "<<getDllname() << ".createStylesheetFromFile"
<< " not found\n" << std::endl;

} else {
releaseStylesheet();
if(stylesheet == NULL) {
std::cerr << "Error in compileFromFile method - The Stylesheet file is NULL" <<std::endl;
return;
}
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);
stylesheetObject = (jobject)(
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, cFilemID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheet), comboArrays.stringArray, comboArrays.objectArray));
if (!stylesheetObject) {
proc->checkAndCreateException(cppClass);

}
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
//SaxonProcessor::sxn_environ->env->NewGlobalRef(stylesheetObject);
}

}

void Xslt30Processor::releaseStylesheet() {

stylesheetObject = NULL;

}

void Xslt30Processor::applyTemplatesReturningFile(const char * stylesheetfile, const char* output_filename){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return;
}

if(selection == NULL) {
std::cerr<< "Error: The initial match selection has not been set. Please set it using setInitialMatchSelection or setInitialMatchSelectionFile."<<std::endl;
return;
}

if(stylesheetfile == NULL && !stylesheetObject){

return;
}

setProperty("resources", proc->getResourcesDirectory());
static jmethodID atmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"applyTemplatesReturningFile",
"(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)V");
if (!atmID) {
std::cerr << "Error: "<< getDllname() << "applyTemplatesAsFile" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, atmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),selection,
(stylesheetfile != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(
stylesheetfile) :
NULL), (output_filename != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(
output_filename) : NULL),
comboArrays.stringArray, comboArrays.objectArray);
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
proc->checkAndCreateException(cppClass);

}
return;

}

const char* Xslt30Processor::applyTemplatesReturningString(const char * stylesheetfile){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return NULL;
}
if(selection == NULL) {
std::cerr<< "Error: The initial match selection has not been set. Please set it using setInitialMatchSelection or setInitialMatchSelectionFile."<<std::endl;
return NULL;
}
if(stylesheetfile == NULL && !stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling applyTemplatesReturningString or check exceptions"<<std::endl;
return NULL;
}
setProperty("resources", proc->getResourcesDirectory());
jmethodID atsmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"applyTemplatesReturningString",
"(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;");
if (!atsmID) {
std::cerr << "Error: "<<getDllname() << "applyTemplatesAsString" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);

jstring result = NULL;
jobject obj = (SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, atsmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
selection,
(stylesheetfile!= NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheetfile) : NULL ),
comboArrays.stringArray, comboArrays.objectArray));

if(obj) {
result = (jstring)obj;
}
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
if (result) {
const char * str = SaxonProcessor::sxn_environ->env->GetStringUTFChars(result,
NULL);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(obj);
return str;
} else {
proc->checkAndCreateException(cppClass);

}
}
return NULL;


}

XdmValue * Xslt30Processor::applyTemplatesReturningValue(const char * stylesheetfile){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return NULL;
}
if(selection == NULL) {
std::cerr<< "Error: The initial match selection has not been set. Please set it using setInitialMatchSelection or setInitialMatchSelectionFile."<<std::endl;
return NULL;
}
if(stylesheetfile == NULL && !stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling applyTemplatesReturningValue or check exceptions"<<std::endl;
return NULL;
}
setProperty("resources", proc->getResourcesDirectory());
jmethodID atsmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"applyTemplatesReturningValue",
"(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)Lnet/sf/saxon/s9api/XdmValue;");
if (!atsmID) {
std::cerr << "Error: "<<getDllname() << "applyTemplatesAsValue" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);


// jstring result = NULL;
jobject result = (jobject)(SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, atsmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
selection,
( stylesheetfile != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheetfile) : NULL),
comboArrays.stringArray, comboArrays.objectArray));
/*if(obj) {
result = (jobject)obj;
}*/
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
if (result) {
jclass atomicValueClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmAtomicValue");
jclass nodeClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmNode");
jclass functionItemClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmFunctionItem");
XdmValue * value = NULL;
XdmItem * xdmItem = NULL;


if(SaxonProcessor::sxn_environ->env->IsInstanceOf(result, atomicValueClass) == JNI_TRUE) {
xdmItem = new XdmAtomicValue(result);
xdmItem->setProcessor(proc);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return xdmItem;

} else if(SaxonProcessor::sxn_environ->env->IsInstanceOf(result, nodeClass) == JNI_TRUE) {
xdmItem = new XdmNode(result);
xdmItem->setProcessor(proc);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return xdmItem;
} else if (SaxonProcessor::sxn_environ->env->IsInstanceOf(result, functionItemClass) == JNI_TRUE) {
std::cerr<<"Error: applyTemplateToValue: FunctionItem found. Currently not be handled"<<std::endl;
return NULL;
} else {
value = new XdmValue(result, true);
value->setProcessor(proc);
for(int z=0;z<value->size();z++) {
value->itemAt(z)->setProcessor(proc);
}
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return value;
}
} else {
proc->checkAndCreateException(cppClass);

}
}
return NULL;

}



void Xslt30Processor::callFunctionReturningFile(const char * stylesheetfile, const char* functionName, XdmValue ** arguments, int argument_length, const char* outfile){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return;
}


if(stylesheetfile == NULL && !stylesheetObject){

return;
}

setProperty("resources", proc->getResourcesDirectory());
static jmethodID afmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"callFunctionReturningFile",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;[Ljava/lang/String;[Ljava/lang/Object;)V");
if (!afmID) {
std::cerr << "Error: "<< getDllname() << "callFunctionReturningFile" << " not found\n"
<< std::endl;
return;
} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);

jobjectArray argumentJArray = SaxonProcessor::createJArray(arguments, argument_length);

SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, afmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
(stylesheetfile != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(
stylesheetfile) :
NULL),
(functionName != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(functionName) :
NULL), argumentJArray,
(outfile != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(outfile) :
NULL),
comboArrays.stringArray, comboArrays.objectArray);
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
proc->checkAndCreateException(cppClass);

}
return;




}

const char * Xslt30Processor::callFunctionReturningString(const char * stylesheet, const char* functionName, XdmValue ** arguments, int argument_length){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return NULL;
}

if(stylesheet == NULL && !stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling callFunctionReturningString or check exceptions"<<std::endl;
return NULL;
}
setProperty("resources", proc->getResourcesDirectory());
jmethodID afsmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"callFunctionReturningString",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;[Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;");
if (!afsmID) {
std::cerr << "Error: "<<getDllname() << "callFunctionReturningString" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);
jobjectArray argumentJArray = SaxonProcessor::createJArray(arguments, argument_length);

jstring result = NULL;
jobject obj = (SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, afsmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
(stylesheet != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheet) : NULL ),
(functionName != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(functionName) : NULL),
argumentJArray, comboArrays.stringArray, comboArrays.objectArray));
if(obj) {
result = (jstring)obj;
}
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
if (result) {
const char * str = SaxonProcessor::sxn_environ->env->GetStringUTFChars(result,
NULL);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(obj);
return str;
} else {
proc->checkAndCreateException(cppClass);

}
}
return NULL;
}



XdmValue * Xslt30Processor::callFunctionReturningValue(const char * stylesheet, const char* functionName, XdmValue ** arguments, int argument_length){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return NULL;
}

if(stylesheet == NULL && !stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling callFunctionReturningValue or check exceptions"<<std::endl;
return NULL;
}
setProperty("resources", proc->getResourcesDirectory());
jmethodID cfvmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"callFunctionReturningValue",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;[Ljava/lang/String;[Ljava/lang/Object;)Lnet/sf/saxon/s9api/XdmValue;");
if (!cfvmID) {
std::cerr << "Error: "<<getDllname() << "callFunctionReturningValue" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);
jobjectArray argumentJArray = SaxonProcessor::createJArray(arguments, argument_length);

jobject result = (jobject)(SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, cfvmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
(stylesheet != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheet) : NULL ),
(functionName != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(functionName) : NULL),
argumentJArray, comboArrays.stringArray, comboArrays.objectArray));

if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
if(argumentJArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(argumentJArray);
}
if (result) {
jclass atomicValueClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmAtomicValue");
jclass nodeClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmNode");
jclass functionItemClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmFunctionItem");
XdmValue * value = NULL;
XdmItem * xdmItem = NULL;


if(SaxonProcessor::sxn_environ->env->IsInstanceOf(result, atomicValueClass) == JNI_TRUE) {
xdmItem = new XdmAtomicValue(result);
xdmItem->setProcessor(proc);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return xdmItem;
} else if(SaxonProcessor::sxn_environ->env->IsInstanceOf(result, nodeClass) == JNI_TRUE) {
xdmItem = new XdmNode(result);
xdmItem->setProcessor(proc);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return xdmItem;

} else if (SaxonProcessor::sxn_environ->env->IsInstanceOf(result, functionItemClass) == JNI_TRUE) {
return NULL;
} else {
value = new XdmValue(result, true);
value->setProcessor(proc);
for(int z=0;z<value->size();z++) {
value->itemAt(z)->setProcessor(proc);
}
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return value;
}
value = new XdmValue();
value->setProcessor(proc);
xdmItem->setProcessor(proc);
value->addXdmItem(xdmItem);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return value;
} else {
proc->checkAndCreateException(cppClass);

}
}
return NULL;

}

void Xslt30Processor::addPackages(const char ** fileNames, int length){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return;
}

if(length<1){

return;
}

jmethodID apmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"addPackages",
"([Ljava/lang/String;)V");
if (!apmID) {
std::cerr << "Error: "<<getDllname() << "addPackage" << " not found\n"
<< std::endl;

} else {

jobjectArray stringArray = NULL;

jclass stringClass = lookForClass(SaxonProcessor::sxn_environ->env,
"java/lang/String");


stringArray = SaxonProcessor::sxn_environ->env->NewObjectArray((jint) length,
stringClass, 0);

for (int i=0; i<length; i++) {

SaxonProcessor::sxn_environ->env->SetObjectArrayElement(stringArray, i,
SaxonProcessor::sxn_environ->env->NewStringUTF(fileNames[i]));
}

SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, apmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()), stringArray);

proc->checkAndCreateException(cppClass);
}
return;

}



void Xslt30Processor::clearPackages(){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return;
}



jmethodID cpmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"clearPackages",
"()V");
if (!cpmID) {
std::cerr << "Error: "<<getDllname() << "clearPackage" << " not found\n"
<< std::endl;

} else {


SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, cpmID);

proc->checkAndCreateException(cppClass);
}
return;




}

void Xslt30Processor::callTemplateReturningFile(const char * stylesheetfile, const char* templateName, const char* outfile){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return;
}


if(stylesheetfile == NULL && !stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling callFunctionReturningFile or check exceptions"<<std::endl;
return;
}

setProperty("resources", proc->getResourcesDirectory());
static jmethodID ctmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"callTemplateReturningFile",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)V");
if (!ctmID) {
std::cerr << "Error: "<< getDllname() << "callTemplateReturningFile" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, ctmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
(stylesheetfile != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(
stylesheetfile) :
NULL),
(templateName != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(templateName) :
NULL),
(outfile != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(outfile) :
NULL),
comboArrays.stringArray, comboArrays.objectArray);
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
proc->checkAndCreateException(cppClass);

}
return;


}




const char* Xslt30Processor::callTemplateReturningString(const char * stylesheet, const char* templateName){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return NULL;
}

if(stylesheet == NULL && !stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling callTemplateReturningString or check exceptions"<<std::endl;
return NULL;
}
setProperty("resources", proc->getResourcesDirectory());
jmethodID ctsmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"callTemplateReturningString",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;");
if (!ctsmID) {
std::cerr << "Error: "<<getDllname() << "callTemplateReturningString" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);


jstring result = NULL;
jobject obj =(jobject)(SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, ctsmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
(stylesheet != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheet) : NULL ),
(templateName != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(templateName) : NULL),
comboArrays.stringArray, comboArrays.objectArray));
if(obj) {
result = (jstring)obj;
}
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
if (result) {
const char * str = SaxonProcessor::sxn_environ->env->GetStringUTFChars(result,
NULL);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(obj);
return str;
} else {
proc->checkAndCreateException(cppClass);

}
}
return NULL;


}

XdmValue* Xslt30Processor::callTemplateReturningValue(const char * stylesheet, const char* templateName){
if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return NULL;
}
if(stylesheet == NULL && !stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling callTemplateReturningValue or check exceptions"<<std::endl;
return NULL;
}
setProperty("resources", proc->getResourcesDirectory());
jmethodID ctsmID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"callTemplateReturningValue",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)Lnet/sf/saxon/s9api/XdmValue;");
if (!ctsmID) {
std::cerr << "Error: "<<getDllname() << "callTemplateReturningValue" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);


jstring result = NULL;
jobject obj = (jobject)(SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, ctsmID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
(stylesheet != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheet) : NULL ),
(templateName != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(templateName) : NULL),
comboArrays.stringArray, comboArrays.objectArray));
if(obj) {
result = (jstring)obj;
}
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
if (result) {
jclass atomicValueClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmAtomicValue");
jclass nodeClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmNode");
jclass functionItemClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmFunctionItem");
XdmValue * value = NULL;

XdmItem * xdmItem = NULL;
if(SaxonProcessor::sxn_environ->env->IsInstanceOf(result, atomicValueClass) == JNI_TRUE) {
xdmItem = new XdmAtomicValue(result);
xdmItem->setProcessor(proc);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return xdmItem;

} else if(SaxonProcessor::sxn_environ->env->IsInstanceOf(result, nodeClass) == JNI_TRUE) {
xdmItem = new XdmNode(result);
xdmItem->setProcessor(proc);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return xdmItem;

} else if (SaxonProcessor::sxn_environ->env->IsInstanceOf(result, functionItemClass) == JNI_TRUE) {
std::cerr<<"Error: callTemplateReturningValue: FunctionItem found. Currently not be handled"<<std::endl;
return NULL;
} else {
value = new XdmValue(result, true);
value->setProcessor(proc);
for(int z=0;z<value->size();z++) {
value->itemAt(z)->setProcessor(proc);
}
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return value;
}
value = new XdmValue();
value->setProcessor(proc);
xdmItem->setProcessor(proc);
value->addXdmItem(xdmItem);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return value;
} else {
proc->checkAndCreateException(cppClass);
}
}
return NULL;
}




XdmValue * Xslt30Processor::transformFileToValue(const char* sourcefile,
const char* stylesheetfile) {

if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return NULL;
}

if(sourcefile == NULL && stylesheetfile == NULL && !stylesheetObject){

return NULL;
}

setProperty("resources", proc->getResourcesDirectory());
static jmethodID mID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"transformToValue",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)Lnet/sf/saxon/s9api/XdmValue;");
if (!mID) {
std::cerr << "Error: "<< getDllname() << ".transformtoValue" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);

jobject result = (jobject)(
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, mID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
(sourcefile != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(sourcefile) :
NULL),
(stylesheetfile != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(
stylesheetfile) :
NULL), comboArrays.stringArray, comboArrays.objectArray));
if (comboArrays.stringArray != NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
if (result) {
jclass atomicValueClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmAtomicValue");
jclass nodeClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmNode");
jclass functionItemClass = lookForClass(SaxonProcessor::sxn_environ->env, "net/sf/saxon/s9api/XdmFunctionItem");
XdmValue * value = NULL;
XdmItem * xdmItem = NULL;


if(SaxonProcessor::sxn_environ->env->IsInstanceOf(result, atomicValueClass) == JNI_TRUE) {
xdmItem = new XdmAtomicValue(result);


} else if(SaxonProcessor::sxn_environ->env->IsInstanceOf(result, nodeClass) == JNI_TRUE) {
xdmItem = new XdmNode(result);


} else if (SaxonProcessor::sxn_environ->env->IsInstanceOf(result, functionItemClass) == JNI_TRUE) {
std::cerr<<"Error: TransformFileToValue: FunctionItem found. Currently not be handled"<<std::endl;
return NULL;
} else {
value = new XdmValue(result, true);
value->setProcessor(proc);
for(int z=0;z<value->size();z++) {
value->itemAt(z)->setProcessor(proc);
}
return value;
}
value = new XdmValue();
value->setProcessor(proc);
xdmItem->setProcessor(proc);
value->addXdmItem(xdmItem);

SaxonProcessor::sxn_environ->env->DeleteLocalRef(result);
return value;
}else {

proc->checkAndCreateException(cppClass);

}
}
return NULL;

}


void Xslt30Processor::transformFileToFile(const char* source,
const char* stylesheet, const char* outputfile) {

if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return;
}
if(!stylesheetObject && stylesheet==NULL){
std::cerr<< "Error: stylesheet has not been set or created using the compile methods."<<std::endl;
return;
}
setProperty("resources", proc->getResourcesDirectory());
jmethodID mID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"transformToFile",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)V");
if (!mID) {
std::cerr << "Error: "<<getDllname() << "transformToFile" << " not found\n"
<< std::endl;

} else {
JParameters comboArrays;
comboArrays = SaxonProcessor::createParameterJArray(parameters, properties);

SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, mID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
(source != NULL ?
SaxonProcessor::sxn_environ->env->NewStringUTF(
source) : NULL),
SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheet), (outputfile != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(outputfile) :NULL),
comboArrays.stringArray, comboArrays.objectArray);
if (comboArrays.stringArray!= NULL) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(comboArrays.objectArray);
}
}
proc->checkAndCreateException(cppClass);
}






XdmValue * Xslt30Processor::getXslMessages(){

jmethodID mID = (jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"getXslMessages",
"()[Lnet/sf/saxon/s9api/XdmNode;");
if (!mID) {
std::cerr << "Error: "<<getDllname() << ".getXslMessages" << " not found in JNI\n"
<< std::endl;

} else {
jobjectArray results = (jobjectArray)(
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, mID));
int sizex = SaxonProcessor::sxn_environ->env->GetArrayLength(results);

if (sizex>0) {
XdmValue * value = new XdmValue();

for (int p=0; p < sizex; ++p)
{
jobject resulti = SaxonProcessor::sxn_environ->env->GetObjectArrayElement(results, p);
value->addUnderlyingValue(resulti);
}
SaxonProcessor::sxn_environ->env->DeleteLocalRef(results);
return value;
}
proc->checkAndCreateException(cppClass);
}
return NULL;


}

const char * Xslt30Processor::transformFileToString(const char* source,
const char* stylesheet) {

if(exceptionOccurred()) {
//Possible error detected in the compile phase. Processor not in a clean state.
//Require clearing exception.
return NULL;
}
if(source == NULL && stylesheet == NULL && !stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling transformFileToString or check exceptions"<<std::endl;
return NULL;
}
setProperty("resources", proc->getResourcesDirectory());
jmethodID mID =
(jmethodID) SaxonProcessor::sxn_environ->env->GetMethodID(cppClass,
"transformToString",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;");
if (!mID) {
std::cerr << "Error: "<<getDllname() << "transformFileToString" << " not found\n"
<< std::endl;

} else {
jobjectArray stringArray = NULL;
jobjectArray 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) {
objectArray = SaxonProcessor::sxn_environ->env->NewObjectArray((jint) size,
objectClass, 0);
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(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;


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(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(stringArray, i,
SaxonProcessor::sxn_environ->env->NewStringUTF(
(iter->first).c_str()));
SaxonProcessor::sxn_environ->env->SetObjectArrayElement(objectArray, i,
SaxonProcessor::sxn_environ->env->NewStringUTF(
(iter->second).c_str()));
}
}

jstring result = NULL;
jobject obj =
(
SaxonProcessor::sxn_environ->env->CallObjectMethod(cppXT, mID,
SaxonProcessor::sxn_environ->env->NewStringUTF(cwdXT.c_str()),
(source != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(
source) : NULL),
(stylesheet != NULL ? SaxonProcessor::sxn_environ->env->NewStringUTF(stylesheet) : NULL),
stringArray, objectArray));
if(obj) {
result = (jstring)obj;
}
if (size > 0) {
SaxonProcessor::sxn_environ->env->DeleteLocalRef(stringArray);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(objectArray);
}
if (result) {
const char * str = SaxonProcessor::sxn_environ->env->GetStringUTFChars(result,
NULL);
SaxonProcessor::sxn_environ->env->DeleteLocalRef(obj);
return str;
} else {
proc->checkAndCreateException(cppClass);

}
}
return NULL;
}


const char * Xslt30Processor::transformToString(XdmNode * source){
if(!stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling transformToString or check exceptions"<<std::endl;
return NULL;
}
if(source != NULL){
source->incrementRefCount();
parameters["node"] = source;
}
return transformFileToString(NULL, NULL);
}


XdmValue * Xslt30Processor::transformToValue(XdmNode * source){
if(!stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling transformToValue or check exceptions"<<std::endl;
return NULL;
}
if(source != NULL){
source->incrementRefCount();
parameters["node"] = source;
}
return transformFileToValue(NULL, NULL);
}

void Xslt30Processor::transformToFile(XdmNode * source){
if(!stylesheetObject){
std::cerr<< "Error: No stylesheet found. Please compile stylesheet before calling transformToFile or check exceptions"<<std::endl;
return;
}
if(source != NULL){
source->incrementRefCount();
parameters["node"] = source;
}
transformFileToFile(NULL, NULL, NULL);
}

const char * Xslt30Processor::getErrorMessage(int i ){
if(proc->exception == NULL) {return NULL;}
return proc->exception->getErrorMessage(i);
}
    (1-1/1)