Subversion Repositories openrisc

/* xmlj_transform.c -

   Copyright (C) 2003, 2004 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2, or (at your option)

any later version.

GNU Classpath is distributed in the hope that it will be useful, but

WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

General Public License for more details.

You should have received a copy of the GNU General Public License

along with GNU Classpath; see the file COPYING.  If not, write to the

Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301 USA.

Linking this library statically or dynamically with other modules is

making a combined work based on this library.  Thus, the terms and

conditions of the GNU General Public License cover the whole

combination.

As a special exception, the copyright holders of this library give you

permission to link this library with independent modules to produce an

executable, regardless of the license terms of these independent

modules, and to copy and distribute the resulting executable under

terms of your choice, provided that you also meet, for each linked

independent module, the terms and conditions of the license of that

module.  An independent module is a module which is not derived from

or based on this library.  If you modify this library, you may extend

this exception to your version of the library, but you are not

obligated to do so.  If you do not wish to do so, delete this

exception statement from your version. */

#include "gnu_xml_libxmlj_transform_GnomeTransformerFactory.h"

#include "gnu_xml_libxmlj_transform_GnomeTransformer.h"

#include "xmlj_dom.h"

#include "xmlj_io.h"

#include "xmlj_error.h"

#include "xmlj_node.h"

#include "xmlj_sax.h"

#include "xmlj_util.h"

#include <math.h>

#include <stdarg.h>

#include <stdio.h>

#include <string.h>

#include <libxml/xmlmemory.h>

#include <libxml/debugXML.h>

#include <libxml/xmlIO.h>

#include <libxml/xinclude.h>

#include <libxml/parser.h>

#include <libxml/catalog.h>

#include <libxslt/keys.h>

#include <libxslt/xslt.h>

#include <libxslt/xsltInternals.h>

#include <libxslt/transform.h>

#include <libxslt/xsltutils.h>

#include <libxslt/functions.h>

#include <libxslt/extensions.h>

#include <libxslt/documents.h>

/* Local function prototypes */

void

xmljDocumentFunction (xmlXPathParserContextPtr ctxt, int nargs);

xsltStylesheetPtr

xmljGetStylesheetID (JNIEnv * env, jobject transformer);

jobject

xmljGetTransformerProperties (JNIEnv *env, jobject transformer);

const xmlChar *

xmljBooleanToString (int value);

void

xmljSetOutputProperties (JNIEnv *env, jobject transformer,

                         xsltStylesheetPtr stylesheet);

jobjectArray

xmljGetParameterArray (JNIEnv *env, jobject transformer);

const char **

xmljGetParameters (JNIEnv *env, jobjectArray pa);

void

xmljFreeParameters (JNIEnv *env, jobjectArray pa, const char **parameters);

xmlDocPtr

xmljTransform (JNIEnv *env, jobject transformer, xmlDocPtr source);

void

xmljTransformToSAX (JNIEnv *env, jobject transformer, xmlDocPtr source,

                    jobject callback);

xmlDocPtr

xmljDocLoader (const xmlChar *uri, xmlDictPtr dict, int options,

               void *ctxt, xsltLoadType type);

/* HACK: store stylesheet URL as context for resolving URIs in xmljDocLoader */

static jstring stylesheetURL = NULL;

/*

 * --------------------------------------------------------------------------

 *

 * Native implementation for class

 * gnu.xml.libxmlj.transform.GnomeTransformer follows.

 */

static void

xmljSetProperty (JNIEnv * env, jobject outputProperties,

                 jmethodID setPropertyMethodID, const char *name,

                 const xmlChar * value)

{

  if (NULL != value)

    {

      jstring nameString = (*env)->NewStringUTF (env, name);

      jstring valueString = (*env)->NewStringUTF (env, (const char *) value);

      jobject prevValue = (*env)->CallObjectMethod (env, outputProperties,

                                                    setPropertyMethodID,

                                                    nameString, valueString);

      if (NULL != prevValue)

        {

          (*env)->DeleteLocalRef (env, prevValue);

        }

      (*env)->DeleteLocalRef (env, nameString);

      (*env)->DeleteLocalRef (env, valueString);

    }

}

