aboutsummaryrefslogtreecommitdiff
path: root/ext
diff options
context:
space:
mode:
authorHans de Graaff <hans@degraaff.org>2012-10-26 13:00:04 +0200
committerHans de Graaff <hans@degraaff.org>2012-10-26 13:00:04 +0200
commit7670cccf083e25676804c503582091a3eadb00cf (patch)
tree8aa8d9a6a760e2aa10c3d2f30df315f34c70ffc7 /ext
parentInitial commit (diff)
downloadgorg-7670cccf083e25676804c503582091a3eadb00cf.tar.gz
gorg-7670cccf083e25676804c503582091a3eadb00cf.tar.bz2
gorg-7670cccf083e25676804c503582091a3eadb00cf.zip
Import distributed 0.6.4 release.0.6.4
Diffstat (limited to 'ext')
-rw-r--r--ext/gorg/xsl/MANIFEST3
-rw-r--r--ext/gorg/xsl/extconf.rb22
-rw-r--r--ext/gorg/xsl/xsl.c894
-rw-r--r--ext/gorg/xsl/xsl.h44
4 files changed, 963 insertions, 0 deletions
diff --git a/ext/gorg/xsl/MANIFEST b/ext/gorg/xsl/MANIFEST
new file mode 100644
index 0000000..29fb55d
--- /dev/null
+++ b/ext/gorg/xsl/MANIFEST
@@ -0,0 +1,3 @@
+extconf.rb
+xsl.c
+xsl.h
diff --git a/ext/gorg/xsl/extconf.rb b/ext/gorg/xsl/extconf.rb
new file mode 100644
index 0000000..1bd115b
--- /dev/null
+++ b/ext/gorg/xsl/extconf.rb
@@ -0,0 +1,22 @@
+require "mkmf"
+
+unless have_library("xml2", "xmlRegisterDefaultInputCallbacks")
+ puts("libxml2 not found")
+ exit(1)
+end
+
+unless have_library('xslt','xsltParseStylesheetFile')
+ puts("libxslt not found")
+ exit(1)
+end
+
+unless have_library('exslt','exsltRegisterAll')
+ puts("libexslt not found")
+ exit(1)
+end
+
+$LDFLAGS << ' ' << `xslt-config --libs`.chomp
+
+$CFLAGS << ' ' << `xslt-config --cflags`.chomp
+
+create_makefile("gorg/xsl")
diff --git a/ext/gorg/xsl/xsl.c b/ext/gorg/xsl/xsl.c
new file mode 100644
index 0000000..d8d40b6
--- /dev/null
+++ b/ext/gorg/xsl/xsl.c
@@ -0,0 +1,894 @@
+/*
+ Copyright 2004, Xavier Neys (neysx@gentoo.org)
+
+ This file is part of gorg.
+
+ gorg 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 of the License, or
+ (at your option) any later version.
+
+ gorg 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 gorg; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "xsl.h"
+
+/*
+ * Copied from xmlIO.c from libxml2
+ */
+static int xmlFileWrite (void * context, const char * buffer, int len)
+{
+ int items;
+
+ if ((context == NULL) || (buffer == NULL))
+ return(-1);
+ items = fwrite(&buffer[0], len, 1, (FILE *) context);
+ if ((items == 0) && (ferror((FILE *) context))) {
+ //xmlIOErr(0, "fwrite()");
+ __xmlIOErr(XML_FROM_IO, 0, "fwrite() failed");
+ return(-1);
+ }
+ return(items * len);
+}
+
+extern int xmlLoadExtDtdDefaultValue;
+static int xmlOptions = XSLT_PARSE_OPTIONS | XML_PARSE_NOWARNING;
+
+/*Enum xmlParserOption {
+ XML_PARSE_RECOVER = 1 : recover on errors
+ XML_PARSE_NOENT = 2 : substitute entities
+ XML_PARSE_DTDLOAD = 4 : load the external subset
+ XML_PARSE_DTDATTR = 8 : default DTD attributes
+ XML_PARSE_DTDVALID = 16 : validate with the DTD
+ XML_PARSE_NOERROR = 32 : suppress error reports
+ XML_PARSE_NOWARNING = 64 : suppress warning reports
+ XML_PARSE_PEDANTIC = 128 : pedantic error reporting
+ XML_PARSE_NOBLANKS = 256 : remove blank nodes
+ XML_PARSE_SAX1 = 512 : use the SAX1 interface internally
+ XML_PARSE_XINCLUDE = 1024 : Implement XInclude substitition
+ XML_PARSE_NONET = 2048 : Forbid network access
+ XML_PARSE_NODICT = 4096 : Do not reuse the context dictionnary
+ XML_PARSE_NSCLEAN = 8192 : remove redundant namespaces declarations
+ XML_PARSE_NOCDATA = 16384 : merge CDATA as text nodes
+ XML_PARSE_NOXINCNODE = 32768 : do not generate XINCLUDE START/END nodes
+}*/
+
+/*
+ * Library global values that need to be accessed by the callbacks
+ * Make sure the lib init routine registers them with ruby's GC
+ */
+VALUE g_xroot=Qnil;
+VALUE g_xfiles=Qnil;
+VALUE g_xmsg=Qnil;
+VALUE g_mutex=Qnil;
+VALUE g_xtrack=Qnil; // true/false, no need to register this one
+
+/*
+ * Store ID's of ruby methodes to speed up calls to rb_funcall*
+ * so that we do not have to call rb_intern("methodName") repeatedly.
+ */
+struct {
+ int include;
+ int to_a;
+ int to_s;
+ int length;
+ int synchronize;
+} id;
+
+
+/*
+ * Add file to list of requested files, if not already in our array
+ */
+void addTrackedFile(char *f, const char *rw)
+{
+ VALUE rbNewPath;
+ VALUE rwo;
+ VALUE rbNewEntry;
+
+ if (Qtrue == g_xtrack)
+ {
+ switch(*rw)
+ {
+ case 'R':
+ case 'r':
+ rwo = rb_str_new2("r");
+ break;
+ case 'W':
+ case 'w':
+ rwo = rb_str_new2("w");
+ break;
+ default:
+ rwo = rb_str_new2("o");
+ }
+ rbNewPath = rb_str_new2(f);
+ rbNewEntry = rb_ary_new();
+ rb_ary_push(rbNewEntry, rwo);
+ rb_ary_push(rbNewEntry, rbNewPath);
+ if (Qtrue != rb_funcall(g_xfiles, id.include, 1, rbNewEntry))
+ rb_ary_push(g_xfiles, rbNewEntry);
+ }
+}
+
+/*
+ * libxml2 File I/O Match Callback :
+ * return 1 if we must handle the file ourselves
+ */
+int XRootMatch(const char * URI) {
+ int r = 0;
+//printf("NSX-RootMatch: %s\n",URI);
+ if ( URI != NULL && (*URI == '/' || !strncmp(URI, "file:///", 8)))
+ r = 1;
+ else
+ if (!strncmp(URI, "ftp://", 6) || !strncmp(URI, "http://", 7))
+ // Add URI to list of requested files to let caller know remote files are used
+ addTrackedFile((char *)URI, "o");
+
+ return r;
+}
+
+
+/*
+ * libxml2 File I/O Open Callback :
+ * open the file, prepend $xroot if necessary and add file to list of requested files on input
+ */
+void *XRootOpen (const char *filename, const char* rw) {
+ char *path = NULL;
+ char *fakexml = NULL;
+ FILE *fd;
+ char *rbxrootPtr="";
+ int rbxrootLen=0;
+ char empty[] = "<?xml version='1.0'?><missing file='%s'/>";
+ int pip[2];
+ struct stat notused;
+
+//printf("NSX-RootOpen: %s\n", filename);
+
+ if (filename == NULL || (*filename != '/' && strncmp(filename, "file:///", 8))){
+ return NULL; // I told you before, I can't help you with that file ;-)
+ }
+
+ if (g_xroot != Qnil)
+ {
+ rbxrootPtr = RSTRING(g_xroot)->ptr;
+ rbxrootLen = RSTRING(g_xroot)->len;
+ }
+ path = (char *) malloc((strlen(filename) + rbxrootLen + 1) * sizeof(char));
+ if (path == NULL)
+ return NULL;
+
+ if (!strncmp(filename, "file:///", 8))
+ {
+ // Absolute path, do not prepend xroot, e.g. file:///etc/xml/catalog
+ strcpy ( path, filename+7);
+ }
+ else
+ {
+ // If requested file is already under xroot, do not prepend path with xroot
+ // Example:
+ // Say we have xroot="/htdocs"
+ // when calling document('../xml/file.xml') in /htdocs/xsl/mysheet.xsl,
+ // the lib will already have replaced the .. with /htdocs
+ // and there is no need to add /htdocs
+ // On the other hand, if we call document('/xml/file.xml') in /htdocs/xsl/mysheet.xsl,
+ // because we know our root is /htdocs, then we need to prepend xroot to get /htdocs/xml/file.xml
+ // The consequence of that is that /${DocRoot}/${DocRoot}/whatever is not usable. Get over it.
+ //
+ // Besides, it is also possible that a file is located outside the $DocumentRoot, e.g. ~usename/file.xml
+ // that apache would have expanded to /home/username/public_html/file.xml e.g.
+ if (rbxrootLen && strncmp(rbxrootPtr, filename, rbxrootLen) && stat(filename,&notused))
+ {
+ // Requested file is not already under $DocRoot, prepend it
+ strcpy (path, rbxrootPtr);
+ strcat (path, filename);
+ }
+ else
+ {
+ // Use the filename that was requested as-is
+ strcpy(path, filename);
+ }
+ }
+
+ // Add file to list of requested files
+ addTrackedFile(path, rw);
+
+ fd = fopen(path, rw);
+ free(path);
+
+ if (*rw == 'r' && fd == NULL && strncmp(filename, "file:///", 8) && strlen(filename)>4 && strncmp((strlen(filename)-4)+filename, ".dtd", 4) && strncmp((strlen(filename)-4)+filename, ".xsl", 4))
+ // Return fake xml
+ // We don't know for sure that libxml2 wants an xml file from a document(),
+ // but what the heck, let's just pretend
+ if (pipe(pip))
+ return (void *) NULL;
+ else
+ {
+ fakexml = (char *) malloc((strlen(filename) + sizeof(empty)) * sizeof(char));
+ if (path == NULL)
+ return NULL;
+ sprintf(fakexml, empty, filename);
+ write(pip[1], fakexml, strlen(fakexml));
+ close(pip[1]);
+ free(fakexml);
+ return (void *) fdopen(pip[0], "r");
+ }
+ else
+ return (void *) fd;
+}
+
+int XRootClose (void * context) {
+ if (context == (void *) -1)
+ return 0;
+ else
+ return xmlFileClose(context);
+}
+
+void *XRootInputOpen (const char *filename) {
+ return XRootOpen (filename, "r");
+}
+
+void *XRootOutputOpen (const char *filename) {
+ return XRootOpen (filename, "w");
+}
+
+
+/*
+ * Intercept xsl:message output strings,
+ * If one starts with "%%GORG%%" then it to our @xmsg array.
+ * If not, pass it to the default generic handler of libxslt
+ */
+void xslMessageHandler(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...)
+{
+ va_list args;
+ char *str;
+ int len;
+
+ va_start(args, msg);
+ len = vasprintf(&str, msg, args);
+ va_end(args);
+
+ if (len > 0)
+ {
+ if (!strncmp(str, "%%GORG%%", 8))
+ {
+ if (len > 8)
+ {
+ rb_ary_push(g_xmsg, rb_str_new2(str+8));
+ }
+ }
+ else
+ {
+ // Not for gorg, spit it out on stderr as libxslt would do
+ fputs(str, stderr);
+ }
+ // Need to free pointer that was allocated by vasprintf
+ free(str);
+ }
+}
+
+
+/*
+ * Try to distinguish between a filename and some xml
+ * without accessing the filesystem or parsing the string as xml
+ *
+ * If the string is long (>FILENAME_MAX) or
+ * starts with "<?xml" or "<?xsl" or
+ * contains newline chars,
+ * we assume it is some kind of xml, otherwise we assume it is a filename
+ */
+int looksLikeXML(VALUE v)
+{
+ return (RSTRING(v)->len > FILENAME_MAX)
+ || (!strncmp(RSTRING(v)->ptr, "<?xml", 5))
+ || (!strncmp(RSTRING(v)->ptr, "<?xsl", 5))
+ || (strstr(RSTRING(v)->ptr, "\n"));
+// We could also try with " " but some are stupid enough to use spaces in filenames
+}
+
+// I got stumped and needed this ;-)
+void dumpCleanup(char * str, struct S_cleanup c)
+{
+printf( "%s\n"
+ "\nparams=%08x"
+ "\ndocxml=%08x"
+ "\ndocxsl=%08x"
+ "\ndocres=%08x"
+ "\n xsl=%08x"
+ "\ndocstr=%08x"
+ "\n=======================\n", str, c.params, c.docxml, c.docxsl, c.docres, c.xsl, c.docstr);
+}
+
+/*
+ * my_raise : cleanup and raise ruby exception
+ *
+ * cleanup frees xsl docs and allocated memory, pointers are in passed struct
+ * then raises the passed exception
+ *
+ * struct of pointers can be NULL (no memory to free) and
+ * exception can be NULL (clean up only, do not call rb_raise)
+ *
+ * Set last error level and last error message if applicable and available
+ */
+void my_raise(VALUE obj, s_cleanup *clean, VALUE rbExcep, char *err)
+{
+ xmlErrorPtr xmlErr = NULL;
+ VALUE hErr;
+
+ if (!NIL_P(obj))
+ {
+ xmlErr = xmlGetLastError();
+ hErr = rb_hash_new();
+ if (xmlErr)
+ {
+ // It seems we usually get a \n at the end of the msg, get rid of it
+ if (*(xmlErr->message+strlen(xmlErr->message)-1) == '\n')
+ *(xmlErr->message+strlen(xmlErr->message)-1) = '\0';
+ // Build hash with error level, code and message
+ rb_hash_aset(hErr, rb_str_new2("xmlErrCode"), INT2FIX(xmlErr->code));
+ rb_hash_aset(hErr, rb_str_new2("xmlErrLevel"), INT2FIX(xmlErr->level));
+ rb_hash_aset(hErr, rb_str_new2("xmlErrMsg"), rb_str_new2(xmlErr->message));
+ }
+ else
+ {
+ // Build hash with only an error code of 0
+ rb_hash_aset(hErr, rb_str_new2("xmlErrCode"), INT2FIX(0));
+ rb_hash_aset(hErr, rb_str_new2("xmlErrLevel"), INT2FIX(0));
+ }
+ rb_iv_set(obj, "@xerr", hErr);
+ }
+
+ if (clean)
+ {
+ //dumpCleanup("Freeing pointers", *clean);
+ free(clean->params);
+ xmlFree(clean->docstr);
+ xmlFreeDoc(clean->docres);
+ xmlFreeDoc(clean->docxml);
+ //xmlFreeDoc(clean->docxsl); segfault /\/ Veillard said xsltFreeStylesheet(xsl) does it
+ xsltFreeStylesheet(clean->xsl);
+ }
+ // Clean up xml stuff
+ xmlCleanupInputCallbacks();
+ xmlCleanupOutputCallbacks();
+ xmlResetError(xmlErr);
+ xmlResetLastError();
+ xsltCleanupGlobals();
+ xmlCleanupParser();
+ xsltSetGenericErrorFunc(NULL, NULL);
+
+ // Reset global variables to let ruby's GC do its work
+ g_xroot = Qnil;
+ g_xfiles = Qnil;
+ g_xmsg = Qnil;
+
+ // Raise exception if requested to
+ if (rbExcep != Qnil)
+ {
+ rb_raise(rbExcep, err);
+ }
+}
+
+
+/*
+ * Register input callback with libxml2
+ *
+ * We need to repeat this call because libxml cleanup unregisters and we like cleaning up
+ */
+void my_register_xml(void)
+{
+ // Enable exslt
+ exsltRegisterAll();
+
+ // Register default callbacks, e.g.http://
+ xmlRegisterDefaultInputCallbacks();
+ xmlRegisterDefaultOutputCallbacks();
+
+/* NO NEED xmlRegisterInputCallbacks(xmlIOHTTPMatch, xmlIOHTTPOpen, xmlIOHTTPRead, xmlIOHTTPClose);
+xmlRegisterInputCallbacks(xmlFileMatch, xmlFileOpen, xmlFileRead, xmlFileClose);*/
+
+ // Add our own file input callback
+ if (xmlRegisterInputCallbacks(XRootMatch, XRootInputOpen, xmlFileRead, XRootClose) < 0)
+ {
+ rb_raise(rb_eSystemCallError, "Failed to register input callbacks");
+ }
+
+ // Add our own file output callback to support exslt:document
+ if (xmlRegisterOutputCallbacks(XRootMatch, XRootOutputOpen, xmlFileWrite, xmlFileClose) < 0)
+ {
+ rb_raise(rb_eSystemCallError, "Failed to register output callbacks");
+ }
+ // Add our own xsl:message handler
+ xsltSetGenericErrorFunc(NULL, xslMessageHandler);
+
+ xsltDebugSetDefaultTrace(XSLT_TRACE_NONE);
+ xmlSubstituteEntitiesDefault(1);
+ xmlLoadExtDtdDefaultValue=1;
+}
+
+
+/*
+ * Check that parameters are usable, i.e. like
+ * [p1, v1] : single parameter
+ * [[p1, v1], [p2, v2]...] : several pairs of (param name, value)
+ * {p1=>v1...} : a hash of (param name, value)
+ * nil : no parameter
+ *
+ * Raise an exceptiom if not happy or return the list of params as
+ * [[p1, v1], [p2, v2]...]
+ */
+VALUE check_params(VALUE xparams)
+{
+ VALUE retparams=Qnil;
+
+ if (!NIL_P(xparams))
+ {
+ VALUE ary;
+ VALUE param;
+ int len, plen;
+ int i;
+
+ // Reject some single values straight away
+ switch (TYPE(xparams))
+ {
+ case T_FLOAT:
+ case T_REGEXP:
+ case T_FIXNUM:
+ case T_BIGNUM:
+ case T_STRUCT:
+ case T_FILE:
+ case T_TRUE:
+ case T_FALSE:
+ case T_DATA:
+ case T_SYMBOL:
+ rb_raise(rb_eTypeError, "Invalid parameters");
+ return Qnil;
+ }
+ // if xparams is not an array, try to make one
+ ary = rb_funcall(xparams, id.to_a, 0);
+
+ // Now check that our array is a suitable array:
+ // empty array => Qnil
+ // array.length==2, could be 2 params [[p1,v1],[p2,v2]] or 1 param [p,v]
+ // if both items are arrays, we have a list of params, otherwise we have a single param
+ len = RARRAY(ary)->len;
+ switch (len)
+ {
+ case 0:
+ retparams = Qnil;
+ break;
+ case 2:
+ // fall through to default if we have 2 arrays, otherwise, we must have 2 strings
+ if (! (TYPE(rb_ary_entry(ary,0))==T_ARRAY && TYPE(rb_ary_entry(ary,1))==T_ARRAY))
+ {
+ VALUE s1 = rb_funcall(rb_ary_entry(ary,0), id.to_s, 0);
+ VALUE s2 = rb_funcall(rb_ary_entry(ary,1), id.to_s, 0);
+
+ // Both items must be strings
+ retparams = rb_ary_new3(2L, s1, s2);
+ break;
+ }
+ default:
+ // scan array and check that each item is an array of 2 strings
+ retparams = rb_ary_new();
+ for (i=0; i < len; ++i)
+ {
+ if ( TYPE(rb_ary_entry(ary,i)) != T_ARRAY )
+ {
+ rb_raise(rb_eTypeError, "Invalid parameters");
+ return Qnil;
+ }
+ param = rb_ary_entry(ary,i);
+ plen = NUM2INT(rb_funcall(param, id.length, 0));
+ if ( plen != 2 )
+ {
+ rb_raise(rb_eTypeError, "Invalid parameters");
+ return Qnil;
+ }
+ VALUE s1 = rb_funcall(rb_ary_entry(param,0), id.to_s, 0);
+ VALUE s2 = rb_funcall(rb_ary_entry(param,1), id.to_s, 0);
+
+ rb_ary_push(retparams, rb_ary_new3(2L, s1, s2));
+ }
+ }
+ }
+ return retparams;
+}
+
+
+/*
+ * Build array of pointers to strings
+ *
+ * return NULL or pointer
+ */
+char *build_params(VALUE rbparams)
+{
+ char *ret;
+ char **paramPtr;
+ char *paramData;
+ int i;
+ VALUE tempval;
+ VALUE tempstr;
+ char quotingChar;
+
+ if (rbparams == Qnil)
+ // You shoud not call this if you have no params, see it as an error
+ return NULL;
+
+ // Compute total block size in one go
+ tempval = rb_funcall(rbparams, id.to_s, 0);
+ ret = malloc ( ((RARRAY(rbparams)->len)*2+1) * sizeof(void *) // Two pointers per [param, value] + 1 NULL
+ + (RARRAY(rbparams)->len) * 4 * sizeof(char) // Quotes around values + 1 NULL per value
+ + (RSTRING(tempval)->len) * sizeof(char) // Size of param names & values
+ );
+ if ( ret==NULL)
+ return NULL; // out of memory
+
+ paramPtr = (char **)ret;
+ paramData = ret + ((RARRAY(rbparams)->len)*2+1) * sizeof(void *);
+ // Copy each param name & value
+ for (i=0; i<RARRAY(rbparams)->len; ++i)
+ {
+ tempval = rb_ary_entry(rbparams, i); // ith param, i.e. [name, value]
+
+ // 1. Add param name
+
+ tempstr = rb_ary_entry(tempval, 0); // param name
+ // Add param name address to list of pointers
+ *paramPtr++ = paramData;
+ // Copy param name into data block
+ strcpy(paramData, RSTRING(tempstr)->ptr);
+ // Move data pointer after inserted string
+ paramData += 1+ RSTRING(tempstr)->len;
+
+ // 2. Copy param value, quoting it with ' or "
+
+ tempstr = rb_ary_entry(tempval, 1); // param value
+ // Don't bother if param is a mix of ' and ", users should know better :-)
+ // or it's been checked already. Here we expect params to be OK.
+ quotingChar = '"';
+ if ( strchr(RSTRING(tempstr)->ptr, quotingChar) )
+ quotingChar = '\''; // Use ' instead of "
+
+ // Add para value address in list of pointers
+ *paramPtr++ = paramData;
+
+ // Start with quoting character
+ *paramData++ = quotingChar;
+ // Copy value
+ strcpy(paramData, RSTRING(tempstr)->ptr);
+ // Move data pointer after inserted string
+ paramData += RSTRING(tempstr)->len;
+ // Close quote
+ *paramData++ = quotingChar;
+ // End string with \0
+ *paramData++ = '\0';
+ }
+ // Terminate list of pointers with a NULL
+ *paramPtr = NULL;
+
+ return ret;
+}
+
+
+
+
+/*
+ * Parse stylesheet and xml document, apply stylesheet and return result
+ */
+VALUE xsl_process_real(VALUE none, VALUE self)
+{
+ s_cleanup myPointers;
+ int docstrlen;
+
+ VALUE rbxml, rbxsl, rbout, rbparams, rbxroot;
+
+ // Get instance data in a reliable format
+ rbxml = rb_iv_get(self, "@xml");
+ if (NIL_P(rbxml))
+ rb_raise(rb_eArgError, "No XML data");
+ rbxml = StringValue(rbxml);
+ if (!RSTRING(rbxml)->len)
+ rb_raise(rb_eArgError, "No XML data");
+ rbxsl = rb_iv_get(self, "@xsl");
+ if (NIL_P(rbxsl))
+ rb_raise(rb_eArgError, "No Stylesheet");
+ rbxsl = StringValue(rbxsl);
+ if (!RSTRING(rbxsl)->len)
+ rb_raise(rb_eArgError, "No Stylesheet");
+ rbxroot = rb_iv_get(self, "@xroot");
+ rbparams = check_params(rb_iv_get(self, "@xparams"));
+
+ // Initialize our globals
+ if (!NIL_P(rbxroot))
+ g_xroot = StringValue(rbxroot);
+ g_xtrack = RTEST(rb_iv_get(self, "@xtrack")) ? Qtrue : Qfalse;
+ g_xfiles = rb_ary_new();
+ g_xmsg = rb_ary_new();
+
+ // Register callbacks and stuff
+ my_register_xml();
+
+ // Make sure our pointers are all NULL
+ memset(&myPointers, '\0', sizeof(myPointers));
+
+ // Build param array
+ if (rbparams != Qnil)
+ if (NULL==(myPointers.params=build_params(rbparams)))
+ my_raise(self, &myPointers, rb_eNoMemError, "Cannot allocate parameter block");
+
+ // Parse XSL
+ if (looksLikeXML(rbxsl))
+ {
+ myPointers.docxsl = xmlParseMemory(RSTRING(rbxsl)->ptr, RSTRING(rbxsl)->len);
+// myPointers.docxsl = xmlReadMemory(RSTRING(rbxsl)->ptr, RSTRING(rbxsl)->len, ".", NULL, 0);
+ if (myPointers.docxsl == NULL)
+ {
+ my_raise(self, &myPointers, rb_eSystemCallError, "XSL parsing error");
+ return Qnil;
+ }
+ myPointers.xsl = xsltParseStylesheetDoc(myPointers.docxsl);
+ if (myPointers.xsl == NULL)
+ {
+ my_raise(self, &myPointers, rb_eSystemCallError, "XSL stylesheet parsing error");
+ return Qnil;
+ }
+ }
+ else // xsl is a filename
+ {
+ myPointers.xsl = xsltParseStylesheetFile(RSTRING(rbxsl)->ptr);
+ if (myPointers.xsl == NULL)
+ {
+ my_raise(self, &myPointers, rb_eSystemCallError, "XSL file loading error");
+ return Qnil;
+ }
+ }
+
+ // Parse XML
+ if (looksLikeXML(rbxml))
+ {
+ myPointers.docxml = xmlReadMemory(RSTRING(rbxml)->ptr, RSTRING(rbxml)->len, ".", NULL, xmlOptions);
+ if (myPointers.docxml == NULL)
+ {
+ my_raise(self, &myPointers, rb_eSystemCallError, "XML parsing error");
+ return Qnil;
+ }
+ }
+ else // xml is a filename
+ {
+ myPointers.docxml = xmlReadFile(RSTRING(rbxml)->ptr, NULL, xmlOptions);
+ if (myPointers.docxml == NULL)
+ {
+ my_raise(self, &myPointers, rb_eSystemCallError, "XML file parsing error");
+ return Qnil;
+ }
+ }
+
+ // Apply stylesheet to xml
+ myPointers.docres = xsltApplyStylesheet(myPointers.xsl, myPointers.docxml, (void*)myPointers.params);
+ if (myPointers.docres == NULL)
+ {
+ my_raise(self, &myPointers, rb_eSystemCallError, "Stylesheet apply error");
+ return Qnil;
+ }
+
+ xsltSaveResultToString(&(myPointers.docstr), &docstrlen, myPointers.docres, myPointers.xsl);
+ if ( docstrlen >= 1 )
+ rbout = rb_str_new2((char*)(myPointers.docstr));
+ else
+ rbout = Qnil;
+ rb_iv_set(self, "@xres", rbout);
+ rb_iv_set(self, "@xfiles", g_xfiles);
+ rb_iv_set(self, "@xmsg", g_xmsg);
+
+ // Clean up, no exception to raise
+ my_raise(self, &myPointers, Qnil, NULL);
+ return rbout;
+}
+
+// Use g_mutex to make sure our callbacks do not mess up the globals
+// if the user is running several transforms in parallel threads
+static VALUE in_sync(VALUE self)
+{
+ return rb_funcall(self, id.synchronize, 0);
+}
+
+VALUE xsl_process(VALUE self)
+{
+ rb_iterate(in_sync, g_mutex, xsl_process_real, self);
+}
+
+/*
+ * @xerr
+ */
+VALUE xsl_xerr_get( VALUE self )
+{
+ return rb_iv_get(self, "@xerr");
+}
+
+/*
+ * @xres
+ */
+VALUE xsl_xres_get( VALUE self )
+{
+ return rb_iv_get(self, "@xres");
+}
+
+/*
+ * @xmsg
+ */
+VALUE xsl_xmsg_get( VALUE self )
+{
+ return rb_iv_get(self, "@xmsg");
+}
+
+/*
+ * @xfiles
+ */
+VALUE xsl_xfiles_get( VALUE self )
+{
+ return rb_iv_get(self, "@xfiles");
+}
+
+/*
+ * @xparams
+ */
+VALUE xsl_xparams_set( VALUE self, VALUE xparams )
+{
+ // Check params and raise an exception if not happy
+ check_params(xparams);
+ // Store parameters
+ return rb_iv_set(self, "@xparams", xparams);
+}
+
+VALUE xsl_xparams_get( VALUE self )
+{
+ return rb_iv_get(self, "@xparams");
+}
+
+/*
+ * @xroot
+ */
+VALUE xsl_xroot_set( VALUE self, VALUE xroot )
+{
+ // Throw an exception if xroot cannot be used as a string
+ if (!NIL_P(xroot)) StringValue(xroot);
+ // Store param in @xroot
+ rb_iv_set(self, "@xroot", xroot);
+
+ return xroot;
+}
+
+VALUE xsl_xroot_get( VALUE self )
+{
+ return rb_iv_get(self, "@xroot");
+}
+
+/*
+ * @xtrack
+ */
+VALUE xsl_xtrack_set( VALUE self, VALUE xtrack )
+{
+ // @xtrack is true if param is neither Qnil nor QFalse
+ rb_iv_set(self, "@xtrack", RTEST(xtrack) ? Qtrue : Qfalse);
+
+ return xtrack;
+}
+
+VALUE xsl_xtrack_get( VALUE self )
+{
+ return rb_iv_get(self, "@xtrack");
+}
+
+/*
+ * @xml
+ */
+VALUE xsl_xml_set( VALUE self, VALUE xml )
+{
+ // Throw an exception if xml cannot be used as a string
+ if (!NIL_P(xml)) StringValue(xml);
+ // Store param in @xml
+ rb_iv_set(self, "@xml", xml);
+
+ return xml;
+}
+
+VALUE xsl_xml_get( VALUE self )
+{
+ return rb_iv_get(self, "@xml");
+}
+
+/*
+ * @xsl
+ */
+VALUE xsl_xsl_set( VALUE self, VALUE xsl )
+{
+ // Throw an exception if xsl cannot be used as a string
+ if (!NIL_P(xsl)) StringValue(xsl);
+ // Store param in @xsl
+ rb_iv_set(self, "@xsl", xsl);
+
+ return xsl;
+}
+
+VALUE xsl_xsl_get( VALUE self )
+{
+ return rb_iv_get(self, "@xsl");
+}
+
+
+static VALUE xsl_init(VALUE self)
+{
+ rb_iv_set(self, "@xml", Qnil);
+ rb_iv_set(self, "@xsl", Qnil);
+ rb_iv_set(self, "@xfiles", Qnil);
+ rb_iv_set(self, "@xmsg", Qnil);
+ rb_iv_set(self, "@xparams", Qnil);
+ rb_iv_set(self, "@xroot", Qnil);
+ rb_iv_set(self, "@xtrack", Qfalse);
+ rb_iv_set(self, "@xerr", Qnil);
+
+ return self;
+}
+
+
+VALUE mGorg;
+VALUE cXSL;
+
+/*
+ * Library Initialization
+ */
+void Init_xsl( void )
+{
+ mGorg = rb_define_module( "Gorg" );
+ cXSL = rb_define_class_under( mGorg, "XSL", rb_cObject );
+
+ // Get our lib global mutex
+ rb_require("thread");
+ g_mutex = rb_eval_string("Mutex.new");
+
+ // Get method ID's
+ id.include = rb_intern("include?");
+ id.to_a = rb_intern("to_a");
+ id.to_s = rb_intern("to_s");
+ id.length = rb_intern("length");
+ id.synchronize = rb_intern("synchronize");
+
+ // Register lib global variables with ruby's GC
+ rb_global_variable(&g_mutex);
+ rb_global_variable(&g_xfiles);
+ rb_global_variable(&g_xmsg);
+ rb_global_variable(&g_xroot);
+
+ rb_define_const( cXSL, "ENGINE_VERSION", rb_str_new2(xsltEngineVersion) );
+ rb_define_const( cXSL, "LIBXSLT_VERSION", INT2NUM(xsltLibxsltVersion) );
+ rb_define_const( cXSL, "LIBXML_VERSION", INT2NUM(xsltLibxmlVersion) );
+ rb_define_const( cXSL, "XSLT_NAMESPACE", rb_str_new2(XSLT_NAMESPACE) );
+ rb_define_const( cXSL, "DEFAULT_VENDOR", rb_str_new2(XSLT_DEFAULT_VENDOR) );
+ rb_define_const( cXSL, "DEFAULT_VERSION", rb_str_new2(XSLT_DEFAULT_VERSION) );
+ rb_define_const( cXSL, "DEFAULT_URL", rb_str_new2(XSLT_DEFAULT_URL) );
+ rb_define_const( cXSL, "NAMESPACE_LIBXSLT", rb_str_new2(XSLT_LIBXSLT_NAMESPACE) );
+
+ rb_define_method( cXSL, "initialize", xsl_init, 0 );
+
+ rb_define_method( cXSL, "xmsg", xsl_xmsg_get, 0 ); // Return array of '%%GORG%%.*' strings returned by the XSL transform with <xsl:message>
+ rb_define_method( cXSL, "xfiles", xsl_xfiles_get, 0 ); // Return array of names of all files that libxml2 opened during last process
+ rb_define_method( cXSL, "xparams", xsl_xparams_get, 0 ); // Return hash of params
+ rb_define_method( cXSL, "xparams=", xsl_xparams_set, 1 ); // Set hash of params to pass to the xslt processor {"name" => "value"...}
+ rb_define_method( cXSL, "xroot", xsl_xroot_get, 0 ); // Root dir where we should look for files with absolute path
+ rb_define_method( cXSL, "xroot=", xsl_xroot_set, 1 ); // See the root dir as a $DocumentRoot
+ rb_define_method( cXSL, "xtrack?", xsl_xtrack_get, 0 ); // Should I track the files that libxml2 opens
+ rb_define_method( cXSL, "xtrack=", xsl_xtrack_set, 1 ); // Track the files that libxml2 opens, or not
+ rb_define_method( cXSL, "xml", xsl_xml_get, 0 );
+ rb_define_method( cXSL, "xml=", xsl_xml_set, 1 );
+ rb_define_method( cXSL, "xsl", xsl_xsl_get, 0 );
+ rb_define_method( cXSL, "xsl=", xsl_xsl_set, 1 );
+ rb_define_method( cXSL, "xerr", xsl_xerr_get, 0 );
+ rb_define_method( cXSL, "xres", xsl_xres_get, 0 );
+ rb_define_method( cXSL, "process", xsl_process, 0 );
+}
diff --git a/ext/gorg/xsl/xsl.h b/ext/gorg/xsl/xsl.h
new file mode 100644
index 0000000..0fa9588
--- /dev/null
+++ b/ext/gorg/xsl/xsl.h
@@ -0,0 +1,44 @@
+/*
+ Copyright 2004, Xavier Neys (neysx@gentoo.org)
+
+ This file is part of gorg.
+
+ gorg 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 of the License, or
+ (at your option) any later version.
+
+ gorg 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 Foobar; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#ifndef __XSL_H__
+#define __XSL_H__
+
+#include <sys/stat.h>
+#include <ruby.h>
+#include <libxslt/xslt.h>
+#include <libexslt/exslt.h>
+#include <libxslt/xsltInternals.h>
+#include <libxslt/extra.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/transform.h>
+
+typedef struct S_cleanup
+{
+ char *params;
+ xmlDocPtr docxml, docxsl, docres;
+ xsltStylesheetPtr xsl;
+ xmlChar *docstr;
+}
+s_cleanup;
+
+#define XSL_VERSION "0.1"
+
+#endif