SaxonProcessor.h

// Copyright (c) 2022 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>
#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 MEM_DEBUG //remove
#define CVERSION "11.5"
#define CVERSION_API_NO 1150
 
 
 
 
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <vector>
#include <stdexcept>      // std::logic_error
 
#include "SaxonCGlue.h"
#include "SaxonCXPath.h"
#include "Xslt30Processor.h"
#include "XsltExecutable.h"
#include "DocumentBuilder.h"
#include "XQueryProcessor.h"
#include "XPathProcessor.h"
#include "SchemaValidator.h"
#include "SaxonApiException.h"
//#include "com_saxonica_functions_extfn_PhpCall.h"
//#include "com_saxonica_functions_extfn_PhpCall_PhpFunctionCall.h"
//#define MEM_DEBUG
#if defined MEM_DEBUG
 
 
#include <algorithm>
#include <cstdlib>
#include <new>
 
static std::vector<void*> myAlloc;
 
void* newImpl(std::size_t sz,char const* file, int line);
 
void* operator new(std::size_t sz,char const* file, int line);
 
void* operator new [](std::size_t sz,char const* file, int line);
 
void operator delete(void* ptr) noexcept;
 
void operator delete(void*, std::size_t) noexcept;
 
#endif
 
 
class Xslt30Processor;
 
class XQueryProcessor;
 
class XPathProcessor;
 
class SchemaValidator;
 
class XdmValue;
 
class XdmNode;
 
class XdmItem;
 
class XdmAtomicValue;
 
class XdmFunctionItem;
 
class XdmArray;
 
class XdmMap;
 
class XsltExecutable;
 
class DocumentBuilder;
 
class SaxonApiException;
 
 
 
typedef struct {
    jobjectArray stringArray; 
    jobjectArray objectArray; 
} JParameters;
 
 
 
//==========================================
 
 
 
class SaxonProcessor {
 
    friend class DocumentBuilder;
 
    friend class Xslt30Processor;
 
    friend class XsltExecutable;
 
    friend class XQueryProcessor;
 
    friend class SchemaValidator;
 
    friend class XPathProcessor;
 
    friend class XdmValue;
 
    friend class XdmAtomicValue;
 
    friend class XdmFunctionItem;
 
    friend class XdmNode;
 
    friend class XdmMap;
 
    friend class XdmArray;
 
public:
 
 
    SaxonProcessor();
 
 
    SaxonProcessor(const char *configFile);
 
 
 
    SaxonProcessor(bool l);
 
 
    SaxonProcessor &operator=(const SaxonProcessor &other);
 
 
 
    SaxonProcessor(const SaxonProcessor &other);
 
    ~SaxonProcessor();
 
 
    const char * getErrorMessage();
 
 
    DocumentBuilder * newDocumentBuilder();
 
 
 
    Xslt30Processor *newXslt30Processor();
 
 
 
    XQueryProcessor *newXQueryProcessor();
 
 
 
    XPathProcessor *newXPathProcessor();
 
 
    SchemaValidator *newSchemaValidator();
 
 
    XdmAtomicValue *makeStringValue(std::string str);
 
 
    XdmAtomicValue *makeStringValue(const char *str);
 
 
    static XdmAtomicValue *makeStringValue2(std::string str);
 
    XdmAtomicValue *makeIntegerValue(int i);
 
 
 
    XdmAtomicValue *makeDoubleValue(double d);
 
 
    XdmAtomicValue *makeFloatValue(float f);
 
 
    XdmAtomicValue *makeLongValue(long l);
 
 
    XdmAtomicValue *makeBooleanValue(bool b);
 
 
    XdmAtomicValue *makeQNameValue(const char *str);
 
 
    XdmAtomicValue *makeAtomicValue(const char *type, const char *value);
 
 
    XdmArray *makeArray(const char **input, int length);
 
 
 
    XdmArray *makeArray(short *input, int length);
 
 
 
    XdmArray *makeArray(int *input, int length);
 
 
    XdmArray *makeArray(long *input, int length);
 
    XdmArray *makeArray(bool *input, int length);
 
 
 