typedef struct CdataSectionScannerInfo_

{

  JNIEnv *env;

  jobject stringBuffer;

  jmethodID appendMethodID;

  int isFirst;

} CdataSectionScannerInfo;

static void

cdataSectionScanner (void *payload, void *data, xmlChar * name)

{

  CdataSectionScannerInfo *info = (CdataSectionScannerInfo *) data;

  JNIEnv *env = info->env;

  jstring nameString = (*env)->NewStringUTF (env, (const char *) name);

  jstring blankString = (*env)->NewStringUTF (env, " ");

  jobject stringBuffer;

  if (!info->isFirst)

    {

      stringBuffer

        = (*env)->CallObjectMethod (env,

                                    info->stringBuffer,

                                    info->appendMethodID, blankString);

      (*env)->DeleteLocalRef (env, stringBuffer);

    }

  info->isFirst = 0;

  stringBuffer

    = (*env)->CallObjectMethod (env,

                                info->stringBuffer,

                                info->appendMethodID, nameString);

  (*env)->DeleteLocalRef (env, stringBuffer);

  (*env)->DeleteLocalRef (env, blankString);

  (*env)->DeleteLocalRef (env, nameString);

}

void

xmljDocumentFunction (xmlXPathParserContextPtr ctxt, int nargs)

{

  xmlXPathObjectPtr obj, obj2 = NULL;

  if ((nargs < 1) || (nargs > 2))

    {

      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,

                          "document() : invalid number of args %d\n", nargs);

      ctxt->error = XPATH_INVALID_ARITY;

      return;

    }

  if (ctxt->value == NULL)

    {

      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,

                          "document() : invalid arg value\n");

      ctxt->error = XPATH_INVALID_TYPE;

      return;

    }

  if (nargs == 2)

    {

      if (ctxt->value->type != XPATH_NODESET)

        {

          xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,

                              "document() : invalid arg expecting a nodeset\n");

          ctxt->error = XPATH_INVALID_TYPE;

          return;

        }

      obj2 = valuePop (ctxt);

    }

  if (ctxt->value->type == XPATH_NODESET)

    {

      int i;

      xmlXPathObjectPtr newobj, ret;

      obj = valuePop (ctxt);

      ret = xmlXPathNewNodeSet (NULL);

      if (obj->nodesetval)

        {

          for (i = 0; i < obj->nodesetval->nodeNr; i++)

            {

              valuePush (ctxt,

                         xmlXPathNewNodeSet (obj->nodesetval->nodeTab[i]));

              xmlXPathStringFunction (ctxt, 1);

              if (nargs == 2)

                {

                  valuePush (ctxt, xmlXPathObjectCopy (obj2));

                }

              else

                {

                  valuePush (ctxt,

                             xmlXPathNewNodeSet (obj->nodesetval->

                                                 nodeTab[i]));

                }

              xsltDocumentFunction (ctxt, 2);

              newobj = valuePop (ctxt);

              ret->nodesetval = xmlXPathNodeSetMerge (ret->nodesetval,

                                                      newobj->nodesetval);

              xmlXPathFreeObject (newobj);

            }

        }

      xmlXPathFreeObject (obj);

      if (obj2 != NULL)

        {

          xmlXPathFreeObject (obj2);

        }

      valuePush (ctxt, ret);

      return;

    }

  /*

   * Make sure it's converted to a string

   */

  xmlXPathStringFunction (ctxt, 1);

  if (ctxt->value->type != XPATH_STRING)

    {

      xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,

                          "document() : invalid arg expecting a string\n");

      ctxt->error = XPATH_INVALID_TYPE;

      if (obj2 != NULL)

        xmlXPathFreeObject (obj2);

      return;

    }

  obj = valuePop (ctxt);

  if (obj->stringval == NULL)

    {

      valuePush (ctxt, xmlXPathNewNodeSet (NULL));

    }

  else

    {

      xsltTransformContextPtr tctxt;

      tctxt = xsltXPathGetTransformContext (ctxt);

      {

        SAXParseContext *saxContext =

          (SAXParseContext *) tctxt->style->_private;

        xmlDocPtr tree = xmljResolveURIAndOpen (saxContext,

                                                (const char*)obj->stringval,

                                                NULL);

        xsltNewDocument (tctxt, tree);  /* FIXME - free at a later point */

        valuePush (ctxt, xmlXPathNewNodeSet ((xmlNodePtr) tree));

      }

    }

  xmlXPathFreeObject (obj);

  if (obj2 != NULL) {

    xmlXPathFreeObject (obj2);

  }

}

