SaxonProcessor.h

// Copyright (c) 2019 Saxonica Limited.
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0.

#ifndef SAXON_PROCESSOR_H
#define SAXON_PROCESSOR_H
    
#if defined __linux__ || defined __APPLE__
        #include <stdlib.h>
        #include <string.h>
        #include <dlfcn.h>

        #define HANDLE void*
        #define LoadLibrary(x) dlopen(x, RTLD_LAZY)
        #define GetProcAddress(x,y) dlsym(x,y)
#else
    #include <windows.h>
#endif

//#define DEBUG //remove
#define CVERSION "1.1.2"
#include <string>
#include <iostream>
#include <sstream>  
#include <map>  
#include <vector>
#include <stdexcept>      // std::logic_error

#include "SaxonCGlue.h"
#include "SaxonCXPath.h"
#include "XsltProcessor.h"
#include "XQueryProcessor.h"
#include "XPathProcessor.h"
#include "SchemaValidator.h"
//#include "com_saxonica_functions_extfn_PhpCall.h"
//#include "com_saxonica_functions_extfn_PhpCall_PhpFunctionCall.h"

class XsltProcessor;
class XQueryProcessor;
class XPathProcessor;
class SchemaValidator;
class XdmValue;
class XdmNode;
class XdmItem;
class XdmAtomicValue;



// The Saxon XSLT interface class

//std::mutex mtx;
typedef struct {
        std::string errorCode;
        std::string errorMessage;
        int linenumber;
            bool isType;
            bool isStatic;
            bool isGlobal;
    }MyException;




class SaxonApiException {

public:

     SaxonApiException(){
    exceptions = std::vector<MyException>(0);
    }

    SaxonApiException(const SaxonApiException &ex){
        exceptions = ex.exceptions;
    }

    SaxonApiException(const char * ec, const char * exM){
        exceptions = std::vector<MyException>(0);
        MyException newEx;  
        if(ec != NULL){
            newEx.errorCode =   std::string(ec);
        } else {
            newEx.errorCode ="Unknown"; 
        }
        if(exM != NULL){
            newEx.errorMessage =  std::string(exM);
        } else {
            newEx.errorMessage="Unkown";        
        }
        newEx.isType = false;
            newEx.isStatic = false;
            newEx.isGlobal = false;
        newEx.linenumber = 0;
        exceptions.push_back(newEx);
    }

    SaxonApiException(const char * ec, const char * exM, bool typeErr, bool stat, bool glob, int l){
        exceptions = std::vector<MyException>(20);
        MyException newEx;
        if(ec != NULL){
            newEx.errorCode =   std::string(ec);
        } else {
            newEx.errorCode ="ERROR1";  
        }
        if(exM != NULL){
            newEx.errorMessage =  std::string(exM);
        } else {
            newEx.errorMessage="ERROR2";        
        }
        newEx.isType = typeErr;
            newEx.isStatic = stat;
            newEx.isGlobal = glob;
        newEx.linenumber = l;
        exceptions.push_back(newEx);
    }

    void add(const char * ec, const char * exM, bool typeErr, bool stat, bool glob, int l){
        MyException newEx;
        if(ec != NULL){
            newEx.errorCode =   std::string(ec);
        } else {
            newEx.errorCode ="ERROR1";  
        }
        if(exM != NULL){
            newEx.errorMessage =  std::string(exM);
        } else {
            newEx.errorMessage="ERROR2";        
        }
        newEx.isType = typeErr;
            newEx.isStatic = stat;
            newEx.isGlobal = glob;
        newEx.linenumber = l;
        exceptions.push_back(newEx);
    }


    ~SaxonApiException(){ 
      clear();
    }

    const char * getErrorCode(int i){
        if((size_t)i <= exceptions.size()){
            return exceptions[i].errorCode.c_str();
        }
        return NULL;
    }


    int getLineNumber(int i){
        if((size_t)i <= exceptions.size()){
            return exceptions[i].linenumber;    
        }
        return 0;
    }

    bool isGlobalError(int i){
        if((size_t)i <= exceptions.size()){
            return exceptions[i].isGlobal;
        }
        return false;
    }

    bool isStaticError(int i){
        if((size_t)i <= exceptions.size()){
            return exceptions[i].isStatic;
        }
        return false;
    }

    bool isTypeError(int i){
        if((size_t) i <= exceptions.size()){
            return exceptions[i].isType;
        }
        return false;
    }

    void clear(){
      for(size_t i =0; i< exceptions.size();i++) {
        exceptions[i].errorCode.clear();
        exceptions[i].errorMessage.clear(); 
      }
      exceptions.clear();
    }

    int count(){
        return (int)exceptions.size();  
    }

    const char * getErrorMessage(int i){
        if((size_t)i <= exceptions.size()){
            return exceptions[i].errorMessage.c_str();
        }
        return NULL;
    }

    const char * getErrorMessages(){
        std::string result;
        for(size_t i = 0;i<exceptions.size();i++) {
            result += getErrorMessage(i);
        }
        if(result.empty()) { return NULL;}
        return result.c_str();
    }

