869 lines
25 KiB
C
869 lines
25 KiB
C
/* 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 ();
|
|
}
|
|
|