/*

 * Returns the stylesheet pointer for the given GnomeTransformer.

 */

xsltStylesheetPtr

xmljGetStylesheetID (JNIEnv * env, jobject transformer)

{

  jclass cls;

  jfieldID field;

  jobject id;

  xsltStylesheetPtr stylesheet;

  if (transformer == NULL)

    {

      xmljThrowException (env, "javax/xml/transform/TransformerException",

                          "Transformer is null");

      return NULL;

    }

  cls = (*env)->GetObjectClass (env, transformer);

  if (cls == NULL)

    {

      return NULL;

    }

  field = (*env)->GetFieldID (env, cls, "stylesheet", "Ljava/lang/Object;");

  if (field == NULL)

    {

      return NULL;

    }

  id = (*env)->GetObjectField (env, transformer, field);

  stylesheet = (xsltStylesheetPtr) xmljAsPointer (env, id);

  if (stylesheet == NULL)

    {

      xmljThrowException (env, "javax/xml/transform/TransformerException",

                          "Stylesheet is null");

      return NULL;

    }

  return stylesheet;

}

jobject

xmljGetTransformerProperties (JNIEnv *env, jobject transformer)

{

  jclass cls;

  jfieldID field;

  cls = (*env)->GetObjectClass (env, transformer);

  if (cls == NULL)

    {

      return NULL;

    }

  field = (*env)->GetFieldID (env, cls, "outputProperties",

                              "Ljava/util/Properties;");

  if (field == NULL)

    {

      return NULL;

    }

  return (*env)->GetObjectField (env, transformer, field);

}

const xmlChar *

xmljBooleanToString (int value)

{

  return value ? BAD_CAST "yes" : BAD_CAST "no";

}

/*

 * Sets the output properties for the given transformer,

 * based on its stylesheet.

 */

void

xmljSetOutputProperties (JNIEnv *env, jobject transformer,

                         xsltStylesheetPtr stylesheet)

