SaxonProcessor.h

// Copyright (c) 2022 - 2023 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 <dlfcn.h>
#include <stdlib.h>
#include <string>
 
#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_API_NO 1210
 
#include <iostream>
#include <map>
#include <sstream>
#include <stdexcept> // std::logic_error
#include <string>
#include <vector>
 
#include "saxonc_export.h"
#include "saxonc/DocumentBuilder.h"
#include "saxonc/SaxonApiException.h"
#include "saxonc/SaxonCGlue.h"
#include "saxonc/SaxonCXPath.h"
#include "saxonc/SchemaValidator.h"
#include "saxonc/XPathProcessor.h"
#include "saxonc/XQueryProcessor.h"
#include "saxonc/Xslt30Processor.h"
#include "saxonc/UserFunctionHandler.h"
#include "saxonc/XsltExecutable.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 XsdCompiler;
 
class XdmValue;
 
class XdmNode;
 
class XdmItem;
 
class XdmAtomicValue;
 
class XdmFunctionItem;
 
class XdmArray;
 
class XdmMap;
 
class XsltExecutable;
 
class DocumentBuilder;
 
class SaxonApiException;
 
 
typedef enum eXdmType {
  XDM_VALUE = 0,
  XDM_ATOMIC_VALUE = 1,
  XDM_NODE = 2,
  XDM_ARRAY = 3,
  XDM_MAP = 4,
  XDM_FUNCTION_ITEM = 5,
  XDM_EMPTY = 6,
  XDM_ITEM = 7,
} XDM_TYPE;
 
struct UserFunctionDescriptor{
  std::string ns;
  std::string functionName;
  XdmValue * (*func)(int, XdmValue **);
  std::string returnTypeStr;
  std::string arguments;
  XdmValue * argumentTypes;
  XdmValue * returnType;
} ;
 
 
 
//extern "C" void * c_nativeCall(char * functionName, void * proc, void * func, int useNativeTypes, int numOfArguments, void ** arguments);
 
 
 
//==========================================

class SAXONC_EXPORT SaxonProcessor {
 
  friend class DocumentBuilder;
 
  friend class Xslt30Processor;
 
  friend class XsltExecutable;
 
  friend class XQueryProcessor;
 
  friend class SchemaValidator;
 
  friend class XsdCompiler;
 
  friend class XPathProcessor;
 
  friend class XdmValue;
 
  friend class XdmItem;
 
  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();

  DocumentBuilder *newDocumentBuilder();

  Xslt30Processor *newXslt30Processor();

  XQueryProcessor *newXQueryProcessor();

  XPathProcessor *newXPathProcessor();

  SchemaValidator *newSchemaValidator();

  XsdCompiler *newXsdCompiler();

  XdmAtomicValue *makeStringValue(std::string str,
                                  const char *encoding = nullptr);

  XdmAtomicValue *makeStringValue(const char *str,
                                  const char *encoding = nullptr);

  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(char **input, int length);

  XdmArray *makeArray(short *input, int length);

  XdmArray *makeArray(int *input, int length);

  XdmArray *makeArray(long long *input, int length);

  XdmArray *makeArray(bool *input, int length);

  XdmArray *makeArray(XdmValue **values, int length);
 
 
  static void * makeInternalArray(void **inputs, 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 *clarkNameToEQName(const char *name);

  const char *EQNameToClarkName(const char *name);

  const char *getStringValue(XdmItem *item);

  XdmNode *parseXmlFromString(const char *source,
                              const char *encoding = nullptr,
                              SchemaValidator *validator = nullptr);

  XdmNode *parseXmlFromFile(const char *source,
                            SchemaValidator *validator = nullptr);

  XdmNode *parseXmlFromUri(const char *source,
                           SchemaValidator *validator = nullptr);

  XdmValue *parseJsonFromString(const char *source,
                                const char *encoding = NULL);

  XdmValue *parseJsonFromFile(const char *source);

  int getNodeKind(int64_t obj);

  bool isSchemaAwareProcessor();
 

  XdmValue **createXdmValueArray(int len) { return (new XdmValue *[len]); }

  void deleteXdmValueArray(XdmValue **arr, int len);

  XdmAtomicValue **createXdmAtomicValueArray(int len) {
    return (new XdmAtomicValue *[len]);
  }

  void deleteXdmAtomicValueArray(XdmAtomicValue **arr, int len);
 

 static  const char * encodeString(const char * stringValue, const char * toCharSetName);

  static void release();

  static void attachCurrentThread();

  static graal_isolatethread_t * getOrAttachCurrentThread(sxnc_environment * sxn);

  static void detachCurrentThread();

  static void attachCurrentThread(sxnc_environment * sxn);

  static void detachCurrentThread(sxnc_environment * sxn);

  void setcwd(const char *cwd);

  const char *getcwd();

  const char *getResourcesDirectory();

  void setResourcesDirectory(const char *dir);

  void setCatalog(const char *catalogFile);

  void setCatalogFiles(const char **catalogFiles, int length);

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

  void clearConfigurationProperties();

 bool isLicensed();

 const char * getSaxonEdition();

  const char *version();
 
  void registerUserFunction(const char * ns, XdmValue * (*func)(int, XdmValue **), const char * signatureJSON, bool useNativeTypes=false);
 
  void registerUserFunctionWithProcessor(void * procPtr, const char * ns, void * func, const char * signatureJSON, bool useNativeTypes=false);


  /*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;
  } **/
 
  static int jvmCreatedCPP; 
  static sxnc_environment
      *sxn_environ; 
  std::string cwd;  

  static void deleteString(const char *data) {
    if (data != nullptr) {
      operator delete((char *)data);
      data = nullptr;
    } 
  }

  static void createHeapDump(bool live);
 
  static XdmItem *makeXdmItemFromRef(int64_t valueRef);
 
  static XdmValue *makeXdmValueFromRef(int64_t valueRef);
 
protected:
 

  SaxonProcessor(int64_t procRef, bool license=false);
 
  std::string cwdV; 
  // std::string resources_dir; /*!< Saxon resources directory */
  std::string versionStr; 
  std::map<std::string, XdmValue *>
      parameters; 
  //std::map<std::string, std::string>
  // configProperties; /*!< Map of properties used for the transformation as
  //                         (string, string) pairs */
  bool licensei; 
  int64_t procRef; 
 
 
private:
  // void createException(const char *message = nullptr);
 
  void initialize(bool l);
 
  void applyConfigurationProperties();
 
  // SaxonC method for internal use
  static int64_t
    createParameterJArray(std::map<std::string, XdmValue *> parameters,
                        std::map<std::string, std::string> properties,
                        int additions = 0);
 
  static int64_t
  createParameterJArray2(std::map<std::string, XdmValue *> parameters);
 
  static int64_t createJArray(XdmValue **values, int length);

  static void destroyHandle(int64_t handleRef);

  static void getInfo();
};
 
//===============================================================================================
 
#endif /* SAXON_PROCESSOR_H */