    MyException getException(int i){
        if((size_t)i <= exceptions.size()){
            return exceptions[i];   
        }
        throw 0;
    }

    

private:
    std::vector<MyException> exceptions; 
};








//==========================================



class SaxonProcessor {
friend  class XsltProcessor;
friend  class XQueryProcessor;
friend class SchemaValidator;
friend class XPathProcessor;
friend class XdmValue;
friend class XdmAtomicValue;
public:


    SaxonProcessor();


    SaxonProcessor(const char * configFile);



    SaxonProcessor(bool l);

    SaxonProcessor& operator=( const SaxonProcessor& other );

    ~SaxonProcessor();
    
    XsltProcessor * newXsltProcessor();

    XQueryProcessor * newXQueryProcessor();


    XPathProcessor * newXPathProcessor();

    SchemaValidator * newSchemaValidator();


    XdmAtomicValue * makeStringValue(std::string str);

    XdmAtomicValue * makeStringValue(const char * str);

    XdmAtomicValue * makeIntegerValue(int i);


    XdmAtomicValue * makeDoubleValue(double d);

    XdmAtomicValue * makeFloatValue(float);

    XdmAtomicValue * makeLongValue(long l);

    XdmAtomicValue * makeBooleanValue(bool b);

    XdmAtomicValue * makeQNameValue(std::string str);

    XdmAtomicValue * makeAtomicValue(std::string type, std::string value);

    const char * getStringValue(XdmItem * item);

    XdmNode * parseXmlFromString(const char* source);

    XdmNode * parseXmlFromFile(const char* source);

    XdmNode * parseXmlFromUri(const char* source);

    int getNodeKind(jobject);

    bool isSchemaAware();
 

    bool exceptionOccurred();

    void exceptionClear(bool clearCPPException=true);

    SaxonApiException * checkForExceptionCPP(JNIEnv* env, jclass callingClass,  jobject callingObject);

    SaxonApiException * getException();

    /*
      * Clean up and destroy Java VM to release memory used. 
     */
    static void release();

   void setcwd(const char* cwd);


   void setResourcesDirectory(const char* dir);
    

   const char * getResourcesDirectory();

    void setConfigurationProperty(const char * name, const char * value);

     void clearConfigurationProperties();


    const char * version();

/*
     * Add a native method.
     * @param name of the native method
     * @param signature of the native method
     * @param fnPtr Pointer to the native method
 */
void addNativeMethod(char *name, char* signature, void * fnPtr){

    JNINativeMethod method;
    method.name = name;
    method.signature = signature;
    method.fnPtr = fnPtr;

    nativeMethodVect.push_back(method);

    

}

/*
     * Register several native methods for one class.
     * @param libName name of the library which contains the function(s). Loads the library
     * @param gMethods Register native methods. Default is NULL, also NULL allowed in which cause assumption is made the user has added native methods using the method addNativeMethod .
 * @return bool success of registered native method
 */
bool registerCPPFunction(char * libName, JNINativeMethod * gMethods=NULL){
    if(libName != NULL) {
        setConfigurationProperty("extc", libName);
            
    }

    if(gMethods == NULL && nativeMethodVect.size()==0) {
    return false;
    } else {
        if(gMethods == NULL) {
            //copy vector to gMethods
            gMethods = new JNINativeMethod[nativeMethodVect.size()];
        } 
        return registerNativeMethods(sxn_environ->env, "com/saxonica/functions/extfn/CppCall$PhpFunctionCall",
    gMethods, sizeof(gMethods) / sizeof(gMethods[0]));
    

    }
    return false;
}

/*
 * Register several native methods for one class.
 * @return bool success of registered native method
 */
static bool registerNativeMethods(JNIEnv* env, const char* className,
    JNINativeMethod* gMethods, int numMethods)
{
    jclass clazz;
    clazz = env->FindClass(className);
    if (clazz == NULL) {
       // std::cerr<<"Native registration unable to find class "<< className<<std::endl;
        return false;
    }
    if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
       // std::cerr<<"RegisterNatives failed for "<< className<<std::endl;
        return false;
    }
    return true;
}

    /* TODO: Remove use of this method.*/
    const char* checkException(jobject cpp);

    /* Internal use*/
    void checkAndCreateException(jclass cppClass);



//  XPathEngine
//  XQueryEngine
//  SchemaManager

   // static JNIEnv *env;
    static int jvmCreatedCPP;
    static sxnc_environment * sxn_environ;
    static int refCount;
    std::string cwd; 
    jobject proc; 
    /*static JavaVM *jvm;*/
    
protected:
    jclass xdmAtomicClass;
    jclass  versionClass;
    jclass  procClass;
    jclass  saxonCAPIClass;
    std::string cwdV; 
    //std::string resources_dir; /*!< current Saxon resources directory */
    char * versionStr;
    std::map<std::string,XdmValue*> parameters; 
    std::map<std::string,std::string> configProperties; 
    bool licensei; 
    bool closed;
    SaxonApiException* exception; 
    JNINativeMethod * nativeMethods;
    std::vector<JNINativeMethod> nativeMethodVect; 
private:

    void applyConfigurationProperties();
};

//===============================================================================================

#endif /* SAXON_PROCESSOR_H */