{

  jobject outputProperties;

  jclass propertiesClass;

  jmethodID setPropertyMethod;

  outputProperties = xmljGetTransformerProperties (env, transformer);

  if (outputProperties == NULL)

    {

      return;

    }

  propertiesClass = (*env)->FindClass (env, "java/util/Properties");

  if (propertiesClass == NULL)

    {

      return;

    }

  setPropertyMethod =

    (*env)->GetMethodID (env, propertiesClass, "setProperty",

                         "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;");

  if (setPropertyMethod == NULL)

    {

      return;

    }

  xmljSetProperty (env, outputProperties, setPropertyMethod,

                   "encoding", stylesheet->encoding);

  xmljSetProperty (env, outputProperties, setPropertyMethod,

                   "media-type", stylesheet->mediaType);

  xmljSetProperty (env, outputProperties, setPropertyMethod,

                   "doctype-public", stylesheet->doctypePublic);

  xmljSetProperty (env, outputProperties, setPropertyMethod,

                   "doctype-system", stylesheet->doctypeSystem);

  xmljSetProperty (env, outputProperties, setPropertyMethod,

                   "indent", xmljBooleanToString (stylesheet->indent));

  xmljSetProperty (env, outputProperties, setPropertyMethod,

                   "method", stylesheet->method);

  xmljSetProperty (env, outputProperties, setPropertyMethod,

                   "standalone", xmljBooleanToString (stylesheet->standalone));

  xmljSetProperty (env, outputProperties, setPropertyMethod,

                   "version", stylesheet->version);

  xmljSetProperty (env, outputProperties, setPropertyMethod,

                   "omit-xml-declaration",

                   xmljBooleanToString (stylesheet->omitXmlDeclaration));

    {

      CdataSectionScannerInfo info;

      jclass stringBufferClass

        =

        (*env)->FindClass (env,

                           "java/lang/StringBuffer");

      jmethodID stringBufferConstructorID =

        (*env)->GetMethodID (env, stringBufferClass,

                             "<init>", "()V");

      jmethodID toStringMethodID =

        (*env)->GetMethodID (env, stringBufferClass,

                             "toString",

                             "()Ljava/lang/String;");

      info.env = env;

      info.isFirst = 1;

      info.stringBuffer

        = (*env)->AllocObject (env, stringBufferClass);

      (*env)->CallVoidMethod (env, info.stringBuffer,

                              stringBufferConstructorID);

      info.appendMethodID =

        (*env)->GetMethodID (env, stringBufferClass,

                             "append",

                             "(Ljava/lang/String;)Ljava/lang/StringBuffer;");

      xmlHashScan (stylesheet->cdataSection,

                   cdataSectionScanner, &info);

        {

          jstring result = (jstring)

            (*env)->CallObjectMethod (env,

                                      info.stringBuffer,

                                      toStringMethodID);

          jstring nameString =

            (*env)->NewStringUTF (env,

                                  "cdata-section-elements");

          jobject prevValue

            =

            (*env)->CallObjectMethod (env,

                                      outputProperties,

                                      setPropertyMethod,

                                      nameString, result);

          if (NULL != prevValue)

            {

              (*env)->DeleteLocalRef (env, prevValue);

            }

          (*env)->DeleteLocalRef (env, nameString);

        }

      (*env)->DeleteLocalRef (env, info.stringBuffer);

    }

}

/*

 * Returns the parameter array for the given GnomeTransformer.

 */

jobjectArray

xmljGetParameterArray (JNIEnv *env, jobject transformer)

{

  jclass cls;

  jmethodID method;

  cls = (*env)->GetObjectClass (env, transformer);

  if (cls == NULL)

    {

      return NULL;

    }

  method = (*env)->GetMethodID (env, cls, "getParameterArray",

                                "()[Ljava/lang/String;");

  if (method == NULL)

    {

      return NULL;

    }

  return (jobjectArray) (*env)->CallObjectMethod (env, transformer, method);

}

/* Convert parameter array to xmlChar ** */

const char **

xmljGetParameters (JNIEnv *env, jobjectArray pa)

{

  int i, len;

  const char **parameters;

  len = (*env)->GetArrayLength (env, pa);

  parameters = (const char **) malloc ((len + 2) * sizeof (const char *));

  if (parameters == NULL)

    {

      return NULL;

    }

  for (i = 0; i < len; i++)

    {

      jstring string = (jstring) (*env)->GetObjectArrayElement (env, pa, i);

      if (string != NULL)

        {

          parameters[i] = (*env)->GetStringUTFChars (env, string, NULL);

        }

      else

        {

          parameters[i] = NULL;

        }

    }

  parameters[len] = 0;

  parameters[len + 1] = 0;

  return parameters;

}

/* Release parameter strings */

void

xmljFreeParameters (JNIEnv *env, jobjectArray pa, const char **parameters)

{

  int i, len;

  len = (*env)->GetArrayLength (env, pa);

  for (i = 0; i < len; i++)

    {

      jstring string = (jstring) (*env)->GetObjectArrayElement (env, pa, i);

      if (string != NULL)

        {

          (*env)->ReleaseStringUTFChars (env, string, parameters[i]);

        }

    }

  free (parameters);

}

xmlDocPtr

xmljTransform (JNIEnv *env, jobject transformer, xmlDocPtr source)

{

  xsltStylesheetPtr stylesheet;

  xmlDocPtr result;

  jobjectArray pa;

  const char **parameters;

  stylesheet = xmljGetStylesheetID (env, transformer);

  pa = xmljGetParameterArray (env, transformer);

  parameters = xmljGetParameters (env, pa);

  if (parameters == NULL)

    {

      xmljThrowException (env, "javax/xml/transform/TransformerException",

                          "Couldn't allocate memory for parameters");

      return NULL;

    }

  result = xsltApplyStylesheet (stylesheet, source, parameters);

  xmljFreeParameters (env, pa, parameters);

  if (result == NULL)

    {

      xmljThrowException (env, "javax/xml/transform/TransformerException",

                          "XSLT transformation failed");

    }

  return result;

}

