gomp-20050608-branch/libjava/classpath/native/jni/xmlj/xmlj_transform.c

   1 /* xmlj_transform.c -
   2    Copyright (C) 2003, 2004 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 #include "gnu_xml_libxmlj_transform_GnomeTransformerFactory.h"
  39 #include "gnu_xml_libxmlj_transform_GnomeTransformer.h"
  40
  41 #include "xmlj_dom.h"
  42 #include "xmlj_io.h"
  43 #include "xmlj_error.h"
  44 #include "xmlj_node.h"
  45 #include "xmlj_sax.h"
  46 #include "xmlj_util.h"
  47
  48 #include <math.h>
  49 #include <stdarg.h>
  50 #include <stdio.h>
  51 #include <string.h>
  52
  53 #include <libxml/xmlmemory.h>
  54 #include <libxml/debugXML.h>
  55 #include <libxml/xmlIO.h>
  56 #include <libxml/xinclude.h>
  57 #include <libxml/parser.h>
  58 #include <libxml/catalog.h>
  59 #include <libxslt/keys.h>
  60 #include <libxslt/xslt.h>
  61 #include <libxslt/xsltInternals.h>
  62 #include <libxslt/transform.h>
  63 #include <libxslt/xsltutils.h>
  64 #include <libxslt/functions.h>
  65 #include <libxslt/extensions.h>
  66 #include <libxslt/documents.h>
  67
  68 /* Local function prototypes */
  69
  70 void
  71 xmljDocumentFunction (xmlXPathParserContextPtr ctxt, int nargs);
  72
  73 xsltStylesheetPtr
  74 xmljGetStylesheetID (JNIEnv * env, jobject transformer);
  75
  76 jobject
  77 xmljGetTransformerProperties (JNIEnv *env, jobject transformer);
  78
  79 const xmlChar *
  80 xmljBooleanToString (int value);
  81
  82 void
  83 xmljSetOutputProperties (JNIEnv *env, jobject transformer,
  84                          xsltStylesheetPtr stylesheet);
  85
  86 jobjectArray
  87 xmljGetParameterArray (JNIEnv *env, jobject transformer);
  88
  89 const char **
  90 xmljGetParameters (JNIEnv *env, jobjectArray pa);
  91
  92 void
  93 xmljFreeParameters (JNIEnv *env, jobjectArray pa, const char **parameters);
  94
  95 xmlDocPtr
  96 xmljTransform (JNIEnv *env, jobject transformer, xmlDocPtr source);
  97
  98 void
  99 xmljTransformToSAX (JNIEnv *env, jobject transformer, xmlDocPtr source,
 100                     jobject callback);
 101
 102 xmlDocPtr
 103 xmljDocLoader (const xmlChar *uri, xmlDictPtr dict, int options,
 104                void *ctxt, xsltLoadType type);
 105
 106 /* HACK: store stylesheet URL as context for resolving URIs in xmljDocLoader */
 107 static jstring stylesheetURL = NULL;
 108
 109 /*
 110  * --------------------------------------------------------------------------
 111  *
 112  * Native implementation for class
 113  * gnu.xml.libxmlj.transform.GnomeTransformer follows.
 114  */
 115
 116 static void
 117 xmljSetProperty (JNIEnv * env, jobject outputProperties,
 118                  jmethodID setPropertyMethodID, const char *name,
 119                  const xmlChar * value)
 120 {
 121   if (NULL != value)
 122     {
 123       jstring nameString = (*env)->NewStringUTF (env, name);
 124       jstring valueString = (*env)->NewStringUTF (env, (const char *) value);
 125
 126       jobject prevValue = (*env)->CallObjectMethod (env, outputProperties,
 127                                                     setPropertyMethodID,
 128                                                     nameString, valueString);
 129       if (NULL != prevValue)
 130         {
 131           (*env)->DeleteLocalRef (env, prevValue);
 132         }
 133
 134       (*env)->DeleteLocalRef (env, nameString);
 135       (*env)->DeleteLocalRef (env, valueString);
 136     }
 137 }
 138
 139 typedef struct CdataSectionScannerInfo_
 140 {
 141   JNIEnv *env;
 142   jobject stringBuffer;
 143   jmethodID appendMethodID;
 144   int isFirst;
 145 } CdataSectionScannerInfo;
 146
 147 static void
 148 cdataSectionScanner (void *payload, void *data, xmlChar * name)
 149 {
 150   CdataSectionScannerInfo *info = (CdataSectionScannerInfo *) data;
 151   JNIEnv *env = info->env;
 152   jstring nameString = (*env)->NewStringUTF (env, (const char *) name);
 153   jstring blankString = (*env)->NewStringUTF (env, " ");
 154   jobject stringBuffer;
 155   if (!info->isFirst)
 156     {
 157       stringBuffer
 158         = (*env)->CallObjectMethod (env,
 159                                     info->stringBuffer,
 160                                     info->appendMethodID, blankString);
 161       (*env)->DeleteLocalRef (env, stringBuffer);
 162     }
 163   info->isFirst = 0;
 164   stringBuffer
 165     = (*env)->CallObjectMethod (env,
 166                                 info->stringBuffer,
 167                                 info->appendMethodID, nameString);
 168   (*env)->DeleteLocalRef (env, stringBuffer);
 169   (*env)->DeleteLocalRef (env, blankString);
 170   (*env)->DeleteLocalRef (env, nameString);
 171 }
 172
 173 void
 174 xmljDocumentFunction (xmlXPathParserContextPtr ctxt, int nargs)
 175 {
 176   xmlXPathObjectPtr obj, obj2 = NULL;
 177
 178   if ((nargs < 1) || (nargs > 2))
 179     {
 180       xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
 181                           "document() : invalid number of args %d\n", nargs);
 182       ctxt->error = XPATH_INVALID_ARITY;
 183       return;
 184     }
 185   if (ctxt->value == NULL)
 186     {
 187       xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
 188                           "document() : invalid arg value\n");
 189       ctxt->error = XPATH_INVALID_TYPE;
 190       return;
 191     }
 192
 193   if (nargs == 2)
 194     {
 195       if (ctxt->value->type != XPATH_NODESET)
 196         {
 197           xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
 198                               "document() : invalid arg expecting a nodeset\n");
 199           ctxt->error = XPATH_INVALID_TYPE;
 200           return;
 201         }
 202
 203       obj2 = valuePop (ctxt);
 204     }
 205
 206   if (ctxt->value->type == XPATH_NODESET)
 207     {
 208       int i;
 209       xmlXPathObjectPtr newobj, ret;
 210
 211       obj = valuePop (ctxt);
 212       ret = xmlXPathNewNodeSet (NULL);
 213
 214       if (obj->nodesetval)
 215         {
 216           for (i = 0; i < obj->nodesetval->nodeNr; i++)
 217             {
 218               valuePush (ctxt,
 219                          xmlXPathNewNodeSet (obj->nodesetval->nodeTab[i]));
 220               xmlXPathStringFunction (ctxt, 1);
 221               if (nargs == 2)
 222                 {
 223                   valuePush (ctxt, xmlXPathObjectCopy (obj2));
 224                 }
 225               else
 226                 {
 227                   valuePush (ctxt,
 228                              xmlXPathNewNodeSet (obj->nodesetval->
 229                                                  nodeTab[i]));
 230                 }
 231               xsltDocumentFunction (ctxt, 2);
 232               newobj = valuePop (ctxt);
 233               ret->nodesetval = xmlXPathNodeSetMerge (ret->nodesetval,
 234                                                       newobj->nodesetval);
 235               xmlXPathFreeObject (newobj);
 236             }
 237         }
 238
 239       xmlXPathFreeObject (obj);
 240       if (obj2 != NULL)
 241         {
 242           xmlXPathFreeObject (obj2);
 243         }
 244       valuePush (ctxt, ret);
 245       return;
 246     }
 247   /*
 248    * Make sure it's converted to a string
 249    */
 250   xmlXPathStringFunction (ctxt, 1);
 251   if (ctxt->value->type != XPATH_STRING)
 252     {
 253       xsltTransformError (xsltXPathGetTransformContext (ctxt), NULL, NULL,
 254                           "document() : invalid arg expecting a string\n");
 255       ctxt->error = XPATH_INVALID_TYPE;
 256       if (obj2 != NULL)
 257         xmlXPathFreeObject (obj2);
 258       return;
 259     }
 260   obj = valuePop (ctxt);
 261   if (obj->stringval == NULL)
 262     {
 263       valuePush (ctxt, xmlXPathNewNodeSet (NULL));
 264     }
 265   else
 266     {
 267
 268       xsltTransformContextPtr tctxt;
 269
 270       tctxt = xsltXPathGetTransformContext (ctxt);
 271
 272       {
 273         SAXParseContext *saxContext =
 274           (SAXParseContext *) tctxt->style->_private;
 275
 276         xmlDocPtr tree = xmljResolveURIAndOpen (saxContext,
 277                                                 (const char*)obj->stringval,
 278                                                 NULL);
 279
 280         xsltNewDocument (tctxt, tree);  /* FIXME - free at a later point */
 281
 282         valuePush (ctxt, xmlXPathNewNodeSet ((xmlNodePtr) tree));
 283       }
 284     }
 285   xmlXPathFreeObject (obj);
 286   if (obj2 != NULL) {
 287     xmlXPathFreeObject (obj2);
 288   }
 289 }
 290
 291 /*
 292  * Returns the stylesheet pointer for the given GnomeTransformer.
 293  */
 294 xsltStylesheetPtr
 295 xmljGetStylesheetID (JNIEnv * env, jobject transformer)
 296 {
 297   jclass cls;
 298   jfieldID field;
 299   jobject id;
 300   xsltStylesheetPtr stylesheet;
 301
 302   if (transformer == NULL)
 303     {
 304       xmljThrowException (env, "javax/xml/transform/TransformerException",
 305                           "Transformer is null");
 306       return NULL;
 307     }
 308   cls = (*env)->GetObjectClass (env, transformer);
 309   if (cls == NULL)
 310     {
 311       return NULL;
 312     }
 313   field = (*env)->GetFieldID (env, cls, "stylesheet", "Ljava/lang/Object;");
 314   if (field == NULL)
 315     {
 316       return NULL;
 317     }
 318   id = (*env)->GetObjectField (env, transformer, field);
 319   stylesheet = (xsltStylesheetPtr) xmljAsPointer (env, id);
 320   if (stylesheet == NULL)
 321     {
 322       xmljThrowException (env, "javax/xml/transform/TransformerException",
 323                           "Stylesheet is null");
 324       return NULL;
 325     }
 326   return stylesheet;
 327 }
 328
 329 jobject
 330 xmljGetTransformerProperties (JNIEnv *env, jobject transformer)
 331 {
 332   jclass cls;
 333   jfieldID field;
 334
 335   cls = (*env)->GetObjectClass (env, transformer);
 336   if (cls == NULL)
 337     {
 338       return NULL;
 339     }
 340   field = (*env)->GetFieldID (env, cls, "outputProperties",
 341                               "Ljava/util/Properties;");
 342   if (field == NULL)
 343     {
 344       return NULL;
 345     }
 346   return (*env)->GetObjectField (env, transformer, field);
 347 }
 348
 349 const xmlChar *
 350 xmljBooleanToString (int value)
 351 {
 352   return value ? BAD_CAST "yes" : BAD_CAST "no";
 353 }
 354
 355 /*
 356  * Sets the output properties for the given transformer,
 357  * based on its stylesheet.
 358  */
 359 void
 360 xmljSetOutputProperties (JNIEnv *env, jobject transformer,
 361                          xsltStylesheetPtr stylesheet)
 362 {
 363   jobject outputProperties;
 364   jclass propertiesClass;
 365   jmethodID setPropertyMethod;
 366
 367   outputProperties = xmljGetTransformerProperties (env, transformer);
 368   if (outputProperties == NULL)
 369     {
 370       return;
 371     }
 372   propertiesClass = (*env)->FindClass (env, "java/util/Properties");
 373   if (propertiesClass == NULL)
 374     {
 375       return;
 376     }
 377   setPropertyMethod =
 378     (*env)->GetMethodID (env, propertiesClass, "setProperty",
 379                          "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;");
 380   if (setPropertyMethod == NULL)
 381     {
 382       return;
 383     }
 384
 385   xmljSetProperty (env, outputProperties, setPropertyMethod,
 386                    "encoding", stylesheet->encoding);
 387
 388   xmljSetProperty (env, outputProperties, setPropertyMethod,
 389                    "media-type", stylesheet->mediaType);
 390
 391   xmljSetProperty (env, outputProperties, setPropertyMethod,
 392                    "doctype-public", stylesheet->doctypePublic);
 393
 394   xmljSetProperty (env, outputProperties, setPropertyMethod,
 395                    "doctype-system", stylesheet->doctypeSystem);
 396
 397   xmljSetProperty (env, outputProperties, setPropertyMethod,
 398                    "indent", xmljBooleanToString (stylesheet->indent));
 399
 400   xmljSetProperty (env, outputProperties, setPropertyMethod,
 401                    "method", stylesheet->method);
 402
 403   xmljSetProperty (env, outputProperties, setPropertyMethod,
 404                    "standalone", xmljBooleanToString (stylesheet->standalone));
 405
 406   xmljSetProperty (env, outputProperties, setPropertyMethod,
 407                    "version", stylesheet->version);
 408
 409   xmljSetProperty (env, outputProperties, setPropertyMethod,
 410                    "omit-xml-declaration",
 411                    xmljBooleanToString (stylesheet->omitXmlDeclaration));
 412
 413     {
 414       CdataSectionScannerInfo info;
 415       jclass stringBufferClass
 416         =
 417         (*env)->FindClass (env,
 418                            "java/lang/StringBuffer");
 419       jmethodID stringBufferConstructorID =
 420         (*env)->GetMethodID (env, stringBufferClass,
 421                              "<init>", "()V");
 422       jmethodID toStringMethodID =
 423         (*env)->GetMethodID (env, stringBufferClass,
 424                              "toString",
 425                              "()Ljava/lang/String;");
 426       info.env = env;
 427       info.isFirst = 1;
 428       info.stringBuffer
 429         = (*env)->AllocObject (env, stringBufferClass);
 430       (*env)->CallVoidMethod (env, info.stringBuffer,
 431                               stringBufferConstructorID);
 432       info.appendMethodID =
 433         (*env)->GetMethodID (env, stringBufferClass,
 434                              "append",
 435                              "(Ljava/lang/String;)Ljava/lang/StringBuffer;");
 436
 437       xmlHashScan (stylesheet->cdataSection,
 438                    cdataSectionScanner, &info);
 439
 440         {
 441           jstring result = (jstring)
 442             (*env)->CallObjectMethod (env,
 443                                       info.stringBuffer,
 444                                       toStringMethodID);
 445
 446           jstring nameString =
 447             (*env)->NewStringUTF (env,
 448                                   "cdata-section-elements");
 449
 450           jobject prevValue
 451             =
 452             (*env)->CallObjectMethod (env,
 453                                       outputProperties,
 454                                       setPropertyMethod,
 455                                       nameString, result);
 456           if (NULL != prevValue)
 457             {
 458               (*env)->DeleteLocalRef (env, prevValue);
 459             }
 460           (*env)->DeleteLocalRef (env, nameString);
 461         }
 462
 463       (*env)->DeleteLocalRef (env, info.stringBuffer);
 464     }
 465 }
 466
 467 /*
 468  * Returns the parameter array for the given GnomeTransformer.
 469  */
 470 jobjectArray
 471 xmljGetParameterArray (JNIEnv *env, jobject transformer)
 472 {
 473   jclass cls;
 474   jmethodID method;
 475
 476   cls = (*env)->GetObjectClass (env, transformer);
 477   if (cls == NULL)
 478     {
 479       return NULL;
 480     }
 481   method = (*env)->GetMethodID (env, cls, "getParameterArray",
 482                                 "()[Ljava/lang/String;");
 483   if (method == NULL)
 484     {
 485       return NULL;
 486     }
 487   return (jobjectArray) (*env)->CallObjectMethod (env, transformer, method);
 488 }
 489
 490 /* Convert parameter array to xmlChar ** */
 491 const char **
 492 xmljGetParameters (JNIEnv *env, jobjectArray pa)
 493 {
 494   int i, len;
 495   const char **parameters;
 496
 497   len = (*env)->GetArrayLength (env, pa);
 498   parameters = (const char **) malloc ((len + 2) * sizeof (const char *));
 499   if (parameters == NULL)
 500     {
 501       return NULL;
 502     }
 503
 504   for (i = 0; i < len; i++)
 505     {
 506       jstring string = (jstring) (*env)->GetObjectArrayElement (env, pa, i);
 507
 508       if (string != NULL)
 509         {
 510           parameters[i] = (*env)->GetStringUTFChars (env, string, NULL);
 511         }
 512       else
 513         {
 514           parameters[i] = NULL;
 515         }
 516     }
 517
 518   parameters[len] = 0;
 519   parameters[len + 1] = 0;
 520   return parameters;
 521 }
 522
 523 /* Release parameter strings */
 524 void
 525 xmljFreeParameters (JNIEnv *env, jobjectArray pa, const char **parameters)
 526 {
 527   int i, len;
 528
 529   len = (*env)->GetArrayLength (env, pa);
 530   for (i = 0; i < len; i++)
 531     {
 532       jstring string = (jstring) (*env)->GetObjectArrayElement (env, pa, i);
 533       if (string != NULL)
 534         {
 535           (*env)->ReleaseStringUTFChars (env, string, parameters[i]);
 536         }
 537     }
 538
 539   free (parameters);
 540 }
 541
 542 xmlDocPtr
 543 xmljTransform (JNIEnv *env, jobject transformer, xmlDocPtr source)
 544 {
 545   xsltStylesheetPtr stylesheet;
 546   xmlDocPtr result;
 547   jobjectArray pa;
 548   const char **parameters;
 549
 550   stylesheet = xmljGetStylesheetID (env, transformer);
 551   pa = xmljGetParameterArray (env, transformer);
 552   parameters = xmljGetParameters (env, pa);
 553   if (parameters == NULL)
 554     {
 555       xmljThrowException (env, "javax/xml/transform/TransformerException",
 556                           "Couldn't allocate memory for parameters");
 557       return NULL;
 558     }
 559   result = xsltApplyStylesheet (stylesheet, source, parameters);
 560   xmljFreeParameters (env, pa, parameters);
 561   if (result == NULL)
 562     {
 563       xmljThrowException (env, "javax/xml/transform/TransformerException",
 564                           "XSLT transformation failed");
 565     }
 566   return result;
 567 }
 568
 569 void
 570 xmljTransformToSAX (JNIEnv *env, jobject transformer, xmlDocPtr source,
 571                     jobject callback)
 572 {
 573   xsltStylesheetPtr stylesheet;
 574   int ret;
 575   jobjectArray pa;
 576   const char **parameters;
 577   xmlSAXHandlerPtr sax;
 578
 579   stylesheet = xmljGetStylesheetID (env, transformer);
 580   pa = xmljGetParameterArray (env, transformer);
 581   parameters = xmljGetParameters (env, pa);
 582   if (parameters == NULL)
 583     {
 584       xmljThrowException (env, "javax/xml/transform/TransformerException",
 585                           "Couldn't allocate memory for parameters");
 586       return;
 587     }
 588   sax = NULL; /* TODO link up sax and callback */
 589   ret = xsltRunStylesheet (stylesheet, source, parameters, NULL, sax, NULL);
 590   xmljFreeParameters (env, pa, parameters);
 591   if (ret == -1)
 592     {
 593       xmljThrowException (env, "javax/xml/transform/TransformerException",
 594                           "XSLT transformation failed");
 595     }
 596 }
 597
 598 xmlDocPtr
 599 xmljDocLoader (const xmlChar *uri, xmlDictPtr dict, int options,
 600                void *ctxt, xsltLoadType type)
 601 {
 602   JNIEnv *env;
 603   jclass xmljClass;
 604   jclass inputStreamClass;
 605   jmethodID getInputStream;
 606   jmethodID getDetectBuffer;
 607   jstring systemId;
 608   jobject inputStream;
 609   jbyteArray detectBuffer;
 610
 611   fflush(stdout);
 612   env = xmljGetJNIEnv ();
 613   if (!env)
 614     {
 615       return NULL;
 616     }
 617   xmljClass = (*env)->FindClass (env, "gnu/xml/libxmlj/util/XMLJ");
 618   if (!xmljClass)
 619     {
 620       return NULL;
 621     }
 622   getInputStream =
 623     (*env)->GetStaticMethodID (env, xmljClass, "xmljGetInputStream",
 624                                "(Ljava/lang/String;Ljava/lang/String;)Lgnu/xml/libxmlj/util/NamedInputStream;");
 625   if (!getInputStream)
 626     {
 627       return NULL;
 628     }
 629   systemId = xmljNewString (env, uri);
 630   inputStream = (*env)->CallStaticObjectMethod (env, xmljClass, getInputStream,
 631                                                 stylesheetURL, systemId);
 632   if (!inputStream)
 633     {
 634       return NULL;
 635     }
 636   inputStreamClass = (*env)->GetObjectClass (env, inputStream);
 637   if (!inputStreamClass)
 638     {
 639       return NULL;
 640     }
 641   getDetectBuffer = (*env)->GetMethodID (env, inputStreamClass,
 642                                          "getDetectBuffer", "()[B");
 643   if (!getDetectBuffer)
 644     {
 645       return NULL;
 646     }
 647   detectBuffer = (*env)->CallObjectMethod (env, inputStream, getDetectBuffer);
 648   if (!detectBuffer)
 649     {
 650       return NULL;
 651     }
 652   return xmljParseDocument (env, NULL, inputStream, detectBuffer,
 653                             NULL, systemId, stylesheetURL,
 654                             0, 0, 0, 0, 0, 0, 0, 0, 0, 2);
 655 }
 656
 657 /* GnomeTransformer.newStylesheet */
 658 JNIEXPORT jobject JNICALL
 659 Java_gnu_xml_libxmlj_transform_GnomeTransformer_newStylesheet (JNIEnv *env,
 660                                                                jobject self)
 661 {
 662   xsltStylesheetPtr stylesheet;
 663   jobject ret;
 664
 665   stylesheetURL = NULL;
 666   xsltSetLoaderFunc (xmljDocLoader);
 667   stylesheet = xsltNewStylesheet ();
 668   xmljSetOutputProperties (env, self, stylesheet);
 669   ret = xmljAsField (env, stylesheet);
 670   if (ret == NULL)
 671     {
 672       xmljThrowException (env,
 673                           "javax/xml/transform/TransformerConfigurationException",
 674                           "Can't create Java object for stylesheet");
 675     }
 676   return ret;
 677 }
 678
 679 /* GnomeTransformer.newStylesheetFromStream */
 680 JNIEXPORT jobject JNICALL
 681 Java_gnu_xml_libxmlj_transform_GnomeTransformer_newStylesheetFromStream
 682 (JNIEnv *env, jobject self, jobject in, jbyteArray detectBuffer,
 683  jstring publicId, jstring systemId, jstring base,
 684  jboolean entityResolver, jboolean errorHandler)
 685 {
 686   xmlDocPtr doc;
 687   xsltStylesheetPtr stylesheet;
 688   jobject ret;
 689
 690   doc = xmljParseDocument (env, self, in, detectBuffer, publicId, systemId,
 691                            base, 0, 0, 0, 0, 0,
 692                            entityResolver, errorHandler, 0, 0, 2);
 693   if (doc == NULL)
 694     {
 695       return NULL;
 696     }
 697   stylesheetURL = systemId;
 698   xsltSetLoaderFunc (xmljDocLoader);
 699   stylesheet = xsltParseStylesheetDoc (doc);
 700   if (stylesheet == NULL)
 701     {
 702       xmljThrowException (env,
 703                           "javax/xml/transform/TransformerConfigurationException",
 704                           "Error parsing XSLT stylesheet");
 705       return NULL;
 706     }
 707   xmljSetOutputProperties (env, self, stylesheet);
 708   ret =  xmljAsField (env, stylesheet);
 709   if (ret == NULL)
 710     {
 711       xmljThrowException (env,
 712                           "javax/xml/transform/TransformerConfigurationException",
 713                           "Can't create Java object for stylesheet");
 714     }
 715   return ret;
 716 }
 717
 718 /* GnomeTransformer.newStylesheetFromDoc */
 719 JNIEXPORT jobject JNICALL
 720 Java_gnu_xml_libxmlj_transform_GnomeTransformer_newStylesheetFromDoc
 721 (JNIEnv *env, jobject self, jobject in)
 722 {
 723   xmlDocPtr doc;
 724   xsltStylesheetPtr stylesheet;
 725   jobject ret;
 726
 727   doc = (xmlDocPtr) xmljGetNodeID (env, in);
 728   if (doc == NULL)
 729     {
 730       return NULL;
 731     }
 732   stylesheetURL = xmljNewString (env, doc->URL);
 733   xsltSetLoaderFunc (xmljDocLoader);
 734   stylesheet = xsltParseStylesheetDoc (doc);
 735   if (stylesheet == NULL)
 736     {
 737       xmljThrowException (env,
 738                           "javax/xml/transform/TransformerConfigurationException",
 739                           "Error parsing XSLT stylesheet");
 740     }
 741   xmljSetOutputProperties (env, self, stylesheet);
 742   ret =  xmljAsField (env, stylesheet);
 743   if (ret == NULL)
 744     {
 745       xmljThrowException (env,
 746                           "javax/xml/transform/TransformerConfigurationException",
 747                           "Can't create Java object for stylesheet");
 748     }
 749   return ret;
 750 }
 751
 752 /* GnomeTransformer.transformStreamToStream */
 753 JNIEXPORT void JNICALL
 754 Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformStreamToStream
 755 (JNIEnv *env, jobject self, jobject in, jbyteArray detectBuffer,
 756  jstring publicId, jstring systemId, jstring base,
 757  jboolean entityResolver, jboolean errorHandler, jobject out)
 758 {
 759   xmlDocPtr source;
 760   xmlDocPtr result;
 761
 762   source = xmljParseDocument (env, self, in, detectBuffer, publicId, systemId,
 763                               base, 0, 0, 0, 0, 0,
 764                               entityResolver, errorHandler, 0, 0, 2);
 765   result = xmljTransform (env, self, source);
 766   xmljSaveFileToJavaOutputStream (env, out, result,
 767                                   (const char*) result->encoding);
 768   xmlFreeDoc (result);
 769 }
 770
 771 /* GnomeTransformer.transformStreamToDoc */
 772 JNIEXPORT jobject JNICALL
 773 Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformStreamToDoc
 774 (JNIEnv *env, jobject self, jobject in, jbyteArray detectBuffer,
 775  jstring publicId, jstring systemId, jstring base,
 776  jboolean entityResolver, jboolean errorHandler)
 777 {
 778   xmlDocPtr source;
 779   xmlDocPtr result;
 780
 781   source = xmljParseDocument (env, self, in, detectBuffer, publicId, systemId,
 782                               base, 0, 0, 0, 0, 0,
 783                               entityResolver, errorHandler, 0, 0, 2);
 784   result = xmljTransform (env, self, source);
 785   return xmljGetNodeInstance (env, (xmlNodePtr) result);
 786 }
 787
 788 /* GnomeTransformer.transformStreamToSAX */
 789 JNIEXPORT void JNICALL
 790 Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformStreamToSAX
 791 (JNIEnv *env, jobject self, jobject in, jbyteArray detectBuffer,
 792  jstring publicId, jstring systemId, jstring base,
 793  jboolean entityResolver, jboolean errorHandler, jobject callback)
 794 {
 795   xmlDocPtr source;
 796
 797   source = xmljParseDocument (env, self, in, detectBuffer, publicId, systemId,
 798                               base, 0, 0, 0, 0, 0,
 799                               entityResolver, errorHandler, 0, 0, 2);
 800   xmljTransformToSAX (env, self, source, callback);
 801 }
 802
 803 /* GnomeTransformer.transformDocToStream */
 804 JNIEXPORT void JNICALL
 805 Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformDocToStream
 806 (JNIEnv *env, jobject self, jobject doc, jobject out)
 807 {
 808   xmlDocPtr source;
 809   xmlDocPtr result;
 810
 811   source = (xmlDocPtr) xmljGetNodeID (env, doc);
 812   result = xmljTransform (env, self, source);
 813   xmljSaveFileToJavaOutputStream (env, out, result,
 814                                   (const char*) result->encoding);
 815   xmlFreeDoc (result);
 816 }
 817
 818 /* GnomeTransformer.transformDocToDoc */
 819 JNIEXPORT jobject JNICALL
 820 Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformDocToDoc
 821 (JNIEnv *env, jobject self, jobject doc)
 822 {
 823   xmlDocPtr source;
 824   xmlDocPtr result;
 825
 826   source = (xmlDocPtr) xmljGetNodeID (env, doc);
 827   result = xmljTransform (env, self, source);
 828   return xmljGetNodeInstance (env, (xmlNodePtr) result);
 829 }
 830
 831 /* GnomeTransformer.transformDocToSAX */
 832 JNIEXPORT void JNICALL
 833 Java_gnu_xml_libxmlj_transform_GnomeTransformer_transformDocToSAX
 834 (JNIEnv *env, jobject self, jobject doc, jobject callback)
 835 {
 836   xmlDocPtr source;
 837
 838   source = (xmlDocPtr) xmljGetNodeID (env, doc);
 839   xmljTransformToSAX (env, self, source, callback);
 840 }
 841
 842 /* GnomeTransformer.free */
 843 JNIEXPORT void JNICALL
 844 Java_gnu_xml_libxmlj_transform_GnomeTransformer_free (JNIEnv *env,
 845                                                       jobject self)
 846 {
 847   xsltStylesheetPtr stylesheet;
 848
 849   stylesheet = xmljGetStylesheetID (env, self);
 850   xsltFreeStylesheet (stylesheet);
 851 }
 852
 853 /*
 854  * --------------------------------------------------------------------------
 855  * Native implementation for class
 856  * gnu.xml.libxmlj.transform.GnomeTransformerFactory follows.
 857  */
 858
 859 /* GnomeTransformerFactory.freeLibxsltGlobal */
 860 JNIEXPORT void JNICALL
 861 Java_gnu_xml_libxmlj_transform_GnomeTransformerFactory_freeLibxsltGlobal (
 862   JNIEnv *env __attribute__((__unused__)),
 863   jclass clazz __attribute__((__unused__)))
 864 {
 865   xsltCleanupGlobals ();
 866   xmlCleanupParser ();
 867 }
 868