| /* 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 */ |
| JNIEXPORT jobject JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformer_newStylesheetFromStream |
| (JNIEnv *env, jobject self, jobject in, jbyteArray detectBuffer, |
| jstring publicId, jstring systemId, jstring base, |
| jboolean entityResolver, jboolean errorHandler) |
| { |
| xmlDocPtr doc; |
| xsltStylesheetPtr stylesheet; |
| jobject ret; |
| |
| doc = xmljParseDocument (env, self, in, detectBuffer, publicId, systemId, |
| base, 0, 0, 0, 0, 0, |
| entityResolver, errorHandler, 0, 0, 2); |
| if (doc == NULL) |
| { |
| return NULL; |
| } |
| stylesheetURL = systemId; |
| xsltSetLoaderFunc (xmljDocLoader); |
| stylesheet = xsltParseStylesheetDoc (doc); |
| if (stylesheet == NULL) |
| { |
| xmljThrowException (env, |
| "javax/xml/transform/TransformerConfigurationException", |
| "Error parsing XSLT stylesheet"); |
| return NULL; |
| } |
| 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.newStylesheetFromDoc */ |
| JNIEXPORT jobject JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformer_newStylesheetFromDoc |
| (JNIEnv *env, jobject self, jobject in) |
| { |
| xmlDocPtr doc; |
| xsltStylesheetPtr stylesheet; |
| jobject ret; |
| |
| doc = (xmlDocPtr) xmljGetNodeID (env, in); |
| if (doc == NULL) |
| { |
| return NULL; |
| } |
| stylesheetURL = xmljNewString (env, doc->URL); |
| xsltSetLoaderFunc (xmljDocLoader); |
| stylesheet = xsltParseStylesheetDoc (doc); |
| if (stylesheet == NULL) |
| { |
| xmljThrowException (env, |
| "javax/xml/transform/TransformerConfigurationException", |
| "Error parsing XSLT stylesheet"); |
| } |
| 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.transformStreamToStream */ |
| JNIEXPORT void JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformStreamToStream |
| (JNIEnv *env, jobject self, jobject in, jbyteArray detectBuffer, |
| jstring publicId, jstring systemId, jstring base, |
| jboolean entityResolver, jboolean errorHandler, jobject out) |
| { |
| xmlDocPtr source; |
| xmlDocPtr result; |
| |
| source = xmljParseDocument (env, self, in, detectBuffer, publicId, systemId, |
| base, 0, 0, 0, 0, 0, |
| entityResolver, errorHandler, 0, 0, 2); |
| result = xmljTransform (env, self, source); |
| xmljSaveFileToJavaOutputStream (env, out, result, |
| (const char*) result->encoding); |
| xmlFreeDoc (result); |
| } |
| |
| /* GnomeTransformer.transformStreamToDoc */ |
| JNIEXPORT jobject JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformStreamToDoc |
| (JNIEnv *env, jobject self, jobject in, jbyteArray detectBuffer, |
| jstring publicId, jstring systemId, jstring base, |
| jboolean entityResolver, jboolean errorHandler) |
| { |
| xmlDocPtr source; |
| xmlDocPtr result; |
| |
| source = xmljParseDocument (env, self, in, detectBuffer, publicId, systemId, |
| base, 0, 0, 0, 0, 0, |
| entityResolver, errorHandler, 0, 0, 2); |
| result = xmljTransform (env, self, source); |
| return xmljGetNodeInstance (env, (xmlNodePtr) result); |
| } |
| |
| /* GnomeTransformer.transformStreamToSAX */ |
| JNIEXPORT void JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformStreamToSAX |
| (JNIEnv *env, jobject self, jobject in, jbyteArray detectBuffer, |
| jstring publicId, jstring systemId, jstring base, |
| jboolean entityResolver, jboolean errorHandler, jobject callback) |
| { |
| xmlDocPtr source; |
| |
| source = xmljParseDocument (env, self, in, detectBuffer, publicId, systemId, |
| base, 0, 0, 0, 0, 0, |
| entityResolver, errorHandler, 0, 0, 2); |
| xmljTransformToSAX (env, self, source, callback); |
| } |
| |
| /* GnomeTransformer.transformDocToStream */ |
| JNIEXPORT void JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformDocToStream |
| (JNIEnv *env, jobject self, jobject doc, jobject out) |
| { |
| xmlDocPtr source; |
| xmlDocPtr result; |
| |
| source = (xmlDocPtr) xmljGetNodeID (env, doc); |
| result = xmljTransform (env, self, source); |
| xmljSaveFileToJavaOutputStream (env, out, result, |
| (const char*) result->encoding); |
| xmlFreeDoc (result); |
| } |
| |
| /* GnomeTransformer.transformDocToDoc */ |
| JNIEXPORT jobject JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformDocToDoc |
| (JNIEnv *env, jobject self, jobject doc) |
| { |
| xmlDocPtr source; |
| xmlDocPtr result; |
| |
| source = (xmlDocPtr) xmljGetNodeID (env, doc); |
| result = xmljTransform (env, self, source); |
| return xmljGetNodeInstance (env, (xmlNodePtr) result); |
| } |
| |
| /* GnomeTransformer.transformDocToSAX */ |
| JNIEXPORT void JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformDocToSAX |
| (JNIEnv *env, jobject self, jobject doc, jobject callback) |
| { |
| xmlDocPtr source; |
| |
| source = (xmlDocPtr) xmljGetNodeID (env, doc); |
| xmljTransformToSAX (env, self, source, callback); |
| } |
| |
| /* GnomeTransformer.free */ |
| JNIEXPORT void JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformer_free (JNIEnv *env, |
| jobject self) |
| { |
| xsltStylesheetPtr stylesheet; |
| |
| stylesheet = xmljGetStylesheetID (env, self); |
| xsltFreeStylesheet (stylesheet); |
| } |
| |
| /* |
| * -------------------------------------------------------------------------- |
| * Native implementation for class |
| * gnu.xml.libxmlj.transform.GnomeTransformerFactory follows. |
| */ |
| |
| /* GnomeTransformerFactory.freeLibxsltGlobal */ |
| JNIEXPORT void JNICALL |
| Java_gnu_xml_libxmlj_transform_GnomeTransformerFactory_freeLibxsltGlobal ( |
| JNIEnv *env __attribute__((__unused__)), |
| jclass clazz __attribute__((__unused__))) |
| { |
| xsltCleanupGlobals (); |
| xmlCleanupParser (); |
| } |
| |