void

xmljTransformToSAX (JNIEnv *env, jobject transformer, xmlDocPtr source,

                    jobject callback)

{

  xsltStylesheetPtr stylesheet;

  int ret;

  jobjectArray pa;

  const char **parameters;

  xmlSAXHandlerPtr sax;

  stylesheet = xmljGetStylesheetID (env, transformer);

  pa = xmljGetParameterArray (env, transformer);

  parameters = xmljGetParameters (env, pa);

  if (parameters == NULL)

    {

      xmljThrowException (env, "javax/xml/transform/TransformerException",

                          "Couldn't allocate memory for parameters");

      return;

    }

  sax = NULL; /* TODO link up sax and callback */

  ret = xsltRunStylesheet (stylesheet, source, parameters, NULL, sax, NULL);

  xmljFreeParameters (env, pa, parameters);

  if (ret == -1)

    {

      xmljThrowException (env, "javax/xml/transform/TransformerException",

                          "XSLT transformation failed");

    }

}

xmlDocPtr

xmljDocLoader (const xmlChar *uri, xmlDictPtr dict, int options,

               void *ctxt, xsltLoadType type)

{

  JNIEnv *env;

  jclass xmljClass;

  jclass inputStreamClass;

  jmethodID getInputStream;

  jmethodID getDetectBuffer;

  jstring systemId;

  jobject inputStream;

  jbyteArray detectBuffer;

  fflush(stdout);

  env = xmljGetJNIEnv ();

  if (!env)

    {

      return NULL;

    }

  xmljClass = (*env)->FindClass (env, "gnu/xml/libxmlj/util/XMLJ");

  if (!xmljClass)

    {

      return NULL;

    }

  getInputStream =

    (*env)->GetStaticMethodID (env, xmljClass, "xmljGetInputStream",

                               "(Ljava/lang/String;Ljava/lang/String;)Lgnu/xml/libxmlj/util/NamedInputStream;");

  if (!getInputStream)

    {

      return NULL;

    }

  systemId = xmljNewString (env, uri);

  inputStream = (*env)->CallStaticObjectMethod (env, xmljClass, getInputStream,

                                                stylesheetURL, systemId);

  if (!inputStream)

    {

      return NULL;

    }

  inputStreamClass = (*env)->GetObjectClass (env, inputStream);

  if (!inputStreamClass)

    {

      return NULL;

    }

  getDetectBuffer = (*env)->GetMethodID (env, inputStreamClass,

                                         "getDetectBuffer", "()[B");

  if (!getDetectBuffer)

    {

      return NULL;

    }

  detectBuffer = (*env)->CallObjectMethod (env, inputStream, getDetectBuffer);

  if (!detectBuffer)

    {

      return NULL;

    }

  return xmljParseDocument (env, NULL, inputStream, detectBuffer,

                            NULL, systemId, stylesheetURL,

                            0, 0, 0, 0, 0, 0, 0, 0, 0, 2);

}

/* GnomeTransformer.newStylesheet */

JNIEXPORT jobject JNICALL

Java_gnu_xml_libxmlj_transform_GnomeTransformer_newStylesheet (JNIEnv *env,

                                                               jobject self)

{

  xsltStylesheetPtr stylesheet;

  jobject ret;

  stylesheetURL = NULL;

  xsltSetLoaderFunc (xmljDocLoader);

  stylesheet = xsltNewStylesheet ();

  xmljSetOutputProperties (env, self, stylesheet);

  ret = xmljAsField (env, stylesheet);

  if (ret == NULL)

    {

      xmljThrowException (env,

                          "javax/xml/transform/TransformerConfigurationException",

                          "Can't create Java object for stylesheet");

    }

  return ret;

}

/* GnomeTransformer.newStylesheetFromStream */