    XdmArray *makeArray(XdmValue ** values, int length);
 
 
    XdmMap *makeMap(std::map<XdmAtomicValue *, XdmValue *> dataMap);
 
 
    static XdmMap *makeMap2(std::map<std::string, XdmValue *> dataMap);
 
 
    XdmMap *makeMap3(XdmAtomicValue ** keys, XdmValue ** values, int len);
 
 
 
    const char *getStringValue(XdmItem *item);
 
 
    XdmNode *parseXmlFromString(const char *source, SchemaValidator * validator = nullptr);
 
 
    XdmNode *parseXmlFromFile(const char *source, SchemaValidator * validator = nullptr);
 
 
    XdmNode *parseXmlFromUri(const char *source, SchemaValidator * validator = nullptr);
 
 
    int getNodeKind(jobject obj);
 
 
    bool isSchemaAwareProcessor();
 
 
 
    bool exceptionOccurred();
 
    void exceptionClear();
 
 
    XdmValue ** createXdmValueArray(int len){
       return (new XdmValue*[len]);
    }
 
    XdmAtomicValue ** createXdmAtomicValueArray(int len){
       return (new XdmAtomicValue*[len]);
    }
 
 
    static SaxonApiException *checkForExceptionCPP(JNIEnv *env, jclass callingClass, jobject callingObject);
 
    static void release();
 
    static void attachCurrentThread();
 
    static void detachCurrentThread();
 
 
    void setcwd(const char *cwd);
 
 
    const char *getcwd();
 
 
 
   const char * getResourcesDirectory();
 
 
   void setResourcesDirectory(const char* dir);
 
    void setCatalog(const char *catalogFile, bool isTracing);
 
 
 
    void setConfigurationProperty(const char *name, const char *value);
 
    void clearConfigurationProperties();
 
 
 
    const char *version();
 
 
    void addNativeMethod(char *name, char *signature, void *fnPtr) {
 
        JNINativeMethod method;
        method.name = name;
        method.signature = signature;
        method.fnPtr = fnPtr;
 
        nativeMethodVect.push_back(method);
 
 
    }
 
 
    bool registerCPPFunction(char *libName, JNINativeMethod *gMethods = nullptr) {
        if (libName != nullptr) {
            setConfigurationProperty("extc", libName);
 
        }
 
        if (gMethods == nullptr && nativeMethodVect.size() == 0) {
            return false;
        } else {
            if (gMethods == nullptr) {
                //copy vector to gMethods
                gMethods = new JNINativeMethod[nativeMethodVect.size()];
            }
            return registerNativeMethods(sxn_environ->env, "com/saxonica/functions/extfn/CppCall$PhpFunctionCall",
                                         gMethods, nativeMethodVect.size());
 
 
        }
        return false;
    }
 
 
    static bool registerNativeMethods(JNIEnv *env, const char *className,
                                      JNINativeMethod *gMethods, int numMethods) {
        jclass clazz;
        clazz = env->FindClass(className);
        if (clazz == nullptr) {
            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;
    }
 
 
    SaxonApiException *checkAndCreateException(jclass cppClass);
 
 
 
 
    static int jvmCreatedCPP; 
    static sxnc_environment *sxn_environ;
    std::string cwd; 
    jobject proc; 
    static void getInfo();
 
    /*static JavaVM *jvm;*/
 
protected:
 
 
    jclass xdmAtomicClass; 
    jclass versionClass; 
    jclass procClass; 
    jclass saxonCAPIClass; 
    std::string cwdV; 
    //std::string resources_dir; /*!< current Saxon resources directory */
    std::string versionStr; 
    std::map<std::string, XdmValue *> parameters; 
    std::map<std::string, std::string> configProperties; 
    bool licensei; 
    JNINativeMethod *nativeMethods; 
    std::vector<JNINativeMethod> nativeMethodVect; 
    SaxonApiException *exception; 
private:
 
    void createException(const char * message=nullptr);
 
    void initialize(bool l);
 
    void applyConfigurationProperties();
 
    // SaxonC method for internal use
    static JParameters
    createParameterJArray(std::map<std::string, XdmValue *> parameters, std::map<std::string, std::string> properties, int additions = 0);
 
    static JParameters createParameterJArray2(std::map<std::string, XdmValue *> parameters);
 
    static jobjectArray createJArray(XdmValue **values, int length);
 
    static const char *checkException();
};
 
 
//===============================================================================================
 
 
 
#endif /* SAXON_PROCESSOR_H */