mirror of
https://gitlab.gnome.org/GNOME/libxslt
synced 2025-07-10 14:40:58 +03:00
2548 lines
110 KiB
HTML
2548 lines
110 KiB
HTML
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
|
||
"http://www.w3.org/TR/html4/loose.dtd">
|
||
<html>
|
||
<head>
|
||
<title>The XSLT C library for GNOME</title>
|
||
<meta name="GENERATOR" content="amaya 8.5, see http://www.w3.org/Amaya/">
|
||
<meta http-equiv="Content-Type" content="text/html">
|
||
</head>
|
||
|
||
<body bgcolor="#ffffff">
|
||
<h1 align="center">The XSLT C library for GNOME</h1>
|
||
|
||
<h1 style="text-align: center">libxslt</h1>
|
||
|
||
<p>Libxslt is the <a href="http://www.w3.org/TR/xslt">XSLT</a> C library
|
||
developed for the GNOME project. XSLT itself is a an XML language to define
|
||
transformation for XML. Libxslt is based on <a
|
||
href="http://xmlsoft.org/">libxml2</a> the XML C library developed for the
|
||
GNOME project. It also implements most of the <a
|
||
href="http://www.exslt.org/">EXSLT</a> set of processor-portable extensions
|
||
functions and some of Saxon's evaluate and expressions extensions.</p>
|
||
|
||
<p>People can either embed the library in their application or use xsltproc
|
||
the command line processing tool. This library is free software and can be
|
||
reused in commercial applications (see the <a href="intro.html">intro</a>)</p>
|
||
|
||
<p>External documents:</p>
|
||
<ul>
|
||
<li>John Fleck wrote <a href="tutorial/libxslttutorial.html">a tutorial for
|
||
libxslt</a></li>
|
||
<li><a href="xsltproc.html">xsltproc user manual</a></li>
|
||
<li><a href="http://xmlsoft.org/">the libxml documentation</a></li>
|
||
</ul>
|
||
|
||
<p></p>
|
||
|
||
<p>Logo designed by <a href="mailto:liyanage@access.ch">Marc Liyanage</a>.</p>
|
||
|
||
<h2><a name="Introducti">Introduction</a></h2>
|
||
|
||
<p>This document describes <a href="http://xmlsoft.org/XSLT/">libxslt</a>,
|
||
the <a href="http://www.w3.org/TR/xslt">XSLT</a> C library developed for the
|
||
<a href="http://www.gnome.org/">GNOME</a> project.</p>
|
||
|
||
<p>Here are some key points about libxslt:</p>
|
||
<ul>
|
||
<li>Libxslt is a C implementation</li>
|
||
<li>Libxslt is based on libxml for XML parsing, tree manipulation and XPath
|
||
support</li>
|
||
<li>It is written in plain C, making as few assumptions as possible, and
|
||
sticking closely to ANSI C/POSIX for easy embedding. Should works on
|
||
Linux/Unix/Windows.</li>
|
||
<li>This library is released under the <a
|
||
href="http://www.opensource.org/licenses/mit-license.html">MIT
|
||
Licence</a></li>
|
||
<li>Though not designed primarily with performances in mind, libxslt seems
|
||
to be a relatively fast processor.</li>
|
||
</ul>
|
||
|
||
<h2><a name="Documentat">Documentation</a></h2>
|
||
|
||
<p>There are some on-line resources about using libxslt:</p>
|
||
<ol>
|
||
<li>Check the <a href="html/libxslt-lib.html#LIBXSLT-LIB">API
|
||
documentation</a> automatically extracted from code comments (using the
|
||
program apibuild.py, developed for libxml, together with the xsl script
|
||
'newapi.xsl' and the libxslt xsltproc program).</li>
|
||
<li>Look at the <a href="http://mail.gnome.org/archives/xslt/">mailing-list
|
||
archive</a>.</li>
|
||
<li>Of course since libxslt is based on libxml, it's a good idea to at
|
||
least read <a href="http://xmlsoft.org/">libxml description</a></li>
|
||
</ol>
|
||
|
||
<h2><a name="Reporting">Reporting bugs and getting help</a></h2>
|
||
|
||
<p>If you need help with the XSLT language itself, here are a number of
|
||
useful resources:</p>
|
||
<ul>
|
||
<li>I strongly suggest to subscribe to <a
|
||
href="http://www.mulberrytech.com/xsl/xsl-list">XSL-list</a>, check <a
|
||
href="http://www.biglist.com/lists/xsl-list/archives/">the XSL-list
|
||
archives</a></li>
|
||
<li>The <a href="http://www.dpawson.co.uk/xsl/xslfaq.html">XSL FAQ</a>.</li>
|
||
<li>The <a
|
||
href="http://www.nwalsh.com/docs/tutorials/xsl/xsl/slides.html">tutorial</a>
|
||
written by Paul Grosso and Norman Walsh is a very good on-line
|
||
introdution to the language.</li>
|
||
<li>The <a
|
||
href="http://www.zvon.org/xxl/XSLTutorial/Books/Book1/index.html">only
|
||
Zvon XSLT tutorial</a> details a lot of constructs with examples.</li>
|
||
<li><a href="http://www.jenitennison.com/xslt/index.html">Jeni Tennison's
|
||
XSLT</a> pages provide links to a lot of answers</li>
|
||
<li>the <a href="http://incrementaldevelopment.com/xsltrick/">Gallery of
|
||
XSLT Tricks</a> provides non-standard use case of XSLT</li>
|
||
<li>And I suggest to buy Michael Kay "XSLT Programmer's Reference" book
|
||
published by <a href="http://www.wrox.com/">Wrox</a> if you plan to work
|
||
seriously with XSLT in the future.</li>
|
||
</ul>
|
||
|
||
<p>Well, bugs or missing features are always possible, and I will make a
|
||
point of fixing them in a timely fashion. The best way to report a bug is to
|
||
use the <a
|
||
href="http://bugzilla.gnome.org/enter_bug.cgi?product=libxslt">GNOME bug
|
||
tracking database</a> (make sure to use the "libxslt" module name). Before
|
||
filing a bug, check the <a
|
||
href="http://bugzilla.gnome.org/buglist.cgi?product=libxslt">list of existing
|
||
libxslt bugs</a> to make sure it hasn't already been filed. I look at reports
|
||
there regularly and it's good to have a reminder when a bug is still open. Be
|
||
sure to specify that the bug is for the package libxslt.</p>
|
||
|
||
<p>For small problems you can try to get help on IRC, the #xml channel on
|
||
irc.gnome.org (port 6667) usually have a few person subscribed which may help
|
||
(but there is no guarantee and if a real issue is raised it should go on the
|
||
mailing-list for archival).</p>
|
||
|
||
<p>There is also a mailing-list <a
|
||
href="mailto:xslt@gnome.org">xslt@gnome.org</a> for libxslt, with an <a
|
||
href="http://mail.gnome.org/archives/xslt/">on-line archive</a>. To subscribe
|
||
to this list, please visit the <a
|
||
href="http://mail.gnome.org/mailman/listinfo/xslt">associated Web</a> page
|
||
and follow the instructions.</p>
|
||
|
||
<p>Alternatively, you can just send the bug to the <a
|
||
href="mailto:xslt@gnome.org">xslt@gnome.org</a> list, if it's really libxslt
|
||
related I will approve it.. Please do not send me mail directly especially
|
||
for portability problem, it makes things really harder to track and in some
|
||
cases I'm not the best person to answer a given question, ask the list
|
||
instead. <strong>Do not send code, I won't debug it</strong> (but patches are
|
||
really appreciated!).</p>
|
||
|
||
<p>Please note that with the current amount of virus and SPAM, sending mail
|
||
to the list without being subscribed won't work. There is *far too many
|
||
bounces* (in the order of a thousand a day !) I cannot approve them manually
|
||
anymore. If your mail to the list bounced waiting for administrator approval,
|
||
it is LOST ! Repost it and fix the problem triggering the error. Also please
|
||
note that <span style="color: #FF0000; background-color: #FFFFFF">emails with
|
||
a legal warning asking to not copy or redistribute freely the information
|
||
they contain</span> are <strong>NOT</strong> acceptable for the mailing-list,
|
||
such mail will as much as possible be discarded automatically, and are less
|
||
likely to be answered if they made it to the list, <strong>DO NOT</strong>
|
||
post to the list from an email address where such legal requirements are
|
||
automatically added, get private paying support if you can't share
|
||
information.</p>
|
||
|
||
<p>Check the following too <span style="color: #E50000">before
|
||
posting</span>:</p>
|
||
<ul>
|
||
<li><a href="search.php">use the search engine</a> to get information
|
||
related to your problem.</li>
|
||
<li>make sure you are <a href="ftp://xmlsoft.org/libxslt/">using a recent
|
||
version</a>, and that the problem still shows up in those</li>
|
||
<li>check the <a href="http://mail.gnome.org/archives/xslt/">list
|
||
archives</a> to see if the problem was reported already, in this case
|
||
there is probably a fix available, similarly check the <a
|
||
href="http://bugzilla.gnome.org/buglist.cgi?product=libxslt">registered
|
||
open bugs</a></li>
|
||
<li>make sure you can reproduce the bug with xsltproc, a very useful thing
|
||
to do is run the transformation with -v argument and redirect the
|
||
standard error to a file, then search in this file for the transformation
|
||
logs just preceding the possible problem</li>
|
||
<li>Please send the command showing the error as well as the input and
|
||
stylesheet (as an attachment)</li>
|
||
</ul>
|
||
|
||
<p>Then send the bug with associated information to reproduce it to the <a
|
||
href="mailto:xslt@gnome.org">xslt@gnome.org</a> list; if it's really libxslt
|
||
related I will approve it. Please do not send mail to me directly, it makes
|
||
things really hard to track and in some cases I am not the best person to
|
||
answer a given question, ask on the list.</p>
|
||
|
||
<p>To <span style="color: #E50000">be really clear about support</span>:</p>
|
||
<ul>
|
||
<li>Support or help <span style="color: #E50000">request MUST be sent to
|
||
the list or on bugzilla</span> in case of problems, so that the Question
|
||
and Answers can be shared publicly. Failing to do so carries the implicit
|
||
message "I want free support but I don't want to share the benefits with
|
||
others" and is not welcome. I will automatically Carbon-Copy the
|
||
xslt@gnome.org mailing list for any technical reply made about libxml2 or
|
||
libxslt.</li>
|
||
<li>There is <span style="color: #E50000">no guarantee for support</span>,
|
||
if your question remains unanswered after a week, repost it, making sure
|
||
you gave all the detail needed and the information requested.</li>
|
||
<li>Failing to provide information as requested or double checking first
|
||
for prior feedback also carries the implicit message "the time of the
|
||
library maintainers is less valuable than my time" and might not be
|
||
welcome.</li>
|
||
</ul>
|
||
|
||
<p>Of course, bugs reports with a suggested patch for fixing them will
|
||
probably be processed faster.</p>
|
||
|
||
<p>If you're looking for help, a quick look at <a
|
||
href="http://mail.gnome.org/archives/xslt/">the list archive</a> may actually
|
||
provide the answer, I usually send source samples when answering libxslt
|
||
usage questions. The <a
|
||
href="html/libxslt-lib.html#LIBXSLT-LIB">auto-generated documentation</a> is
|
||
not as polished as I would like (I need to learn more about Docbook), but
|
||
it's a good starting point.</p>
|
||
|
||
<h2><a name="help">How to help</a></h2>
|
||
|
||
<p>You can help the project in various ways, the best thing to do first is to
|
||
subscribe to the mailing-list as explained before, check the <a
|
||
href="http://mail.gnome.org/archives/xslt/">archives </a>and the <a
|
||
href="http://bugzilla.gnome.org/buglist.cgi?product=libxslt">GNOME bug
|
||
database:</a>:</p>
|
||
<ol>
|
||
<li>provide patches when you find problems</li>
|
||
<li>provide the diffs when you port libxslt to a new platform. They may not
|
||
be integrated in all cases but help pinpointing portability problems
|
||
and</li>
|
||
<li>provide documentation fixes (either as patches to the code comments or
|
||
as HTML diffs).</li>
|
||
<li>provide new documentations pieces (translations, examples, etc ...)</li>
|
||
<li>Check the TODO file and try to close one of the items</li>
|
||
<li>take one of the points raised in the archive or the bug database and
|
||
provide a fix. <a href="mailto:daniel@veillard.com">Get in touch with me
|
||
</a>before to avoid synchronization problems and check that the suggested
|
||
fix will fit in nicely :-)</li>
|
||
</ol>
|
||
|
||
<h2><a name="Downloads">Downloads</a></h2>
|
||
|
||
<p>The latest versions of libxslt can be found on the <a
|
||
href="ftp://xmlsoft.org/libxslt/">xmlsoft.org</a> server. (NOTE that
|
||
you need the <a href="http://rpmfind.net/linux/RPM/libxml2.html">libxml2</a>,
|
||
<a href="http://rpmfind.net/linux/RPM/libxml2-devel.html">libxml2-devel</a>,
|
||
<a href="http://rpmfind.net/linux/RPM/libxslt.html">libxslt</a> and <a
|
||
href="http://rpmfind.net/linux/RPM/libxslt-devel.html">libxslt-devel</a>
|
||
packages installed to compile applications using libxslt.) <a
|
||
href="mailto:igor@zlatkovic.com">Igor Zlatkovic</a> is now the maintainer of
|
||
the Windows port, <a
|
||
href="http://www.zlatkovic.com/projects/libxml/index.html">he provides
|
||
binaries</a>. <a href="http://opencsw.org/">CSW</a> provides
|
||
<a href="http://opencsw.org/packages/libxslt">Solaris binaries</a>, and
|
||
<a href="mailto:Steve.Ball@explain.com.au">Steve Ball</a> provides <a
|
||
href="http://www.explain.com.au/oss/libxml2xslt.html">Mac Os X
|
||
binaries</a>.</p>
|
||
|
||
<p><a name="Snapshot">Snapshot:</a></p>
|
||
<ul>
|
||
<li>Code from the GNOME GIT base libxslt module, updated hourly <a
|
||
href="ftp://xmlsoft.org/libxml2/libxslt-git-snapshot.tar.gz">libxslt-git-snapshot.tar.gz</a>.</li>
|
||
</ul>
|
||
|
||
<p><a name="Contribs">Contribs:</a></p>
|
||
|
||
<p>I do accept external contributions, especially if compiling on another
|
||
platform, get in touch with me to upload the package. I will keep them in the
|
||
<a href="ftp://xmlsoft.org/libxml2/contribs/">contrib directory</a></p>
|
||
|
||
<p>Libxslt is also available from GIT:</p>
|
||
<ul>
|
||
<li><p>See <a href="http://git.gnome.org/browse/libxslt/">libxslt Git web</a>.
|
||
To checkout a local tree use:</p>
|
||
<pre>git clone git://git.gnome.org/libxslt</pre>
|
||
</li>
|
||
<li>The <strong>libxml2</strong> module is also present
|
||
<a href="http://git.gnome.org/browse/libxml2/">there</a></li>
|
||
</ul>
|
||
|
||
|
||
<h2><a name="FAQ">FAQ</a></h2>
|
||
<ol>
|
||
<li><em>Troubles compiling or linking programs using libxslt</em>
|
||
<p>Usually the problem comes from the fact that the compiler doesn't get
|
||
the right compilation or linking flags. There is a small shell script
|
||
<code>xslt-config</code> which is installed as part of libxslt usual
|
||
install process which provides those flags. Use</p>
|
||
<p><code>xslt-config --cflags</code></p>
|
||
<p>to get the compilation flags and</p>
|
||
<p><code>xslt-config --libs</code></p>
|
||
<p>to get the linker flags. Usually this is done directly from the
|
||
Makefile as:</p>
|
||
<p><code>CFLAGS=`xslt-config --cflags`</code></p>
|
||
<p><code>LIBS=`xslt-config --libs`</code></p>
|
||
<p>Note also that if you use the EXSLT extensions from the program then
|
||
you should prepend <code>-lexslt</code> to the LIBS options</p>
|
||
</li>
|
||
<li><em>passing parameters on the xsltproc command line doesn't work</em>
|
||
<p><em>xsltproc --param test alpha foo.xsl foo.xml</em></p>
|
||
<p><em>the param does not get passed and ends up as ""</em></p>
|
||
<p>In a nutshell do a double escaping at the shell prompt:</p>
|
||
<p>xsltproc --param test "'alpha'" foo.xsl foo.xml</p>
|
||
<p>i.e. the string value is surrounded by " and ' then terminated by '
|
||
and ". Libxslt interpret the parameter values as XPath expressions, so
|
||
the string -><code>alpha</code><- is intepreted as the node set
|
||
matching this string. You really want -><code>'alpha'</code><- to
|
||
be passed to the processor. And to allow this you need to escape the
|
||
quotes at the shell level using -><code>"'alpha'"</code><- .</p>
|
||
<p>or use</p>
|
||
<p>xsltproc --stringparam test alpha foo.xsl foo.xml</p>
|
||
</li>
|
||
<li><em>Is there C++ bindings ?</em>
|
||
<p>Yes for example <a
|
||
href="http://pmade.org/pjones/software/xmlwrapp/">xmlwrapp</a> , see <a
|
||
href="python.html">the related pages about bindings</a></p>
|
||
</li>
|
||
</ol>
|
||
|
||
<h2><a name="News">News</a></h2>
|
||
|
||
<p>The <a href="ChangeLog.html">change log</a> describes the recents commits
|
||
to the <a href="http://svn.gnome.org/viewcvs/libxslt/trunk/">SVN</a> code base.</p>
|
||
|
||
<p>Those are the public releases made:</p>
|
||
|
||
<h3>1.1.26: Sep 24 2009</h3>
|
||
<ul>
|
||
<li> Improvement:
|
||
Add xsltProcessOneNode to exported symbols for lxml (Daniel Veillard)
|
||
</li>
|
||
<li> Bug fixes:
|
||
Fix an idness generation problem (Daniel Veillard),
|
||
595612 Try to fix some locking problems (Daniel Veillard),
|
||
Fix a crash on misformed imported stylesheets (Daniel Veillard)
|
||
</li>
|
||
</ul>
|
||
<h3>1.1.25: Sep 17 2009</h3>
|
||
<ul>
|
||
<li> Features:
|
||
Add API versioning and various cleanups (Daniel Veillard),
|
||
xsl:sort lang support using the locale (Nick Wellnhofer and Roumen Petrov)
|
||
</li>
|
||
<li> Documentation:
|
||
Fix the download links for Solaris (Daniel Veillard),
|
||
Fix makefile and spec file to include doc in rpm (Daniel Veillard)
|
||
</li>
|
||
<li> Portability:
|
||
Make sure testThreads is linked with pthreads (Daniel Veillard),
|
||
Fix potential crash on debug of extensions Solaris (Ben Walton),
|
||
applied patch from Roumen Petrov for mingw cross compilation problems (Roumen Petrov),
|
||
patch from Richard Jones to build shared libs with MinGW cross-compiler (Richard Jones),
|
||
fix include path when compiling with MinGW (Roumen Petrov),
|
||
portability fixes ( Nick Wellnhofer and Roumen Petrov)
|
||
</li>
|
||
<li> Bug fixes:
|
||
Big fixes of pattern compilations (Nick Wellnhofer),
|
||
Fix uses of xmlAddChild for error handling (Daniel Veillard),
|
||
Detect deep recusion on function calls (Daniel Veillard),
|
||
Avoid an error in namespace generation (Martin),
|
||
Fix importing of encoding from included stylesheets (Nick Wellnhofer),
|
||
Fix problems with embedded stylesheets and namespaces (Martin),
|
||
QName parsing fix for patterns (Martin),
|
||
Crash compiling stylesheet with DTD (Martin),
|
||
Fix xsl:strip-space with namespace and wildcard (Nick Wellnhofer),
|
||
Fix a mutex deadlock on unregistered extensions (Nix),
|
||
567192 xsltproc --output option ignore --xinclude (Joachim Breitner),
|
||
Fix redundant headers in list (Daniel Veillard),
|
||
134754 Configure's --with-html-dir related fixes (Julio M. Merino Vidal),
|
||
305913 a serious problem in extensions reentrancy (Daniel Veillard),
|
||
Fix an idness issue when building the tree (Daniel Veillard),
|
||
Fixed indexing error reported by Ron Burk on the mailing list. (William M. Brack),
|
||
prevent some unchecked pointer accesses (Jake Goulding),
|
||
fix for CVE-2008-2935 libexslt RC4 encryption/decryption functions Daniel (Daniel Veillard),
|
||
avoid a quadratic behaviour when hitting duplicates (Daniel Veillard),
|
||
544829 fixed option --with-debugger (Arun Ragnavan),
|
||
541965 fixed incorrect argument popping in exsltMathAtan2Function (William M. Brack),
|
||
fix problem with string check for element-available (Ron Burk),
|
||
539741 added code to handle literal within an AVT (William M. Brack)
|
||
</li>
|
||
<li> Improvements:
|
||
Allow use of EXSLT outside XSLT (Martin),
|
||
Support Esperanto locale (Nick Wellnhofer),
|
||
Change how attributes are copied for id and speed (Daniel Veillard),
|
||
Add API versioning and various cleanups (Daniel Veillard),
|
||
Adding a test program to check thread reentrancy (Daniel Veillard),
|
||
big patch from finishing xsl:sort lang support (Roumen Petrov),
|
||
add xsl:sort lang support using the locale (Nick Wellnhofer)
|
||
</li>
|
||
<li> Cleanups:
|
||
Label xsltProcessOneNode as static (Daniel Veillard),
|
||
git setup (Daniel Veillard),
|
||
fixed typo detected by new libxml2 code (William M. Brack),
|
||
xsltExtFunctionLookup was defined but never implemented (Ralf Junker)
|
||
</li>
|
||
</ul>
|
||
<h3>1.1.24: May 13 2008</h3>
|
||
<ul>
|
||
<li>Documentation: man page fix (Vincent Lefevre).</li>
|
||
<li>Bug fixes: pattern bug fix, key initialization problems, exclusion of
|
||
unknown namespaced element on top of stylesheets, python generator
|
||
syntactic cleanup (Martin)</li>
|
||
</ul>
|
||
<h3>1.1.23: Apr 8 2008</h3>
|
||
<ul>
|
||
<li>Documentation: fix links for Cygwin DocBook setup (Philippe Bourcier),
|
||
xsltParseStylesheetDoc doc fix (Jason Viers), fix manpage default
|
||
maxdepth value </li>
|
||
<li>Bug fixes: python segfault (Daniel Gryniewicz), week-in-year bug fix
|
||
(Maurice van der Pot), fix python iterator problem (William Brack),
|
||
avoid garbage collection problems on str:tokenize and str:split
|
||
and function results (William Brack and Peter Pawlowski)
|
||
superfluous re-generation of keys (William Brack), remove superfluous
|
||
code in xsltExtInitTest (Tony Graham), func:result segfault fix
|
||
(William Brack), timezone offset problem (Peter Pawlowski),</li>
|
||
<li>Portability fixes: old gcrypt support fix (Brent Cowgill), Python
|
||
portability patch (Stephane Bidoul), VS 2008 fix (Rob Richard) </li>
|
||
</ul>
|
||
<h3>1.1.22: Aug 23 2007</h3>
|
||
<ul>
|
||
<li>Bug fixes: RVT cleanup problems (William Brack), exclude-result-prefix
|
||
bug (William Brack), stylesheet compilation error handling (Rob Richards).
|
||
</li>
|
||
<li>Portability fixes: improve build with VS2005 (Rob Richards),
|
||
fixing build on AIX (Bjorn Wiberg), fix the security file checks on
|
||
Windows (Roland Schwarz and Rob Richards). </li>
|
||
<li>Improvement: add an --encoding option to xsltproc (Drazen Kacar). </li>
|
||
</ul>
|
||
<h3>1.1.21: Jun 12 2007</h3>
|
||
<ul>
|
||
<li>Bug fixes: out of memory allocation errors (William Brack),
|
||
namespace problem on compound predicates (William Brack),
|
||
python space/tab inconsistencies (Andreas Hanke), hook xsl:message
|
||
to per transformation error callbacks (Shaun McCance),
|
||
cached RVT problem (William Brack), XPath context maintainance
|
||
on choose (William Brack), memory leaks in the math module (William
|
||
Brack), exclude-result-prefix induced namespace problem (William
|
||
Brack)</li>
|
||
<li>Build: configure setup for TRIO_REPLACE_STDIO (William Brack)
|
||
<li>Documentation: updated after change from CVs to SVN (William Brack)</li>
|
||
</ul>
|
||
<h3>1.1.20: Jan 17 2007</h3>
|
||
<ul>
|
||
<li>Portability fixes: strict aliasing fix (Marcus Meissner), BSD portability
|
||
patches (Roland Illig)</li>
|
||
<li>Bug fixes: Result Value Tree handling fix (William Brack), function
|
||
parameters fix (William), uninitialized variable (Kjartan Maraas),
|
||
empty text node handling (William), plugin support and test fixes (William),
|
||
fragment support fixes (William)</li>
|
||
<li>Improvements: python stylesheet compare and transform context
|
||
access (Nic Ferrier), EXSLT string replace support (Joel Reed),
|
||
xsltproc better low level error handling (Mike Hommey and William)</li>
|
||
</ul>
|
||
<h3>1.1.19: Nov 29 2006</h3>
|
||
<ul>
|
||
<li>Bug fixes: entities within attributes (William Brack), Python detection
|
||
problem (Joseph Sacco), in-scope namespace bug (Mike Hommey), Result
|
||
value tree caching bug (William Brack)</li>
|
||
</ul>
|
||
<h3>1.1.18: Oct 26 2006</h3>
|
||
<ul>
|
||
<li>portability and build fixes: DESTDIR problem, build paths in python
|
||
shared lib, compile when libxml2 doesn't support XInclude (Gary Coady).</li>
|
||
<li>bug fixes: a number of namespace related bugs (Kasimier Buchcik),
|
||
parameters bugs (Kasimier Buchcik), proximity position in predicates
|
||
of match patterns (Kasimier), exslt-node-set troubles with strings
|
||
(Kasimier), CDATA serialization, Python floats and booleans XPath
|
||
conversions, XInclude support fixes, RVT cleanup problem (William Brack
|
||
and Kasimier), attribute checking in stylesheets (Kasimier), xsltForEach
|
||
context problem (Kasimier), security check should pass full URLs (Shane
|
||
Corgatelli), security cleanup patch (Mikhail Zabaluev), some python
|
||
accessor for stylesheet were broken, memory errors when compiling
|
||
stylesheets (Mike Hommey), EXSLT current date end-of-month problem
|
||
(William Brack).</li>
|
||
<li>improvements: refactoring of namespace handling, value-of impleemntation
|
||
and template internal processing (Kasimier Buchcik), new xsltproc
|
||
flag to apply Xinclude to stylesheets.</li>
|
||
<li>documentation: xsltproc man pages (Daniel Leidert), tests updates
|
||
(William Brack), various typo fixes (Daniel Leidert), comments on
|
||
versions macros (Peter Breitenlohner).</li>
|
||
</ul>
|
||
<h3>1.1.17: Jun 6 2006</h3>
|
||
<ul>
|
||
<li>portability fixes: python detection</li>
|
||
<li>bug fixes: some regression tests, attribute/namespaces output (Kasimier
|
||
Buchcik), problem in mixed xsl:value-of and xsl:text uses (Kasimier)</li>
|
||
<li>improvements: internal refactoring (Kasimier Buchcik), use of the XPath
|
||
object cache in libxml2-2.6.25 (Kasimier)</li>
|
||
</ul>
|
||
|
||
<h3>1.1.16: May 01 2006</h3>
|
||
<ul>
|
||
<li>portability fixes: EXSLT date/time on Solaris and IRIX (Albert Chin),
|
||
HP-UX build (Albert Chin),
|
||
<li>build fixes: Python detection(Joseph Sacco), plugin configurei
|
||
(Joel Reed)</li>
|
||
<li>bug fixes: pattern compilation fix(William Brack), EXSLT date/time
|
||
fix (Thomas Broyer), EXSLT function bug, potential loop on variable
|
||
eval, startup race (Christopher Palmer), debug statement left in python
|
||
(Nic Ferrier), various cleanup based on Coverity reports), error on
|
||
Out of memory condition (Charles Hardin), various namespace prefixes
|
||
fixes (Kasimier Buchcik), </li>
|
||
<li>improvement: speed up sortingi, start of internals refactoring (Kasimier
|
||
Buchcik)</li>
|
||
<li>documentation: man page fixes and updates (Daniel Leidert)
|
||
</ul>
|
||
|
||
<h3>1.1.15: Sep 04 2005</h3>
|
||
<ul>
|
||
<li>build fixes: Windows build cleanups and updates (Igor Zlatkovic),
|
||
remove jhbuild warnings</li>
|
||
<li>bug fixes: negative number formatting (William Brack), number
|
||
formatting per mille definition (William Brack), XInclude default values
|
||
(William), text copy bugs (William), bug related to xmlXPathContext size,
|
||
reuse libxml2 memory management for text nodes, dictionary text bug,
|
||
forbid variables in match (needs libxml2-2.6.21)</li>
|
||
<li>improvements: EXSLT dyn:map (Mark Vakoc),</li>
|
||
<li>documentation: EXSLT date and time functions namespace in man (Jonathan
|
||
Wakely)</li>
|
||
</ul>
|
||
|
||
<h3>1.1.14: Apr 02 2005</h3>
|
||
<ul>
|
||
<li>bug fixes: text node on stylesheet document without a dictionary
|
||
(William Brack), more checking of XSLT syntax, calling xsltInit()
|
||
multiple times, mode values interning raised by Mark Vakoc, bug in
|
||
pattern matching with ancestors, bug in patterna matching with cascading
|
||
select, xinclude and document() problem, build outside of source tree
|
||
(Mike Castle)</li>
|
||
<li>improvement: added a --nodict mode to xsltproc to check problems for
|
||
docuemtns without dictionaries</li>
|
||
</ul>
|
||
|
||
<h3>1.1.13: Mar 13 2005</h3>
|
||
<ul>
|
||
<li>build fixes: 64bits cleanup (William Brack), python 2.4 test (William),
|
||
LIBXSLT_VERSION_EXTRA on Windows (William), Windows makefiles fixes (Joel
|
||
Reed), libgcrypt-devel requires for RPM spec.</li>
|
||
<li>bug fixes: exslt day-of-week-in-month (Sal Paradise), xsl:call-template
|
||
should not change the current template rule (William Brack), evaluation
|
||
of global variables (William Brack), RVT's in XPath predicates (William),
|
||
namespace URI on template names (Mark Vakoc), stat() for Windows patch
|
||
(Aleksey Gurtovoy), pattern expression fixes (William Brack), out of
|
||
memory detection misses (William), parserOptions propagation (William),
|
||
exclude-result-prefixes fix (William), // patten fix (William).</li>
|
||
<li>extensions: module support (Joel Reed), dictionary based speedups
|
||
trying to get rid of xmlStrEqual as much as possible.</li>
|
||
<li>documentation: added Wiki (Joel Reed)</li>
|
||
</ul>
|
||
|
||
<h3>1.1.12: Oct 29 2004</h3>
|
||
<ul>
|
||
<li>build fixes: warnings removal (William).</li>
|
||
<li>bug fixes: attribute document pointer fix (Mark Vakoc), exslt date
|
||
negative periods (William Brack), generated tree structure fixes,
|
||
namespace lookup fix, use reentrant gmtime_r (William Brack),
|
||
exslt:funtion namespace fix (William), potential NULL pointer reference
|
||
(Dennis Dams, William), force string interning on generated
|
||
documents.</li>
|
||
<li>documentation: update of the second tutorial (Panagiotis Louridas), add
|
||
exslt doc in rpm packages, fix the xsltproc man page.</li>
|
||
</ul>
|
||
|
||
<h3>1.1.11: Sep 29 2004</h3>
|
||
<ul>
|
||
<li>bug fixes: xsl:include problems (William Brack), UTF8 number pattern
|
||
(William), date-time validation (William), namespace fix (William),
|
||
various Exslt date fixes (William), error callback fixes, leak with
|
||
namespaced global variable, attempt to fix a weird problem #153137</li>
|
||
<li>improvements: exslt:date-sum tests (Derek Poon)</li>
|
||
<li>documentation: second tutorial by Panagiotis Lourida</li>
|
||
</ul>
|
||
|
||
<h3>1.1.10: Aug 31 2004</h3>
|
||
<ul>
|
||
<li>build fix: NUL in c file blocking compilation on Solaris, Windows build
|
||
(Igor Zlatkovic)</li>
|
||
<li>fix: key initialization problem (William Brack)</li>
|
||
<li>documentation: fixed missing man page description for --path</li>
|
||
</ul>
|
||
|
||
<h3>1.1.9: Aug 22 2004</h3>
|
||
<ul>
|
||
<li>build fixes: missing tests (William Brack), Python dependancies, Python
|
||
on 64bits boxes, --with-crypto flag (Rob Richards),</li>
|
||
<li>fixes: RVT key handling (William), Python binding (William and Sitsofe
|
||
Wheeler), key and XPath troubles (William), template priority on imports
|
||
(William), str:tokenize with empty strings (William), #default namespace
|
||
alias behaviour (William), doc ordering missing for main document
|
||
(William), 64bit bug (Andreas Schwab)</li>
|
||
<li>improvements: EXSLT date:sum added (Joel Reed), hook for document
|
||
loading for David Hyatt, xsltproc --nodtdattr to avoid defaulting DTD
|
||
attributes, extend xsltproc --version with CVS stamp (William).</li>
|
||
<li>Documentation: web page problem reported by Oliver Stoeneberg</li>
|
||
</ul>
|
||
|
||
<h3>1.1.8: July 5 2004</h3>
|
||
<ul>
|
||
<li>build fixes: Windows runtime options (Oliver Stoeneberg), Windows
|
||
binary package layout (Igor Zlatkovic), libgcrypt version test and link
|
||
(William)</li>
|
||
<li>documentation: fix libxslt namespace name in doc (William)</li>
|
||
<li>bug fixes: undefined namespace message (William Brack), search engine
|
||
(William), multiple namespace fixups (William), namespace fix for key
|
||
evaluation (William), Python memory debug bindings,</li>
|
||
<li>improvements: crypto extensions for exslt (Joel Reed, William)</li>
|
||
</ul>
|
||
|
||
<h3>1.1.7: May 17 2004</h3>
|
||
<ul>
|
||
<li>build fix: warning about localtime_r on Solaris</li>
|
||
<li>bug fix: UTF8 string tokenize (William Brack), subtle memory
|
||
corruption, linefeed after comment at document level (William),
|
||
disable-output-escaping problem (William), pattern compilation in deep
|
||
imported stylesheets (William), namespace extension prefix bug,
|
||
libxslt.m4 bug (Edward Rudd), namespace lookup for attribute, namespaced
|
||
DOCTYPE name</li>
|
||
</ul>
|
||
|
||
<h3>1.1.6: Apr 18 2004</h3>
|
||
<ul>
|
||
<li>2 bug fixes about keys fixed one by Mark Vakoc</li>
|
||
</ul>
|
||
|
||
<h3>1.1.5: Mar 23 2004</h3>
|
||
<ul>
|
||
<li>performance: use dictionary lookup for variables</li>
|
||
<li>remove use of _private from source documents</li>
|
||
<li>cleanup of "make tests" output</li>
|
||
<li>bugfixes: AVT in local variables, use localtime_r to avoid thread
|
||
troubles (William), dictionary handling bug (William), limited number of
|
||
stubstitutions in AVT (William), tokenize fix for UTF-8 (William),
|
||
superfluous namespace (William), xsltproc error code on
|
||
<xsl:message> halt, OpenVMS fix, dictionary reference counting
|
||
change.</li>
|
||
</ul>
|
||
|
||
<h3>1.1.4: Feb 23 2004</h3>
|
||
<ul>
|
||
<li>bugfixes: attributes without doc (Mariano Su<53>rez-Alvarez), problem with
|
||
Yelp, extension problem</li>
|
||
<li>display extension modules (Steve Little)</li>
|
||
<li>Windows compilation patch (Mark Vadoc), Mingw (Mikhail Grushinskiy)</li>
|
||
</ul>
|
||
|
||
<h3>1.1.3: Feb 16 2004</h3>
|
||
<ul>
|
||
<li>Rewrote the Attribute Value Template code, new XPath compilation
|
||
interfaces, dictionary reuses for XSLT with potential for serious
|
||
performance improvements.</li>
|
||
<li>bug fixes: portability (William Brack), key() in node-set() results
|
||
(William), comment before doctype (William), math and node-set() problems
|
||
(William), cdata element and default namespace (William), behaviour on
|
||
unknown XSLT elements (Stefan Kost), priority of "//foo" patterns
|
||
(William), xsl:element and xsl:attribute QName check (William), comments
|
||
with -- (William), attribute namespace (William), check for ?> in PI
|
||
(William)</li>
|
||
<li>Documentations: cleanup (John Fleck and William)</li>
|
||
<li>Python: patch for OS-X (Gianni Ceccarelli), enums export (Stephane
|
||
bidoul)</li>
|
||
</ul>
|
||
|
||
<h3>1.1.2: Dec 24 2003</h3>
|
||
<ul>
|
||
<li>Documentation fixes (John Fleck, William Brack), EXSLT documentation
|
||
(William Brack)</li>
|
||
<li>Windows compilation fixes for MSVC and Mingw (Igor Zlatkovic)</li>
|
||
<li>Bug fixes: exslt:date returning NULL strings (William Brack),
|
||
namespaces output (William Brack), key and namespace definition problem,
|
||
passing options down to the document() parser, xsl:number fixes (William
|
||
Brack)</li>
|
||
</ul>
|
||
|
||
<h3>1.1.1: Dec 10 2003</h3>
|
||
<ul>
|
||
<li>code cleanup (William Brack)</li>
|
||
<li>Windows: Makefile improvements (Igor Zlatkovic)</li>
|
||
<li>documentation improvements: William Brack, libexslt man page (Jonathan
|
||
Wakely)</li>
|
||
<li>param in EXSLT functions (Shaun McCance)</li>
|
||
<li>XSLT debugging improvements (Mark Vakoc)</li>
|
||
<li>bug fixes: number formatting (Bjorn Reese), exslt:tokenize (William
|
||
Brack), key selector parsing with | reported by Oleg Paraschenko,
|
||
xsl:element with computed namespaces (William Brack), xslt:import/include
|
||
recursion detection (William Brack), exslt:function used in keys (William
|
||
Brack), bug when CDATA_SECTION are foun in the tree (William Brack),
|
||
entities handling when using XInclude.</li>
|
||
</ul>
|
||
|
||
<h3>1.1.0: Nov 4 2003</h3>
|
||
<ul>
|
||
<li>Removed DocBook SGML broken support</li>
|
||
<li>fix xsl:key to work with PIs</li>
|
||
<li>Makefile and build improvement (Graham Wilson), build cleanup (William
|
||
Brack), macro fix (Justin Fletcher), build outside of source tree (Roumen
|
||
Petrov)</li>
|
||
<li>xsltproc option display fix (Alexey Efimov), --load-trace (Crutcher
|
||
Dunnavant)</li>
|
||
<li>Python: never use stdout for error</li>
|
||
<li>extension memory error fix (Karl Eichwalder)</li>
|
||
<li>header path fixes (Steve Ball)</li>
|
||
<li>added saxon:line-number() to libexslt (Brett Kail)</li>
|
||
<li>Fix some tortuous template problems when using predicates (William
|
||
Brack)</li>
|
||
<li>Debugger status patch (Kasimier Buchcik)</li>
|
||
<li>Use new libxml2-2.6.x APIs for faster processing</li>
|
||
<li>Make sure xsl:sort is empty</li>
|
||
<li>Fixed a bug in default processing of attributes</li>
|
||
<li>Removes the deprecated breakpoint library</li>
|
||
<li>detect invalid names on templates (William Brack)</li>
|
||
<li>fix exslt:document (and similar) base handling problem</li>
|
||
</ul>
|
||
|
||
<h3>1.0.33: Sep 12 2003</h3>
|
||
|
||
<p>This is a bugfix only release</p>
|
||
<ul>
|
||
<li>error message missing argument (William Brack)</li>
|
||
<li>mode not cascaded in template fallbacks (William Brack)</li>
|
||
<li>catch redefinition of parameter/variables (William Brack)</li>
|
||
<li>multiple keys with same namespace name (William Brack)</li>
|
||
<li>patch for compilation using MingW on Windows (Mikhail Grushinskiy)</li>
|
||
<li>header export macros for Windows (Igor Zlatkovic)</li>
|
||
<li>cdata-section-elements handling of namespaced names</li>
|
||
<li>compilation without libxml2 XPointer support (Mark Vadoc)</li>
|
||
<li>apply-templates crash (William Brack)</li>
|
||
<li>bug with imported templates (William Brack)</li>
|
||
<li>imported attribute-sets merging bug (DocBook) (William Brack)</li>
|
||
</ul>
|
||
|
||
<h3>1.0.32: Aug 9 2003</h3>
|
||
<ul>
|
||
<li>bugfixes: xsltSaveResultToFile() python binding (Chris Jaeger), EXSLT
|
||
function (William Brack), RVT for globals (William Brack), EXSLT date
|
||
(William Brack),
|
||
<p>speed of large text output, xsl:copy with attributes, strip-space and
|
||
namespaces prefix, fix for --path xsltproc option, EXST:tokenize (Shaun
|
||
McCance), EXSLT:seconds (William Brack), sort with multiple keys (William
|
||
Brack), checking of { and } for attribute value templates (William
|
||
Brack)</p>
|
||
</li>
|
||
<li>Python bindings for extension elements (Sean Treadway)</li>
|
||
<li>EXSLT:split added (Shaun McCance)</li>
|
||
<li>portability fixes for HP-UX/Solaris/IRIX (William Brack)</li>
|
||
<li>doc cleanup</li>
|
||
</ul>
|
||
|
||
<h3>1.0.31: Jul 6 2003</h3>
|
||
<ul>
|
||
<li>bugfixes: xsl:copy on namespace nodes, AVT for xsl:sort order, fix for
|
||
the debugger (Keith Isdale), output filename limitation, trio.h and
|
||
triodef.h added (Albert Chin), EXSLT node-set (Peter Breitenlohner),
|
||
xsltChoose and whitespace (Igor Zlatkovic),
|
||
<p>stylesheet compilation (Igor Zlatkovic), NaN and sort (William Brack),
|
||
RVT bug introduced in 1.0.30</p>
|
||
</li>
|
||
<li>avoid generating &quot; (fix in libxml2-2.5.8)</li>
|
||
<li>fix 64bit cleaness problem and compilation troubles introduced in
|
||
1.0.30</li>
|
||
<li>Windows makefile generation (Igor Zlatkovic)</li>
|
||
<li>HP-UX portability fix</li>
|
||
</ul>
|
||
|
||
<h3>1.0.30: May 4 2003</h3>
|
||
<ul>
|
||
<li>Fixes and new APIs to handle Result Value Trees and avoid leaks</li>
|
||
<li>Fixes for: EXSLT math pow() function (Charles Bozeman), global
|
||
parameter and global variables mismatch, a segfault on pattern
|
||
compilation errors, namespace copy in xsl:copy-of, python generator
|
||
problem, OpenVMS trio update, premature call to xsltFreeStackElem (Igor),
|
||
current node when templates applies to attributes</li>
|
||
</ul>
|
||
|
||
<h3>1.0.29: Apr 1 2003</h3>
|
||
<ul>
|
||
<li>performance improvements especially for large flat documents</li>
|
||
<li>bug fixes: Result Value Tree handling, XML IDs, keys(), extra namespace
|
||
declarations with xsl:elements.</li>
|
||
<li>portability: python and trio fixes (Albert Chin), python on Solaris
|
||
(Ben Phillips)</li>
|
||
</ul>
|
||
|
||
<h3>1.0.28: Mar 24 2003</h3>
|
||
<ul>
|
||
<li>fixed node() in patterns semantic.</li>
|
||
<li>fixed a memory access problem in format-number()</li>
|
||
<li>fixed stack overflow in recursive global variable or params</li>
|
||
<li>cleaned up Result Value Tree handling, and fixed a couple of old bugs
|
||
in the process</li>
|
||
</ul>
|
||
|
||
<h3>1.0.27: Feb 24 2003</h3>
|
||
<ul>
|
||
<li>bug fixes: spurious xmlns:nsX="" generation, serialization bug (in
|
||
libxml2), a namespace copy problem, errors in the RPM spec prereqs</li>
|
||
<li>Windows path canonicalization and document cache fix (Igor)</li>
|
||
</ul>
|
||
|
||
<h3>1.0.26: Feb 10 2003</h3>
|
||
<ul>
|
||
<li>Fixed 3 serious bugs in document() and stylesheet compilation which
|
||
could lead to a crash</li>
|
||
</ul>
|
||
|
||
<h3>1.0.25: Feb 5 2003</h3>
|
||
<ul>
|
||
<li>Bug fix: double-free for standalone stylesheets introduced in 1.0.24, C
|
||
syntax pbm, 3 bugs reported by Eric van der Vlist</li>
|
||
<li>Some XPath and XInclude related problems were actually fixed in
|
||
libxml2-2.5.2</li>
|
||
<li>Documentation: emphasize taht --docbook is not for XML docs.</li>
|
||
</ul>
|
||
|
||
<h3>1.0.24: Jan 14 2003</h3>
|
||
<ul>
|
||
<li>bug fixes: imported global varables, python bindings (St<53>phane Bidoul),
|
||
EXSLT memory leak (Charles Bozeman), namespace generation on
|
||
xsl:attribute, space handling with imports (Daniel Stodden),
|
||
extension-element-prefixes (Josh Parsons), comments within xsl:text (Matt
|
||
Sergeant), superfluous xmlns generation, XInclude related bug for
|
||
numbering, EXSLT strings (Alexey Efimov), attribute-sets computation on
|
||
imports, extension module init and shutdown callbacks not called</li>
|
||
<li>HP-UX portability (Alexey Efimov), Windows makefiles (Igor and Stephane
|
||
Bidoul), VMS makefile updates (Craig A. Berry)</li>
|
||
<li>adds xsltGetProfileInformation() (Michael Rothwell)</li>
|
||
<li>fix the API generation scripts</li>
|
||
<li>API to provide the sorting routines (Richard Jinks)</li>
|
||
<li>added XML description of the EXSLT API</li>
|
||
<li>added ESXLT URI (un)escaping (J<>rg Walter)</li>
|
||
<li>Some memory leaks have been found and fixed</li>
|
||
<li>document() now support fragment identifiers in URIs</li>
|
||
</ul>
|
||
|
||
<h3>1.0.23: Nov 17 2002</h3>
|
||
<ul>
|
||
<li>Windows build cleanup (Igor)</li>
|
||
<li>Unix build and RPM packaging cleanup</li>
|
||
<li>Improvement of the python bindings: extension functions and activating
|
||
EXSLT</li>
|
||
<li>various bug fixes: number formatting, portability for bounded string
|
||
functions, CData nodes, key(), @*[...] patterns</li>
|
||
<li>Documentation improvements (John Fleck)</li>
|
||
<li>added libxslt.m4 (Thomas Schraitle)</li>
|
||
</ul>
|
||
|
||
<h3>1.0.22: Oct 18 2002</h3>
|
||
<ul>
|
||
<li>Updates on the Windows Makefiles</li>
|
||
<li>Added a security module, and a related set of new options to
|
||
xsltproc</li>
|
||
<li>Allowed per transformation error handler.</li>
|
||
<li>Fixed a few bugs: node() semantic, URI escaping, media-type, attribute
|
||
lists</li>
|
||
</ul>
|
||
|
||
<h3>1.0.21: Sep 26 2002</h3>
|
||
<ul>
|
||
<li>Bug fixes: match="node()", date:difference() (Igor and Charlie
|
||
Bozeman), disable-output-escaping</li>
|
||
<li>Python bindings: style.saveResultToString() from Ralf Mattes</li>
|
||
<li>Logos from Marc Liyanage</li>
|
||
<li>Mem leak fix from Nathan Myers</li>
|
||
<li>Makefile: DESTDIR fix from Christophe Merlet, AMD x86_64 (Mandrake),
|
||
Windows (Igor), Python detection</li>
|
||
<li>Documentation improvements: John Fleck</li>
|
||
</ul>
|
||
|
||
<h3>1.0.20: Aug 23 2002</h3>
|
||
<ul>
|
||
<li>Windows makefile updates (Igor) and x86-64 (Frederic Crozat)</li>
|
||
<li>fixed HTML meta tag saving for Mac/IE users</li>
|
||
<li>possible leak patches from Nathan Myers</li>
|
||
<li>try to handle document('') as best as possible depending in the
|
||
cases</li>
|
||
<li>Fixed the DocBook stylesheets handling problem</li>
|
||
<li>Fixed a few XSLT reported errors</li>
|
||
</ul>
|
||
|
||
<h3>1.0.19: July 6 2002</h3>
|
||
<ul>
|
||
<li>EXSLT: dynamic functions and date support bug fixes (Mark Vakoc)</li>
|
||
<li>xsl:number fix: Richard Jinks</li>
|
||
<li>xsl:format-numbers fix: Ken Neighbors</li>
|
||
<li>document('') fix: bug pointed by Eric van der Vlist</li>
|
||
<li>xsl:message with terminate="yes" fixes: William Brack</li>
|
||
<li>xsl:sort order support added: Ken Neighbors</li>
|
||
<li>a few other bug fixes, some of them requiring the latest version of
|
||
libxml2</li>
|
||
</ul>
|
||
|
||
<h3>1.0.18: May 27 2002</h3>
|
||
<ul>
|
||
<li>a number of bug fixes: attributes, extra namespace declarations
|
||
(DocBook), xsl:include crash (Igor), documentation (Christian Cornelssen,
|
||
Charles Bozeman and Geert Kloosterman), element-available (Richard
|
||
Jinks)</li>
|
||
<li>xsltproc can now list teh registered extensions thanks to Mark
|
||
Vakoc</li>
|
||
<li>there is a new API to save directly to a string
|
||
xsltSaveResultToString() by Morus Walter</li>
|
||
<li>specific error registration function for the python API</li>
|
||
</ul>
|
||
|
||
<h3>1.0.17: April 29 2002</h3>
|
||
<ul>
|
||
<li>cleanup in code, XSLT debugger support and Makefiles for Windows by
|
||
Igor</li>
|
||
<li>a C++ portability fix by Mark Vakoc</li>
|
||
<li>EXSLT date improvement and regression tests by Charles Bozeman</li>
|
||
<li>attempt to fix a bug in xsltProcessUserParamInternal</li>
|
||
</ul>
|
||
|
||
<h3>1.0.16: April 15 2002</h3>
|
||
<ul>
|
||
<li>Bug fixes: strip-space, URL in HTML output, error when xsltproc can't
|
||
save</li>
|
||
<li>portability fixes: OSF/1, IEEE on alphas, Windows, Python bindings</li>
|
||
</ul>
|
||
|
||
<h3>1.0.15: Mar 25 2002</h3>
|
||
<ul>
|
||
<li>Bugfixes: XPath, python Makefile, recursive attribute sets, @foo[..]
|
||
templates</li>
|
||
<li>Debug of memory alocation with valgind</li>
|
||
<li>serious profiling leading to significant improvement for DocBook
|
||
processing</li>
|
||
<li>revamp of the Windows build</li>
|
||
</ul>
|
||
|
||
<h3>1.0.14: Mar 18 2002</h3>
|
||
<ul>
|
||
<li>Improvement in the XPath engine (libxml2-2.4.18)</li>
|
||
<li>Nasty bug fix related to exslt:node-set</li>
|
||
<li>Fixed the python Makefiles, cleanup of doc comments, Windows
|
||
portability fixes</li>
|
||
</ul>
|
||
|
||
<h3>1.0.13: Mar 8 2002</h3>
|
||
<ul>
|
||
<li>a number of bug fixes including "namespace node have no parents"</li>
|
||
<li>Improvement of the Python bindings</li>
|
||
<li>Charles Bozeman provided fixes and regression tests for exslt date
|
||
functions.</li>
|
||
</ul>
|
||
|
||
<h3>1.0.12: Feb 11 2002</h3>
|
||
<ul>
|
||
<li>Fixed the makefiles especially the python module ones</li>
|
||
<li>half a dozen bugs fixes including 2 old ones</li>
|
||
</ul>
|
||
|
||
<h3>1.0.11: Feb 8 2002</h3>
|
||
<ul>
|
||
<li>Change of Licence to the <a
|
||
href="http://www.opensource.org/licenses/mit-license.html">MIT
|
||
Licence</a></li>
|
||
<li>Added a beta version of the Python bindings, including support to
|
||
extend the engine with functions written in Python</li>
|
||
<li>A number of bug fixes</li>
|
||
<li>Charlie Bozeman provided more EXSLT functions</li>
|
||
<li>Portability fixes</li>
|
||
</ul>
|
||
|
||
<h3>1.0.10: Jan 14 2002</h3>
|
||
<ul>
|
||
<li>Windows fixes for Win32 from Igor</li>
|
||
<li>Fixed the Solaris compilation trouble (Albert)</li>
|
||
<li>Documentation changes and updates: John Fleck</li>
|
||
<li>Added a stringparam option to avoid escaping hell at the shell
|
||
level</li>
|
||
<li>A few bug fixes</li>
|
||
</ul>
|
||
|
||
<h3>1.0.9: Dec 7 2001</h3>
|
||
<ul>
|
||
<li>Makefile patches from Peter Williams</li>
|
||
<li>attempt to fix the compilation problem associated to prelinking</li>
|
||
<li>obsoleted libxsltbreakpoint now deprecated and frozen to 1.0.8 API</li>
|
||
<li>xsltproc return codes are now significant, John Fleck updated the
|
||
documentation</li>
|
||
<li>patch to allow as much as 40 steps in patterns (Marc Tardif), should be
|
||
made dynamic really</li>
|
||
<li>fixed a bug raised by Nik Clayton when using doctypes with HTML
|
||
output</li>
|
||
<li>patches from Keith Isdale to interface with xsltdebugger</li>
|
||
</ul>
|
||
|
||
<h3>1.0.8: Nov 26 2001</h3>
|
||
<ul>
|
||
<li>fixed an annoying header problem, removed a few bugs and some code
|
||
cleanup</li>
|
||
<li>patches for Windows and update of Windows Makefiles by Igor</li>
|
||
<li>OpenVMS port instructions from John A Fotheringham</li>
|
||
<li>fixed some Makefiles annoyance and libraries prelinking
|
||
information</li>
|
||
</ul>
|
||
|
||
<h3>1.0.7: Nov 10 2001</h3>
|
||
<ul>
|
||
<li>remove a compilation problem with LIBXSLT_PUBLIC</li>
|
||
<li>Finishing the integration steps for Keith Isdale debugger</li>
|
||
<li>fixes the handling of indent="no" on HTML output</li>
|
||
<li>fixes on the configure script and RPM spec file</li>
|
||
</ul>
|
||
|
||
<h3>1.0.6: Oct 30 2001</h3>
|
||
<ul>
|
||
<li>bug fixes on number formatting (Thomas), date/time functions (Bruce
|
||
Miller)</li>
|
||
<li>update of the Windows Makefiles (Igor)</li>
|
||
<li>fixed DOCTYPE generation rules for HTML output (me)</li>
|
||
</ul>
|
||
|
||
<h3>1.0.5: Oct 10 2001</h3>
|
||
<ul>
|
||
<li>some portability fixes, including Windows makefile updates from
|
||
Igor</li>
|
||
<li>fixed a dozen bugs on XSLT and EXSLT (me and Thomas Broyer)</li>
|
||
<li>support for Saxon's evaluate and expressions extensions added (initial
|
||
contribution from Darren Graves)</li>
|
||
<li>better handling of XPath evaluation errors</li>
|
||
</ul>
|
||
|
||
<h3>1.0.4: Sep 12 2001</h3>
|
||
<ul>
|
||
<li>Documentation updates from John fleck</li>
|
||
<li>bug fixes (DocBook FO generation should be fixed) and portability
|
||
improvements</li>
|
||
<li>Thomas Broyer improved the existing EXSLT support and added String,
|
||
Time and Date core functions support</li>
|
||
</ul>
|
||
|
||
<h3>1.0.3: Aug 23 2001</h3>
|
||
<ul>
|
||
<li>XML Catalog support see the doc</li>
|
||
<li>New NaN/Infinity floating point code</li>
|
||
<li>A few bug fixes</li>
|
||
</ul>
|
||
|
||
<h3>1.0.2: Aug 15 2001</h3>
|
||
<ul>
|
||
<li>lot of bug fixes, increased the testsuite</li>
|
||
<li>a large chunk of EXSLT is implemented</li>
|
||
<li>improvements on the extension framework</li>
|
||
<li>documentation improvements</li>
|
||
<li>Windows MSC projects files should be up-to-date</li>
|
||
<li>handle attributes inherited from the DTD by default</li>
|
||
</ul>
|
||
|
||
<h3>1.0.1: July 24 2001</h3>
|
||
<ul>
|
||
<li>initial EXSLT framework</li>
|
||
<li>better error reporting</li>
|
||
<li>fixed the profiler on Windows</li>
|
||
<li>bug fixes</li>
|
||
</ul>
|
||
|
||
<h3>1.0.0: July 10 2001</h3>
|
||
<ul>
|
||
<li>a lot of cleanup, a lot of regression tests added or fixed</li>
|
||
<li>added a documentation for <a href="extensions.html">writing
|
||
extensions</a></li>
|
||
<li>fixed some variable evaluation problems (with William)</li>
|
||
<li>added profiling of stylesheet execution accessible as the xsltproc
|
||
--profile option</li>
|
||
<li>fixed element-available() and the implementation of the various
|
||
chunking methods present, Norm Walsh provided a lot of feedback</li>
|
||
<li>exclude-result-prefixes and namespaces output should now work as
|
||
expected</li>
|
||
<li>added support of embedded stylesheet as described in section 2.7 of the
|
||
spec</li>
|
||
</ul>
|
||
|
||
<h3>0.14.0: July 5 2001</h3>
|
||
<ul>
|
||
<li>lot of bug fixes, and code cleanup</li>
|
||
<li>completion of the little XSLT-1.0 features left unimplemented</li>
|
||
<li>Added and implemented the extension API suggested by Thomas Broyer</li>
|
||
<li>the Windows MSC environment should be complete</li>
|
||
<li>tested and optimized with a really large document (DocBook Definitive
|
||
Guide) libxml/libxslt should really be faster on serious workloads</li>
|
||
</ul>
|
||
|
||
<h3>0.13.0: June 26 2001</h3>
|
||
<ul>
|
||
<li>lots of cleanups</li>
|
||
<li>fixed a C++ compilation problem</li>
|
||
<li>couple of fixes to xsltSaveTo()</li>
|
||
<li>try to fix Docbook-xslt-1.4 and chunking, updated the regression test
|
||
with them</li>
|
||
<li>fixed pattern compilation and priorities problems</li>
|
||
<li>Patches for Windows and MSC project mostly contributed by Yon Derek</li>
|
||
<li>update to the Tutorial by John Fleck</li>
|
||
<li>William fixed bugs in templates and for-each functions</li>
|
||
<li>added a new interface xsltRunStylesheet() for a more flexible output
|
||
(incomplete), added -o option to xsltproc</li>
|
||
</ul>
|
||
|
||
<h3>0.12.0: June 18 2001</h3>
|
||
<ul>
|
||
<li>fixed a dozen of bugs reported</li>
|
||
<li>HTML generation should be quite better (requires libxml-2.3.11 upgrade
|
||
too)</li>
|
||
<li>William fixed some problems with document()</li>
|
||
<li>Fix namespace nodes selection and copy (requires libxml-2.3.11 upgrade
|
||
too)</li>
|
||
<li>John Fleck added a<a href="tutorial/libxslttutorial.html">
|
||
tutorial</a></li>
|
||
<li>Fixes for namespace handling when evaluating variables</li>
|
||
<li>XInclude global flag added to process XInclude on document() if
|
||
requested</li>
|
||
<li>made xsltproc --version more detailed</li>
|
||
</ul>
|
||
|
||
<h3>0.11.0: June 1 2001</h3>
|
||
|
||
<p>Mostly a bug fix release.</p>
|
||
<ul>
|
||
<li>integration of catalogs from xsltproc</li>
|
||
<li>added --version to xsltproc for bug reporting</li>
|
||
<li>fixed errors when handling ID in external parsed entities</li>
|
||
<li>document() should hopefully work correctly but ...</li>
|
||
<li>fixed bug with PI and comments processing</li>
|
||
<li>William fixed the XPath string functions when using unicode</li>
|
||
</ul>
|
||
|
||
<h3>0.10.0: May 19 2001</h3>
|
||
<ul>
|
||
<li>cleanups to make stylesheet read-only (not 100% complete)</li>
|
||
<li>fixed URI resolution in document()</li>
|
||
<li>force all XPath expression to be compiled at stylesheet parsing time,
|
||
even if unused ...</li>
|
||
<li>Fixed HTML default output detection</li>
|
||
<li>Fixed double attribute generation #54446</li>
|
||
<li>Fixed {{ handling in attributes #54451</li>
|
||
<li>More tests and speedups for DocBook document transformations</li>
|
||
<li>Fixed a really bad race like bug in xsltCopyTreeList()</li>
|
||
<li>added a documentation on the libxslt internals</li>
|
||
<li>William Brack and Bjorn Reese improved format-number()</li>
|
||
<li>Fixed multiple sort, it should really work now</li>
|
||
<li>added a --docbook option for SGML DocBook input (hackish)</li>
|
||
<li>a number of other bug fixes and regression test added as people were
|
||
submitting them</li>
|
||
</ul>
|
||
|
||
<h3>0.9.0: May 3 2001</h3>
|
||
<ul>
|
||
<li>lot of various bugfixes, extended the regression suite</li>
|
||
<li>xsltproc should work with multiple params</li>
|
||
<li>added an option to use xsltproc with HTML input</li>
|
||
<li>improved the stylesheet compilation, processing of complex stylesheets
|
||
should be faster</li>
|
||
<li>using the same stylesheet for concurrent processing on multithreaded
|
||
programs should work now</li>
|
||
<li>fixed another batch of namespace handling problems</li>
|
||
<li>Implemented multiple level of sorting</li>
|
||
</ul>
|
||
|
||
<h3>0.8.0: Apr 22 2001</h3>
|
||
<ul>
|
||
<li>fixed ansidecl.h problem</li>
|
||
<li>fixed unparsed-entity-uri() and generate-id()</li>
|
||
<li>sort semantic fixes and priority prob from William M. Brack</li>
|
||
<li>fixed namespace handling problems in XPath expression computations
|
||
(requires libxml-2.3.7)</li>
|
||
<li>fixes to current() and key()</li>
|
||
<li>other, smaller fixes, lots of testing with N Walsh DocBook HTML
|
||
stylesheets</li>
|
||
</ul>
|
||
|
||
<h3>0.7.0: Apr 10 2001</h3>
|
||
<ul>
|
||
<li>cleanup using stricter compiler flags</li>
|
||
<li>command line parameter passing</li>
|
||
<li>fix to xsltApplyTemplates from William M. Brack</li>
|
||
<li>added the XSLTMark in the regression tests as well as document()</li>
|
||
</ul>
|
||
|
||
<h3>0.6.0: Mar 22 2001</h3>
|
||
<ul>
|
||
<li>another beta</li>
|
||
<li>requires 2.3.5, which provide XPath expression compilation support</li>
|
||
<li>document() extension should function properly</li>
|
||
<li>fixed a number or reported bugs</li>
|
||
</ul>
|
||
|
||
<h3>0.5.0: Mar 10 2001</h3>
|
||
<ul>
|
||
<li>fifth beta</li>
|
||
<li>some optimization work, for the moment 2 XSLT transform cannot use the
|
||
same stylesheet at the same time (to be fixed)</li>
|
||
<li>fixed problems with handling of tree results</li>
|
||
<li>fixed a reported strip-spaces problem</li>
|
||
<li>added more reported/fixed bugs to the test suite</li>
|
||
<li>incorporated William M. Brack fix for imports and global variables as
|
||
well as patch for with-param support in apply-templates</li>
|
||
<li>a bug fix on for-each</li>
|
||
</ul>
|
||
|
||
<h3>0.4.0: Mar 1 2001</h3>
|
||
<ul>
|
||
<li>fourth beta test, released at the same time of libxml2-2.3.3</li>
|
||
<li>bug fixes</li>
|
||
<li>some optimization</li>
|
||
<li>started implement extension support, not finished</li>
|
||
<li>implemented but not tested multiple file output</li>
|
||
</ul>
|
||
|
||
<h3>0.3.0: Feb 24 2001</h3>
|
||
<ul>
|
||
<li>third beta test, released at the same time of libxml2-2.3.2</li>
|
||
<li>lot of bug fixes</li>
|
||
<li>some optimization</li>
|
||
<li>added DocBook XSL based testsuite</li>
|
||
</ul>
|
||
|
||
<h3>0.2.0: Feb 15 2001</h3>
|
||
<ul>
|
||
<li>second beta version, released at the same time as libxml2-2.3.1</li>
|
||
<li>getting close to feature completion, lot of bug fixes, some in the HTML
|
||
and XPath support of libxml</li>
|
||
<li>start becoming usable for real work. This version can now regenerate
|
||
the XML 2e HTML from the original XML sources and the associated
|
||
stylesheets (in <a
|
||
href="http://www.w3.org/TR/REC-xml#b4d250b6c21">section I of the XML
|
||
REC</a>)</li>
|
||
<li>Still misses extension element/function/prefixes support. Support of
|
||
key() and document() is not complete</li>
|
||
</ul>
|
||
|
||
<h3>0.1.0: Feb 8 2001</h3>
|
||
<ul>
|
||
<li>first beta version, released at the same time as libxml2-2.3.0</li>
|
||
<li>lots of bug fixes, first "testing" version, but incomplete</li>
|
||
</ul>
|
||
|
||
<h3>0.0.1: Jan 25 2001</h3>
|
||
<ul>
|
||
<li>first alpha version released at the same time as libxml2-2.2.12</li>
|
||
<li>Framework in place, should work on simple examples, but far from being
|
||
feature complete</li>
|
||
</ul>
|
||
|
||
<h2><a name="xsltproc">The xsltproc tool</a></h2>
|
||
|
||
<p>This program is the simplest way to use libxslt: from the command line. It
|
||
is also used for doing the regression tests of the library.</p>
|
||
|
||
<p>It takes as first argument the path or URL to an XSLT stylesheet, the next
|
||
arguments are filenames or URIs of the inputs to be processed. The output of
|
||
the processing is redirected on the standard output. There is actually a few
|
||
more options available:</p>
|
||
<pre>orchis:~ -> xsltproc
|
||
Usage: xsltproc [options] stylesheet file [file ...]
|
||
Options:
|
||
--version or -V: show the version of libxml and libxslt used
|
||
--verbose or -v: show logs of what's happening
|
||
--output file or -o file: save to a given file
|
||
--timing: display the time used
|
||
--repeat: run the transformation 20 times
|
||
--debug: dump the tree of the result instead
|
||
--novalid: skip the DTD loading phase
|
||
--noout: do not dump the result
|
||
--maxdepth val : increase the maximum depth
|
||
--html: the input document is(are) an HTML file(s)
|
||
--docbook: the input document is SGML docbook
|
||
--param name value : pass a (parameter,value) pair
|
||
--nonet refuse to fetch DTDs or entities over network
|
||
--warnnet warn against fetching over the network
|
||
--catalogs : use the catalogs from $SGML_CATALOG_FILES
|
||
--xinclude : do XInclude processing on document input
|
||
--profile or --norman : dump profiling information
|
||
orchis:~ -></pre>
|
||
|
||
<h2><a name="DocBook">DocBook</a></h2>
|
||
|
||
<p><img src="duck.png" align="right" alt="The duck picture"></p>
|
||
|
||
<p><a href="http://www.oasis-open.org/committees/docbook/">DocBook</a> is an
|
||
XML/SGML vocabulary particularly well suited to books and papers about
|
||
computer hardware and software.</p>
|
||
|
||
<p>xsltproc and libxslt are not specifically dependant on DocBook, but since
|
||
a lot of people use xsltproc and libxml2 for DocBook formatting, here are a
|
||
few pointers and information which may be helpful:</p>
|
||
<ul>
|
||
<li>The <a href="http://www.oasis-open.org/committees/docbook/">DocBook
|
||
homepage at Oasis</a> you should find pointers there on all the lastest
|
||
versions of the DTDs and XSLT stylesheets</li>
|
||
<li><a href="http://www.docbook.org/">DocBook: The Definitive Guide</a> is
|
||
the official reference documentation for DocBook.</li>
|
||
<li><a
|
||
href="https://sourceforge.net/docman/index.php?group_id=21935">DocBook
|
||
Open Repository</a> contains a lot of information about DocBook</li>
|
||
<li>Bob Stayton provides a <a href="http://www.sagehill.net/">lot of
|
||
resources</a> and consulting services around DocBook.</li>
|
||
<li>Here is a <a href="/buildDocBookCatalog">shell script</a> to generate
|
||
XML Catalogs for DocBook 4.1.2 . If it can write to the /etc/xml/
|
||
directory, it will set-up /etc/xml/catalog and /etc/xml/docbook based on
|
||
the resources found on the system. Otherwise it will just create
|
||
~/xmlcatalog and ~/dbkxmlcatalog and doing:
|
||
<p><code>export XMLCATALOG=$HOME/xmlcatalog</code></p>
|
||
<p>should allow to process DocBook documentations without requiring
|
||
network accesses for the DTd or stylesheets</p>
|
||
</li>
|
||
<li>I have uploaded <a href="ftp://xmlsoft.org/libxml2/test/dbk412catalog.tar.gz">a
|
||
small tarball</a> containing XML Catalogs for DocBook 4.1.2 which seems
|
||
to work fine for me too</li>
|
||
<li>Informations on installing a <a
|
||
href="http://wiki.docbook.org/topic/CygwinPackages">Windows
|
||
DocBook processing setup</a> based on Cygwin (using the binaries from the
|
||
official Windows port should be possible too)</li>
|
||
<li>Alexander Kirillov's page on <a
|
||
href="http://www.math.sunysb.edu/~kirillov/dbxml/">Using DocBook XML
|
||
4.1.2</a> (RPM packages)</li>
|
||
<li>Tim Waugh's <a href="http://cyberelk.net/tim/xmlto/">xmlto front-end
|
||
conversion script</a></li>
|
||
<li>Linux Documentation Project <a
|
||
href="http://www.linuxdoc.org/HOWTO/mini/DocBook-Install/">
|
||
DocBook-Install-mini-HOWTO</a></li>
|
||
<li>ScrollKeeper the open documentation cataloging project has a <a
|
||
href="http://scrollkeeper.sourceforge.net/docbook.shtml">DocBook
|
||
section</a></li>
|
||
<li>Dan York presentation on <a
|
||
href="http://www.lodestar2.com/people/dyork/talks/2001/xugo/docbook/index.html">Publishing
|
||
using DocBook XML</a></li>
|
||
</ul>
|
||
|
||
<p>Do not use the --docbook option of xsltproc to process XML DocBook
|
||
documents, this option is only intended to provide some (limited) support of
|
||
the SGML version of DocBook.</p>
|
||
|
||
<p>Points which are not DocBook specific but still worth mentionning
|
||
again:</p>
|
||
<ul>
|
||
<li>if you think DocBook processing time is too slow, make sure you have
|
||
XML Catalogs pointing to a local installation of the DTD of DocBook.
|
||
Check the <a href="http://xmlsoft.org/catalog.html">XML Catalog page</a>
|
||
to understand more on this subject.</li>
|
||
<li>before processing a new document, use the command
|
||
<p><code>xmllint --valid --noout path_to_document</code></p>
|
||
<p>to make sure that your input is valid DocBook. And fixes the errors
|
||
before processing further. Note that XSLT processing may work correctly
|
||
with some forms of validity errors left, but in general it can give
|
||
troubles on output.</p>
|
||
</li>
|
||
</ul>
|
||
|
||
<h2><a name="API">The programming API</a></h2>
|
||
|
||
<p>Okay this section is clearly incomplete. But integrating libxslt into your
|
||
application should be relatively easy. First check the few steps described
|
||
below, then for more detailed information, look at the<a
|
||
href="html/libxslt-lib.html"> generated pages</a> for the API and the source
|
||
of libxslt/xsltproc.c and the <a
|
||
href="tutorial/libxslttutorial.html">tutorial</a>.</p>
|
||
|
||
<p>Basically doing an XSLT transformation can be done in a few steps:</p>
|
||
<ol>
|
||
<li>configure the parser for XSLT:
|
||
<p>xmlSubstituteEntitiesDefault(1);</p>
|
||
<p>xmlLoadExtDtdDefaultValue = 1;</p>
|
||
</li>
|
||
<li>parse the stylesheet with xsltParseStylesheetFile()</li>
|
||
<li>parse the document with xmlParseFile()</li>
|
||
<li>apply the stylesheet using xsltApplyStylesheet()</li>
|
||
<li>save the result using xsltSaveResultToFile() if needed set
|
||
xmlIndentTreeOutput to 1</li>
|
||
</ol>
|
||
|
||
<p>Steps 2,3, and 5 will probably need to be changed depending on you
|
||
processing needs and environment for example if reading/saving from/to
|
||
memory, or if you want to apply XInclude processing to the stylesheet or
|
||
input documents.</p>
|
||
|
||
<h2><a name="Python">Python and bindings</a></h2>
|
||
|
||
<p>There is a number of language bindings and wrappers available for libxml2,
|
||
the list below is not exhaustive. Please contact the <a
|
||
href="http://mail.gnome.org/mailman/listinfo/xml-bindings">xml-bindings@gnome.org</a>
|
||
(<a href="http://mail.gnome.org/archives/xml-bindings/">archives</a>) in
|
||
order to get updates to this list or to discuss the specific topic of libxml2
|
||
or libxslt wrappers or bindings:</p>
|
||
<ul>
|
||
<li><a
|
||
href="http://mail.gnome.org/archives/xml/2001-March/msg00014.html">Matt
|
||
Sergeant</a> developped <a href="http://axkit.org/download/">XML::LibXML
|
||
and XML::LibXSLT</a>, Perl wrappers for libxml2/libxslt as part of the <a
|
||
href="http://axkit.com/">AxKit XML application server</a></li>
|
||
<li><a href="mailto:dkuhlman@cutter.rexx.com">Dave Kuhlman</a> provides and
|
||
earlier version of the libxml/libxslt <a
|
||
href="http://www.rexx.com/~dkuhlman">wrappers for Python</a></li>
|
||
<li>Petr Kozelka provides <a
|
||
href="http://sourceforge.net/projects/libxml2-pas">Pascal units to glue
|
||
libxml2</a> with Kylix, Delphi and other Pascal compilers</li>
|
||
<li>Wai-Sun "Squidster" Chia provides <a
|
||
href="http://www.rubycolor.org/arc/redist/">bindings for Ruby</a> and
|
||
libxml2 bindings are also available in Ruby through the <a
|
||
href="http://libgdome-ruby.berlios.de/">libgdome-ruby</a> module
|
||
maintained by Tobias Peters.</li>
|
||
<li>Steve Ball and contributors maintains <a
|
||
href="http://tclxml.sourceforge.net/">libxml2 and libxslt bindings for
|
||
Tcl</a></li>
|
||
<li><a href="mailto:xmlwrapp@pmade.org">Peter Jones</a> maintains C++
|
||
bindings for libxslt within <a
|
||
href="http://pmade.org/pjones/software/xmlwrapp/">xmlwrapp</a></li>
|
||
<li><a href="phillim2@comcast.net">Mike Phillips</a> provides a module
|
||
using <a href="http://siasl.dyndns.org/projects/projects.html">libxslt
|
||
for PHP</a>.</li>
|
||
<li><a href="http://savannah.gnu.org/projects/classpathx/">LibxmlJ</a> is
|
||
an effort to create a 100% JAXP-compatible Java wrapper for libxml2 and
|
||
libxslt as part of GNU ClasspathX project.</li>
|
||
<li>Patrick McPhee provides Rexx bindings fof libxml2 and libxslt, look for
|
||
<a href="http://www.interlog.com/~ptjm/software.html">RexxXML</a>.</li>
|
||
<li><a
|
||
href="http://www.satimage.fr/software/en/xml_suite.html">Satimage</a>
|
||
provides <a
|
||
href="http://www.satimage.fr/software/en/downloads_osaxen.html">XMLLib
|
||
osax</a>. This is an osax for Mac OS X with a set of commands to
|
||
implement in AppleScript the XML DOM, XPATH and XSLT.</li>
|
||
</ul>
|
||
|
||
<p>The libxslt Python module depends on the <a
|
||
href="http://xmlsoft.org/python.html">libxml2 Python</a> module.</p>
|
||
|
||
<p>The distribution includes a set of Python bindings, which are guaranteed to
|
||
be maintained as part of the library in the future, though the Python
|
||
interface have not yet reached the completeness of the C API.</p>
|
||
|
||
<p><a href="mailto:stephane.bidoul@softwareag.com">St<EFBFBD>phane Bidoul</a>
|
||
maintains <a href="http://users.skynet.be/sbi/libxml-python/">a Windows port
|
||
of the Python bindings</a>.</p>
|
||
|
||
<p>Note to people interested in building bindings, the API is formalized as
|
||
<a href="libxslt-api.xml">an XML API description file</a> which allows to
|
||
automate a large part of the Python bindings, this includes function
|
||
descriptions, enums, structures, typedefs, etc... The Python script used to
|
||
build the bindings is python/generator.py in the source distribution.</p>
|
||
|
||
<p>To install the Python bindings there are 2 options:</p>
|
||
<ul>
|
||
<li>If you use an RPM based distribution, simply install the <a
|
||
href="http://rpmfind.net/linux/rpm2html/search.php?query=libxml2-python">libxml2-python
|
||
RPM</a> and the <a
|
||
href="http://rpmfind.net/linux/rpm2html/search.php?query=libxslt-python">libxslt-python
|
||
RPM</a>.</li>
|
||
<li>Otherwise use the <a href="ftp://xmlsoft.org/libxml2/python/">libxml2-python
|
||
module distribution</a> corresponding to your installed version of
|
||
libxml2 and libxslt. Note that to install it you will need both libxml2
|
||
and libxslt installed and run "python setup.py build install" in the
|
||
module tree.</li>
|
||
</ul>
|
||
|
||
<p>The distribution includes a set of examples and regression tests for the
|
||
python bindings in the <code>python/tests</code> directory. Here are some
|
||
excepts from those tests:</p>
|
||
|
||
<h3>basic.py:</h3>
|
||
|
||
<p>This is a basic test of XSLT interfaces: loading a stylesheet and a
|
||
document, transforming the document and saving the result.</p>
|
||
<pre>import libxml2
|
||
import libxslt
|
||
|
||
styledoc = libxml2.parseFile("test.xsl")
|
||
style = libxslt.parseStylesheetDoc(styledoc)
|
||
doc = libxml2.parseFile("test.xml")
|
||
result = style.applyStylesheet(doc, None)
|
||
style.saveResultToFilename("foo", result, 0)
|
||
style.freeStylesheet()
|
||
doc.freeDoc()
|
||
result.freeDoc()</pre>
|
||
|
||
<p>The Python module is called libxslt, you will also need the libxml2 module
|
||
for the operations on XML trees. Let's have a look at the objects manipulated
|
||
in that example and how is the processing done:</p>
|
||
<ul>
|
||
<li><code>styledoc</code> : is a libxml2 document tree. It is obtained by
|
||
parsing the XML file "test.xsl" containing the stylesheet.</li>
|
||
<li><code>style</code> : this is a precompiled stylesheet ready to be used
|
||
by the following transformations (note the plural form, multiple
|
||
transformations can resuse the same stylesheet).</li>
|
||
<li><code>doc</code> : this is the document to apply the transformation to.
|
||
In this case it is simply generated by parsing it from a file but any
|
||
other processing is possible as long as one get a libxml2 Doc. Note that
|
||
HTML tree are suitable for XSLT processing in libxslt. This is actually
|
||
how this page is generated !</li>
|
||
<li><code>result</code> : this is a document generated by applying the
|
||
stylesheet to the document. Note that some of the stylesheet information
|
||
may be related to the serialization of that document and as in this
|
||
example a specific saveResultToFilename() method of the stylesheet should
|
||
be used to save it to a file (in that case to "foo").</li>
|
||
</ul>
|
||
|
||
<p>Also note the need to explicitely deallocate documents with freeDoc()
|
||
except for the stylesheet document which is freed when its compiled form is
|
||
garbage collected.</p>
|
||
|
||
<h3>extfunc.py:</h3>
|
||
|
||
<p>This one is a far more complex test. It shows how to modify the behaviour
|
||
of an XSLT transformation by passing parameters and how to extend the XSLT
|
||
engine with functions defined in python:</p>
|
||
<pre>import libxml2
|
||
import libxslt
|
||
import string
|
||
|
||
nodeName = None
|
||
def f(ctx, str):
|
||
global nodeName
|
||
|
||
#
|
||
# Small check to verify the context is correcly accessed
|
||
#
|
||
try:
|
||
pctxt = libxslt.xpathParserContext(_obj=ctx)
|
||
ctxt = pctxt.context()
|
||
tctxt = ctxt.transformContext()
|
||
nodeName = tctxt.insertNode().name
|
||
except:
|
||
pass
|
||
|
||
return string.upper(str)
|
||
|
||
libxslt.registerExtModuleFunction("foo", "http://example.com/foo", f)</pre>
|
||
|
||
<p>This code defines and register an extension function. Note that the
|
||
function can be bound to any name (foo) and how the binding is also
|
||
associated to a namespace name "http://example.com/foo". From an XSLT point
|
||
of view the function just returns an upper case version of the string passed
|
||
as a parameter. But the first part of the function also read some contextual
|
||
information from the current XSLT processing environement, in that case it
|
||
looks for the current insertion node in the resulting output (either the
|
||
resulting document or the Result Value Tree being generated), and saves it to
|
||
a global variable for checking that the access actually worked.</p>
|
||
|
||
<p>For more information on the xpathParserContext and transformContext
|
||
objects check the <a href="internals.html">libray internals description</a>.
|
||
The pctxt is actually an object from a class derived from the
|
||
libxml2.xpathParserContext() with just a couple more properties including the
|
||
possibility to look up the XSLT transformation context from the XPath
|
||
context.</p>
|
||
<pre>styledoc = libxml2.parseDoc("""
|
||
<xsl:stylesheet version='1.0'
|
||
xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
|
||
xmlns:foo='http://example.com/foo'
|
||
xsl:exclude-result-prefixes='foo'>
|
||
|
||
<xsl:param name='bar'>failure</xsl:param>
|
||
<xsl:template match='/'>
|
||
<article><xsl:value-of select='foo:foo($bar)'/></article>
|
||
</xsl:template>
|
||
</xsl:stylesheet>
|
||
""")</pre>
|
||
|
||
<p>Here is a simple example of how to read an XML document from a python
|
||
string with libxml2. Note how this stylesheet:</p>
|
||
<ul>
|
||
<li>Uses a global parameter <code>bar</code></li>
|
||
<li>Reference the extension function f</li>
|
||
<li>how the Namespace name "http://example.com/foo" has to be bound to a
|
||
prefix</li>
|
||
<li>how that prefix is excluded from the output</li>
|
||
<li>how the function is called from the select</li>
|
||
</ul>
|
||
<pre>style = libxslt.parseStylesheetDoc(styledoc)
|
||
doc = libxml2.parseDoc("<doc/>")
|
||
result = style.applyStylesheet(doc, { "bar": "'success'" })
|
||
style.freeStylesheet()
|
||
doc.freeDoc()</pre>
|
||
|
||
<p>that part is identical, to the basic example except that the
|
||
transformation is passed a dictionary of parameters. Note that the string
|
||
passed "success" had to be quoted, otherwise it is interpreted as an XPath
|
||
query for the childs of root named "success".</p>
|
||
<pre>root = result.children
|
||
if root.name != "article":
|
||
print "Unexpected root node name"
|
||
sys.exit(1)
|
||
if root.content != "SUCCESS":
|
||
print "Unexpected root node content, extension function failed"
|
||
sys.exit(1)
|
||
if nodeName != 'article':
|
||
print "The function callback failed to access its context"
|
||
sys.exit(1)
|
||
|
||
result.freeDoc()</pre>
|
||
|
||
<p>That part just verifies that the transformation worked, that the parameter
|
||
got properly passed to the engine, that the function f() got called and that
|
||
it properly accessed the context to find the name of the insertion node.</p>
|
||
|
||
<h3>pyxsltproc.py:</h3>
|
||
|
||
<p>this module is a bit too long to be described there but it is basically a
|
||
rewrite of the xsltproc command line interface of libxslt in Python. It
|
||
provides nearly all the functionalities of xsltproc and can be used as a base
|
||
module to write Python customized XSLT processors. One of the thing to notice
|
||
are:</p>
|
||
<pre>libxml2.lineNumbersDefault(1)
|
||
libxml2.substituteEntitiesDefault(1)</pre>
|
||
|
||
<p>those two calls in the main() function are needed to force the libxml2
|
||
processor to generate DOM trees compliant with the XPath data model.</p>
|
||
|
||
<h2><a name="Internals">Library internals</a></h2>
|
||
|
||
<h3>Table of contents</h3>
|
||
<ul>
|
||
<li><a href="internals.html#Introducti">Introduction</a></li>
|
||
<li><a href="internals.html#Basics">Basics</a></li>
|
||
<li><a href="internals.html#Keep">Keep it simple stupid</a></li>
|
||
<li><a href="internals.html#libxml">The libxml nodes</a></li>
|
||
<li><a href="internals.html#XSLT">The XSLT processing steps</a></li>
|
||
<li><a href="internals.html#XSLT1">The XSLT stylesheet compilation</a></li>
|
||
<li><a href="internals.html#XSLT2">The XSLT template compilation</a></li>
|
||
<li><a href="internals.html#processing">The processing itself</a></li>
|
||
<li><a href="internals.html#XPath">XPath expressions compilation</a></li>
|
||
<li><a href="internals.html#XPath1">XPath interpretation</a></li>
|
||
<li><a href="internals.html#Descriptio">Description of XPath
|
||
Objects</a></li>
|
||
<li><a href="internals.html#XPath3">XPath functions</a></li>
|
||
<li><a href="internals.html#stack">The variables stack frame</a></li>
|
||
<li><a href="internals.html#Extension">Extension support</a></li>
|
||
<li><a href="internals.html#Futher">Further reading</a></li>
|
||
<li><a href="internals.html#TODOs">TODOs</a></li>
|
||
<li><a href="internals.html#Thanks">Thanks</a></li>
|
||
</ul>
|
||
|
||
<h3><a name="Introducti2">Introduction</a></h3>
|
||
|
||
<p>This document describes the processing of <a
|
||
href="http://xmlsoft.org/XSLT/">libxslt</a>, the <a
|
||
href="http://www.w3.org/TR/xslt">XSLT</a> C library developed for the <a
|
||
href="http://www.gnome.org/">GNOME</a> project.</p>
|
||
|
||
<p>Note: this documentation is by definition incomplete and I am not good at
|
||
spelling, grammar, so patches and suggestions are <a
|
||
href="mailto:veillard@redhat.com">really welcome</a>.</p>
|
||
|
||
<h3><a name="Basics1">Basics</a></h3>
|
||
|
||
<p>XSLT is a transformation language. It takes an input document and a
|
||
stylesheet document and generates an output document:</p>
|
||
|
||
<p align="center"><img src="processing.gif"
|
||
alt="the XSLT processing model"></p>
|
||
|
||
<p>Libxslt is written in C. It relies on <a
|
||
href="http://www.xmlsoft.org/">libxml</a>, the XML C library for GNOME, for
|
||
the following operations:</p>
|
||
<ul>
|
||
<li>parsing files</li>
|
||
<li>building the in-memory DOM structure associated with the documents
|
||
handled</li>
|
||
<li>the XPath implementation</li>
|
||
<li>serializing back the result document to XML and HTML. (Text is handled
|
||
directly.)</li>
|
||
</ul>
|
||
|
||
<h3><a name="Keep1">Keep it simple stupid</a></h3>
|
||
|
||
<p>Libxslt is not very specialized. It is built under the assumption that all
|
||
nodes from the source and output document can fit in the virtual memory of
|
||
the system. There is a big trade-off there. It is fine for reasonably sized
|
||
documents but may not be suitable for large sets of data. The gain is that it
|
||
can be used in a relatively versatile way. The input or output may never be
|
||
serialized, but the size of documents it can handle are limited by the size
|
||
of the memory available.</p>
|
||
|
||
<p>More specialized memory handling approaches are possible, like building
|
||
the input tree from a serialization progressively as it is consumed,
|
||
factoring repetitive patterns, or even on-the-fly generation of the output as
|
||
the input is parsed but it is possible only for a limited subset of the
|
||
stylesheets. In general the implementation of libxslt follows the following
|
||
pattern:</p>
|
||
<ul>
|
||
<li>KISS (keep it simple stupid)</li>
|
||
<li>when there is a clear bottleneck optimize on top of this simple
|
||
framework and refine only as much as is needed to reach the expected
|
||
result</li>
|
||
</ul>
|
||
|
||
<p>The result is not that bad, clearly one can do a better job but more
|
||
specialized too. Most optimization like building the tree on-demand would
|
||
need serious changes to the libxml XPath framework. An easy step would be to
|
||
serialize the output directly (or call a set of SAX-like output handler to
|
||
keep this a flexible interface) and hence avoid the memory consumption of the
|
||
result.</p>
|
||
|
||
<h3><a name="libxml">The libxml nodes</a></h3>
|
||
|
||
<p>DOM-like trees, as used and generated by libxml and libxslt, are
|
||
relatively complex. Most node types follow the given structure except a few
|
||
variations depending on the node type:</p>
|
||
|
||
<p align="center"><img src="node.gif" alt="description of a libxml node"></p>
|
||
|
||
<p>Nodes carry a <strong>name</strong> and the node <strong>type</strong>
|
||
indicates the kind of node it represents, the most common ones are:</p>
|
||
<ul>
|
||
<li>document nodes</li>
|
||
<li>element nodes</li>
|
||
<li>text nodes</li>
|
||
</ul>
|
||
|
||
<p>For the XSLT processing, entity nodes should not be generated (i.e. they
|
||
should be replaced by their content). Most nodes also contains the following
|
||
"navigation" information:</p>
|
||
<ul>
|
||
<li>the containing <strong>doc</strong>ument</li>
|
||
<li>the <strong>parent</strong> node</li>
|
||
<li>the first <strong>children</strong> node</li>
|
||
<li>the <strong>last</strong> children node</li>
|
||
<li>the <strong>prev</strong>ious sibling</li>
|
||
<li>the following sibling (<strong>next</strong>)</li>
|
||
</ul>
|
||
|
||
<p>Elements nodes carries the list of attributes in the properties, an
|
||
attribute itself holds the navigation pointers and the children list (the
|
||
attribute value is not represented as a simple string to allow usage of
|
||
entities references).</p>
|
||
|
||
<p>The <strong>ns</strong> points to the namespace declaration for the
|
||
namespace associated to the node, <strong>nsDef</strong> is the linked list
|
||
of namespace declaration present on element nodes.</p>
|
||
|
||
<p>Most nodes also carry an <strong>_private</strong> pointer which can be
|
||
used by the application to hold specific data on this node.</p>
|
||
|
||
<h3><a name="XSLT">The XSLT processing steps</a></h3>
|
||
|
||
<p>There are a few steps which are clearly decoupled at the interface
|
||
level:</p>
|
||
<ol>
|
||
<li>parse the stylesheet and generate a DOM tree</li>
|
||
<li>take the stylesheet tree and build a compiled version of it (the
|
||
compilation phase)</li>
|
||
<li>take the input and generate a DOM tree</li>
|
||
<li>process the stylesheet against the input tree and generate an output
|
||
tree</li>
|
||
<li>serialize the output tree</li>
|
||
</ol>
|
||
|
||
<p>A few things should be noted here:</p>
|
||
<ul>
|
||
<li>the steps 1/ 3/ and 5/ are optional: the DOM representing the
|
||
stylesheet and input can be created by other means, not just by parsing
|
||
serialized XML documents, and similarly the result tree DOM can be
|
||
made available to other processeswithout being serialized.
|
||
<li>the stylesheet obtained at 2/ can be reused by multiple processing 4/
|
||
(and this should also work in threaded programs)</li>
|
||
<li>the tree provided in 2/ should never be freed using xmlFreeDoc, but by
|
||
freeing the stylesheet.</li>
|
||
<li>the input tree created in step 3/ is not modified except the
|
||
_private field which may be used for labelling keys if used by the
|
||
stylesheet. It's not modified at all in step 4/ to allow parallel
|
||
processing using a shared precompiled stylesheet.</li>
|
||
</ul>
|
||
|
||
<h3><a name="XSLT1">The XSLT stylesheet compilation</a></h3>
|
||
|
||
<p>This is the second step described. It takes a stylesheet tree, and
|
||
"compiles" it. This associates to each node a structure stored in the
|
||
_private field and containing information computed in the stylesheet:</p>
|
||
|
||
<p align="center"><img src="stylesheet.gif"
|
||
alt="a compiled XSLT stylesheet"></p>
|
||
|
||
<p>One xsltStylesheet structure is generated per document parsed for the
|
||
stylesheet. XSLT documents allow includes and imports of other documents,
|
||
imports are stored in the <strong>imports</strong> list (hence keeping the
|
||
tree hierarchy of includes which is very important for a proper XSLT
|
||
processing model) and includes are stored in the <strong>doclist</strong>
|
||
list. An imported stylesheet has a parent link to allow browsing of the
|
||
tree.</p>
|
||
|
||
<p>The DOM tree associated to the document is stored in <strong>doc</strong>.
|
||
It is preprocessed to remove ignorable empty nodes and all the nodes in the
|
||
XSLT namespace are subject to precomputing. This usually consist of
|
||
extracting all the context information from the context tree (attributes,
|
||
namespaces, XPath expressions), and storing them in an xsltStylePreComp
|
||
structure associated to the <strong>_private</strong> field of the node.</p>
|
||
|
||
<p>A couple of notable exceptions to this are XSLT template nodes (more on
|
||
this later) and attribute value templates. If they are actually templates,
|
||
the value cannot be computed at compilation time. (Some preprocessing could
|
||
be done like isolation and preparsing of the XPath subexpressions but it's
|
||
not done, yet.)</p>
|
||
|
||
<p>The xsltStylePreComp structure also allows storing of the precompiled form
|
||
of an XPath expression that can be associated to an XSLT element (more on
|
||
this later).</p>
|
||
|
||
<h3><a name="XSLT2">The XSLT template compilation</a></h3>
|
||
|
||
<p>A proper handling of templates lookup is one of the keys of fast XSLT
|
||
processing. (Given a node in the source document this is the process of
|
||
finding which templates should be applied to this node.) Libxslt follows the
|
||
hint suggested in the <a href="http://www.w3.org/TR/xslt#patterns">5.2
|
||
Patterns</a> section of the XSLT Recommendation, i.e. it doesn't evaluate it
|
||
as an XPath expression but tokenizes it and compiles it as a set of rules to
|
||
be evaluated on a candidate node. There usually is an indication of the node
|
||
name in the last step of this evaluation and this is used as a key check for
|
||
the match. As a result libxslt builds a relatively more complex set of
|
||
structures for the templates:</p>
|
||
|
||
<p align="center"><img src="templates.gif"
|
||
alt="The templates related structure"></p>
|
||
|
||
<p>Let's describe a bit more closely what is built. First the xsltStylesheet
|
||
structure holds a pointer to the template hash table. All the XSLT patterns
|
||
compiled in this stylesheet are indexed by the value of the the target
|
||
element (or attribute, pi ...) name, so when a element or an attribute "foo"
|
||
needs to be processed the lookup is done using the name as a key.</p>
|
||
|
||
<p>Each of the patterns is compiled into an xsltCompMatch
|
||
(i.e. an ''XSLT compiled match') structure. It holds
|
||
the set of rules based on the tokenization of the pattern stored in reverse
|
||
order (matching is easier this way). </p>
|
||
|
||
<p>The xsltCompMatch are then stored in the hash table, the clash list is
|
||
itself sorted by priority of the template to implement "naturally" the XSLT
|
||
priority rules.</p>
|
||
|
||
<p>Associated to the compiled pattern is the xsltTemplate itself containing
|
||
the information required for the processing of the pattern including, of
|
||
course, a pointer to the list of elements used for building the pattern
|
||
result.</p>
|
||
|
||
<p>Last but not least a number of patterns do not fit in the hash table
|
||
because they are not associated to a name, this is the case for patterns
|
||
applying to the root, any element, any attributes, text nodes, pi nodes, keys
|
||
etc. Those are stored independently in the stylesheet structure as separate
|
||
linked lists of xsltCompMatch.</p>
|
||
|
||
<h3><a name="processing">The processing itself</a></h3>
|
||
|
||
<p>The processing is defined by the XSLT specification (the basis of the
|
||
algorithm is explained in <a
|
||
href="http://www.w3.org/TR/xslt#section-Introduction">the Introduction</a>
|
||
section). Basically it works by taking the root of the input document
|
||
as the cureent node and applying the following algorithm:</p>
|
||
<ol>
|
||
<li>Finding the template applying to current node.
|
||
This is a lookup in the template hash table, walking the hash list until
|
||
the node satisfies all the steps of the pattern, then checking the
|
||
appropriate global template(s) (i.e. templates applying to a node type)
|
||
to see if there isn't a higher priority rule to apply</li>
|
||
<li>If there is no template, apply the default rule (recurse on the
|
||
children as the current node)</li>
|
||
<li>else walk the content list of the selected templates, for each of them:
|
||
<ul>
|
||
<li>if the node is in the XSLT namespace then the node has a _private
|
||
field pointing to the preprocessed values, jump to the specific
|
||
code</li>
|
||
<li>if the node is in an extension namespace, look up the associated
|
||
behavior</li>
|
||
<li>otherwise copy the node.</li>
|
||
</ul>
|
||
<p>The closure is usually done through the XSLT
|
||
<strong>apply-templates</strong>construct, which invokes this process
|
||
recursively starting at step 1, to find the appropriate template
|
||
for the nodes selected by the 'select' attribute of the apply-templates
|
||
instruction (default: the children of the node currently being
|
||
processed)</p>
|
||
</li>
|
||
</ol>
|
||
|
||
<p>Note that large parts of the input tree may not be processed by a given
|
||
stylesheet and that conversely some may be processed multiple times.
|
||
(This often is the case when a Table of Contents is built).</p>
|
||
|
||
<p>The module <code>transform.c</code> is the one implementing most of this
|
||
logic. <strong>xsltApplyStylesheet()</strong> is the entry point, it
|
||
allocates an xsltTransformContext containing the following:</p>
|
||
<ul>
|
||
<li>a pointer to the stylesheet being processed</li>
|
||
<li>a stack of templates</li>
|
||
<li>a stack of variables and parameters</li>
|
||
<li>an XPath context</li>
|
||
<li>the template mode</li>
|
||
<li>current document</li>
|
||
<li>current input node</li>
|
||
<li>current selected node list</li>
|
||
<li>the current insertion points in the output document</li>
|
||
<li>a couple of hash tables for extension elements and functions</li>
|
||
</ul>
|
||
|
||
<p>Then a new document gets allocated (HTML or XML depending on the type of
|
||
output), the user parameters and global variables and parameters are
|
||
evaluated. Then <strong>xsltProcessOneNode()</strong> which implements the
|
||
1-2-3 algorithm is called on the docuemnt node of the input. Step 1/ is
|
||
implemented by calling <strong>xsltGetTemplate()</strong>, step 2/ is
|
||
implemented by <strong>xsltDefaultProcessOneNode()</strong> and step 3/ is
|
||
implemented by <strong>xsltApplyOneTemplate()</strong>.</p>
|
||
|
||
<h3><a name="XPath">XPath expression compilation</a></h3>
|
||
|
||
<p>The XPath support is actually implemented in the libxml module (where it
|
||
is reused by the XPointer implementation). XPath is a relatively classic
|
||
expression language. The only uncommon feature is that it is working on XML
|
||
trees and hence has specific syntax and types to handle them.</p>
|
||
|
||
<p>XPath expressions are compiled using <strong>xmlXPathCompile()</strong>.
|
||
It will take an expression string in input and generate a structure
|
||
containing the parsed expression tree, for example the expression:</p>
|
||
<pre>/doc/chapter[title='Introduction']</pre>
|
||
|
||
<p>will be compiled as</p>
|
||
<pre>Compiled Expression : 10 elements
|
||
SORT
|
||
COLLECT 'child' 'name' 'node' chapter
|
||
COLLECT 'child' 'name' 'node' doc
|
||
ROOT
|
||
PREDICATE
|
||
SORT
|
||
EQUAL =
|
||
COLLECT 'child' 'name' 'node' title
|
||
NODE
|
||
ELEM Object is a string : Introduction
|
||
COLLECT 'child' 'name' 'node' title
|
||
NODE</pre>
|
||
|
||
<p>This can be tested using the <code>testXPath</code> command (in the
|
||
libxml codebase) using the <code>--tree</code> option.</p>
|
||
|
||
<p>Again, the KISS approach is used. No optimization is done. This could be
|
||
an interesting thing to add. <a
|
||
href="http://www-106.ibm.com/developerworks/library/x-xslt2/?dwzone=x?open&l=132%2ct=gr%2c+p=saxon">Michael
|
||
Kay describes</a> a lot of possible and interesting optimizations done in
|
||
Saxon which would be possible at this level. I'm unsure they would provide
|
||
much gain since the expressions tends to be relatively simple in general and
|
||
stylesheets are still hand generated. Optimizations at the interpretation
|
||
sounds likely to be more efficient.</p>
|
||
|
||
<h3><a name="XPath1">XPath interpretation</a></h3>
|
||
|
||
<p>The interpreter is implemented by <strong>xmlXPathCompiledEval()</strong>
|
||
which is the front-end to <strong>xmlXPathCompOpEval()</strong> the function
|
||
implementing the evaluation of the expression tree. This evaluation follows
|
||
the KISS approach again. It's recursive and calls
|
||
<strong>xmlXPathNodeCollectAndTest()</strong> to collect a set of nodes when
|
||
evaluating a <code>COLLECT</code> node.</p>
|
||
|
||
<p>An evaluation is done within the framework of an XPath context stored in
|
||
an <strong>xmlXPathContext</strong> structure, in the framework of a
|
||
transformation the context is maintained within the XSLT context. Its content
|
||
follows the requirements from the XPath specification:</p>
|
||
<ul>
|
||
<li>the current document</li>
|
||
<li>the current node</li>
|
||
<li>a hash table of defined variables (but not used by XSLT,
|
||
which uses its own stack frame for variables, described below)</li>
|
||
<li>a hash table of defined functions</li>
|
||
<li>the proximity position (the place of the node in the current node
|
||
list)</li>
|
||
<li>the context size (the size of the current node list)</li>
|
||
<li>the array of namespace declarations in scope (there also is a namespace
|
||
hash table but it is not used in the XSLT transformation).</li>
|
||
</ul>
|
||
|
||
<p>For the purpose of XSLT an <strong>extra</strong> pointer has been added
|
||
allowing to retrieve the XSLT transformation context. When an XPath
|
||
evaluation is about to be performed, an XPath parser context is allocated
|
||
containing an XPath object stack (this is actually an XPath evaluation
|
||
context, this is a relic of the time where there was no separate parsing and
|
||
evaluation phase in the XPath implementation). Here is an overview of the set
|
||
of contexts associated to an XPath evaluation within an XSLT
|
||
transformation:</p>
|
||
|
||
<p align="center"><img src="contexts.gif"
|
||
alt="The set of contexts associated "></p>
|
||
|
||
<p>Clearly this is a bit too complex and confusing and should be refactored
|
||
at the next set of binary incompatible releases of libxml. For example the
|
||
xmlXPathCtxt has a lot of unused parts and should probably be merged with
|
||
xmlXPathParserCtxt.</p>
|
||
|
||
<h3><a name="Descriptio">Description of XPath Objects</a></h3>
|
||
|
||
<p>An XPath expression manipulates XPath objects. XPath defines the default
|
||
types boolean, numbers, strings and node sets. XSLT adds the result tree
|
||
fragment type which is basically an unmodifiable node set.</p>
|
||
|
||
<p>Implementation-wise, libxml follows again a KISS approach, the
|
||
xmlXPathObject is a structure containing a type description and the various
|
||
possibilities. (Using an enum could have gained some bytes.) In the case of
|
||
node sets (or result tree fragments), it points to a separate xmlNodeSet
|
||
object which contains the list of pointers to the document nodes:</p>
|
||
|
||
<p align="center"><img src="object.gif"
|
||
alt="An Node set object pointing to "></p>
|
||
|
||
<p>The <a href="http://xmlsoft.org/html/libxml-xpath.html">XPath API</a> (and
|
||
its <a href="http://xmlsoft.org/html/libxml-xpathinternals.html">'internal'
|
||
part</a>) includes a number of functions to create, copy, compare, convert or
|
||
free XPath objects.</p>
|
||
|
||
<h3><a name="XPath3">XPath functions</a></h3>
|
||
|
||
<p>All the XPath functions available to the interpreter are registered in the
|
||
function hash table linked from the XPath context. They all share the same
|
||
signature:</p>
|
||
<pre>void xmlXPathFunc (xmlXPathParserContextPtr ctxt, int nargs);</pre>
|
||
|
||
<p>The first argument is the XPath interpretation context, holding the
|
||
interpretation stack. The second argument defines the number of objects
|
||
passed on the stack for the function to consume (last argument is on top of
|
||
the stack).</p>
|
||
|
||
<p>Basically an XPath function does the following:</p>
|
||
<ul>
|
||
<li>check <code>nargs</code> for proper handling of errors or functions
|
||
with variable numbers of parameters</li>
|
||
<li>pop the parameters from the stack using <code>obj =
|
||
valuePop(ctxt);</code></li>
|
||
<li>do the function specific computation</li>
|
||
<li>push the result parameter on the stack using <code>valuePush(ctxt,
|
||
res);</code></li>
|
||
<li>free up the input parameters with
|
||
<code>xmlXPathFreeObject(obj);</code></li>
|
||
<li>return</li>
|
||
</ul>
|
||
|
||
<p>Sometime the work can be done directly by modifying in-situ the top object
|
||
on the stack <code>ctxt->value</code>.</p>
|
||
|
||
<h3><a name="stack">The XSLT variables stack frame</a></h3>
|
||
|
||
<p>Not to be confused with XPath object stack, this stack holds the XSLT
|
||
variables and parameters as they are defined through the recursive calls of
|
||
call-template, apply-templates and default templates. This is used to define
|
||
the scope of variables being called.</p>
|
||
|
||
<p>This part seems to be one needing most work , first it is
|
||
done in a very inefficient way since the location of the variables and
|
||
parameters within the stylesheet tree is still done at run time (it really
|
||
should be done statically at compile time), and I am still unsure that my
|
||
understanding of the template variables and parameter scope is actually
|
||
right.</p>
|
||
|
||
<p>This part of the documentation is still to be written once this part of
|
||
the code will be stable. <span
|
||
style="background-color: #FF0000">TODO</span></p>
|
||
|
||
<h3><a name="Extension">Extension support</a></h3>
|
||
|
||
<p>There is a separate document explaining <a href="extensions.html">how the
|
||
extension support works</a>.</p>
|
||
|
||
<h3><a name="Futher">Further reading</a></h3>
|
||
|
||
<p>Michael Kay wrote <a
|
||
href="http://www-106.ibm.com/developerworks/library/x-xslt2/?dwzone=x?open&l=132%2ct=gr%2c+p=saxon">a
|
||
really interesting article on Saxon internals</a> and the work he did on
|
||
performance issues. I wish I had read it before starting libxslt design (I
|
||
would probably have avoided a few mistakes and progressed faster). A lot of
|
||
the ideas in his papers should be implemented or at least tried in
|
||
libxslt.</p>
|
||
|
||
<p>The <a href="http://xmlsoft.org/">libxml documentation</a>, especially <a
|
||
href="http://xmlsoft.org/xmlio.html">the I/O interfaces</a> and the <a
|
||
href="http://xmlsoft.org/xmlmem.html">memory management</a>.</p>
|
||
|
||
<h3><a name="TODOs">TODOs</a></h3>
|
||
|
||
<p>redesign the XSLT stack frame handling. Far too much work is done at
|
||
execution time. Similarly for the attribute value templates handling, at
|
||
least the embedded subexpressions ought to be precompiled.</p>
|
||
|
||
<p>Allow output to be saved to a SAX like output (this notion of SAX like API
|
||
for output should be added directly to libxml).</p>
|
||
|
||
<p>Implement and test some of the optimization explained by Michael Kay
|
||
especially:</p>
|
||
<ul>
|
||
<li>static slot allocation on the stack frame</li>
|
||
<li>specific boolean interpretation of an XPath expression</li>
|
||
<li>some of the sorting optimization</li>
|
||
<li>Lazy evaluation of location path. (this may require more changes but
|
||
sounds really interesting. XT does this too.)</li>
|
||
<li>Optimization of an expression tree (This could be done as a completely
|
||
independent module.)</li>
|
||
</ul>
|
||
|
||
<p></p>
|
||
|
||
<p>Error reporting, there is a lot of case where the XSLT specification
|
||
specify that a given construct is an error are not checked adequately by
|
||
libxslt. Basically one should do a complete pass on the XSLT spec again and
|
||
add all tests to the stylesheet compilation. Using the DTD provided in the
|
||
appendix and making direct checks using the libxml validation API sounds a
|
||
good idea too (though one should take care of not raising errors for
|
||
elements/attributes in different namespaces).</p>
|
||
|
||
<p>Double check all the places where the stylesheet compiled form might be
|
||
modified at run time (extra removal of blanks nodes, hint on the
|
||
xsltCompMatch).</p>
|
||
|
||
<h3><a name="Thanks">Thanks:</a></h3>
|
||
<p>Thanks to <a href="http://cmsmcq.com/">Michael Sperberg-McQueen</a> for
|
||
various fixes and clarifications on this document!</p>
|
||
|
||
<p></p>
|
||
|
||
<h2><a name="Extensions">Writing extensions</a></h2>
|
||
|
||
<h3>Table of content</h3>
|
||
<ul>
|
||
<li><a href="extensions.html#Introducti">Introduction</a></li>
|
||
<li><a href="extensions.html#Basics">Basics</a></li>
|
||
<li><a href="extensions.html#Keep">Extension modules</a></li>
|
||
<li><a href="extensions.html#Registerin">Registering a module</a></li>
|
||
<li><a href="extensions.html#module">Loading a module</a></li>
|
||
<li><a href="extensions.html#Registerin1">Registering an extension
|
||
function</a></li>
|
||
<li><a href="extensions.html#Implementi">Implementing an extension
|
||
function</a></li>
|
||
<li><a href="extensions.html#Examples">Examples for extension
|
||
functions</a></li>
|
||
<li><a href="extensions.html#Registerin2">Registering an extension
|
||
element</a></li>
|
||
<li><a href="extensions.html#Implementi1">Implementing an extension
|
||
element</a></li>
|
||
<li><a href="extensions.html#Example">Example for extension
|
||
elements</a></li>
|
||
<li><a href="extensions.html#shutdown">The shutdown of a module</a></li>
|
||
<li><a href="extensions.html#Future">Future work</a></li>
|
||
</ul>
|
||
|
||
<h3><a name="Introducti1">Introduction</a></h3>
|
||
|
||
<p>This document describes the work needed to write extensions to the
|
||
standard XSLT library for use with <a
|
||
href="http://xmlsoft.org/XSLT/">libxslt</a>, the <a
|
||
href="http://www.w3.org/TR/xslt">XSLT</a> C library developed for the <a
|
||
href="http://www.gnome.org/">GNOME</a> project.</p>
|
||
|
||
<p>Before starting reading this document it is highly recommended to get
|
||
familiar with <a href="internals.html">the libxslt internals</a>.</p>
|
||
|
||
<p>Note: this documentation is by definition incomplete and I am not good at
|
||
spelling, grammar, so patches and suggestions are <a
|
||
href="mailto:veillard@redhat.com">really welcome</a>.</p>
|
||
|
||
<h3><a name="Basics">Basics</a></h3>
|
||
|
||
<p>The <a href="http://www.w3.org/TR/xslt">XSLT specification</a> provides
|
||
two <a href="http://www.w3.org/TR/xslt">ways to extend an XSLT engine</a>:</p>
|
||
<ul>
|
||
<li>providing <a href="http://www.w3.org/TR/xslt">new extension
|
||
functions</a> which can be called from XPath expressions</li>
|
||
<li>providing <a href="http://www.w3.org/TR/xslt">new extension
|
||
elements</a> which can be inserted in stylesheets</li>
|
||
</ul>
|
||
|
||
<p>In both cases the extensions need to be associated to a new namespace,
|
||
i.e. an URI used as the name for the extension's namespace (there is no need
|
||
to have a resource there for this to work).</p>
|
||
|
||
<p>libxslt provides a few extensions itself, either in the libxslt namespace
|
||
"http://xmlsoft.org/XSLT/namespace" or in namespaces for other well known
|
||
extensions provided by other XSLT processors like Saxon, Xalan or XT.</p>
|
||
|
||
<h3><a name="Keep">Extension modules</a></h3>
|
||
|
||
<p>Since extensions are bound to a namespace name, usually sets of extensions
|
||
coming from a given source are using the same namespace name defining in
|
||
practice a group of extensions providing elements, functions or both. From
|
||
the libxslt point of view those are considered as an "extension module", and
|
||
most of the APIs work at a module point of view.</p>
|
||
|
||
<p>Registration of new functions or elements are bound to the activation of
|
||
the module. This is currently done by declaring the namespace as an extension
|
||
by using the attribute <code>extension-element-prefixes</code> on the
|
||
<code><a href="http://www.w3.org/TR/xslt">xsl:stylesheet</a></code>
|
||
element.</p>
|
||
|
||
<p>An extension module is defined by 3 objects:</p>
|
||
<ul>
|
||
<li>the namespace name associated</li>
|
||
<li>an initialization function</li>
|
||
<li>a shutdown function</li>
|
||
</ul>
|
||
|
||
<h3><a name="Registerin">Registering a module</a></h3>
|
||
|
||
<p>Currently a libxslt module has to be compiled within the application using
|
||
libxslt. There is no code to load dynamically shared libraries associated to
|
||
a namespace (this may be added but is likely to become a portability
|
||
nightmare).</p>
|
||
|
||
<p>The current way to register a module is to link the code implementing it
|
||
with the application and to call a registration function:</p>
|
||
<pre>int xsltRegisterExtModule(const xmlChar *URI,
|
||
xsltExtInitFunction initFunc,
|
||
xsltExtShutdownFunction shutdownFunc);</pre>
|
||
|
||
<p>The associated header is read by:</p>
|
||
<pre>#include<libxslt/extensions.h></pre>
|
||
|
||
<p>which also defines the type for the initialization and shutdown
|
||
functions</p>
|
||
|
||
<h3><a name="module">Loading a module</a></h3>
|
||
|
||
<p>Once the module URI has been registered and if the XSLT processor detects
|
||
that a given stylesheet needs the functionalities of an extended module, this
|
||
one is initialized.</p>
|
||
|
||
<p>The xsltExtInitFunction type defines the interface for an initialization
|
||
function:</p>
|
||
<pre>/**
|
||
* xsltExtInitFunction:
|
||
* @ctxt: an XSLT transformation context
|
||
* @URI: the namespace URI for the extension
|
||
*
|
||
* A function called at initialization time of an XSLT
|
||
* extension module
|
||
*
|
||
* Returns a pointer to the module specific data for this
|
||
* transformation
|
||
*/
|
||
typedef void *(*xsltExtInitFunction)(xsltTransformContextPtr ctxt,
|
||
const xmlChar *URI);</pre>
|
||
|
||
<p>There are 3 things to notice:</p>
|
||
<ul>
|
||
<li>The function gets passed the namespace name URI as an argument. This
|
||
allows a single function to provide the initialization for multiple
|
||
logical modules.</li>
|
||
<li>It also gets passed a transformation context. The initialization is
|
||
done at run time before any processing occurs on the stylesheet but it
|
||
will be invoked separately each time for each transformation.</li>
|
||
<li>It returns a pointer. This can be used to store module specific
|
||
information which can be retrieved later when a function or an element
|
||
from the extension is used. An obvious example is a connection to a
|
||
database which should be kept and reused along with the transformation.
|
||
NULL is a perfectly valid return; there is no way to indicate a failure
|
||
at this level</li>
|
||
</ul>
|
||
|
||
<p>What this function is expected to do is:</p>
|
||
<ul>
|
||
<li>prepare the context for this module (like opening the database
|
||
connection)</li>
|
||
<li>register the extensions specific to this module</li>
|
||
</ul>
|
||
|
||
<h3><a name="Registerin1">Registering an extension function</a></h3>
|
||
|
||
<p>There is a single call to do this registration:</p>
|
||
<pre>int xsltRegisterExtFunction(xsltTransformContextPtr ctxt,
|
||
const xmlChar *name,
|
||
const xmlChar *URI,
|
||
xmlXPathEvalFunc function);</pre>
|
||
|
||
<p>The registration is bound to a single transformation instance referred by
|
||
ctxt, name is the UTF8 encoded name for the NCName of the function, and URI
|
||
is the namespace name for the extension (no checking is done, a module could
|
||
register functions or elements from a different namespace, but it is not
|
||
recommended).</p>
|
||
|
||
<h3><a name="Implementi">Implementing an extension function</a></h3>
|
||
|
||
<p>The implementation of the function must have the signature of a libxml
|
||
XPath function:</p>
|
||
<pre>/**
|
||
* xmlXPathEvalFunc:
|
||
* @ctxt: an XPath parser context
|
||
* @nargs: the number of arguments passed to the function
|
||
*
|
||
* an XPath evaluation function, the parameters are on the
|
||
* XPath context stack
|
||
*/
|
||
|
||
typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt,
|
||
int nargs);</pre>
|
||
|
||
<p>The context passed to an XPath function is not an XSLT context but an <a
|
||
href="internals.html#XPath1">XPath context</a>. However it is possible to
|
||
find one from the other:</p>
|
||
<ul>
|
||
<li>The function xsltXPathGetTransformContext provides this lookup facility:
|
||
<pre>xsltTransformContextPtr
|
||
xsltXPathGetTransformContext
|
||
(xmlXPathParserContextPtr ctxt);</pre>
|
||
</li>
|
||
<li>The <code>xmlXPathContextPtr</code> associated to an
|
||
<code>xsltTransformContext</code> is stored in the <code>xpathCtxt</code>
|
||
field.</li>
|
||
</ul>
|
||
|
||
<p>The first thing an extension function may want to do is to check the
|
||
arguments passed on the stack, the <code>nargs</code> parameter will tell how
|
||
many of them were provided on the XPath expression. The macro valuePop will
|
||
extract them from the XPath stack:</p>
|
||
<pre>#include <libxml/xpath.h>
|
||
#include <libxml/xpathInternals.h>
|
||
|
||
xmlXPathObjectPtr obj = valuePop(ctxt); </pre>
|
||
|
||
<p>Note that <code>ctxt</code> is the XPath context not the XSLT one. It is
|
||
then possible to examine the content of the value. Check <a
|
||
href="internals.html#Descriptio">the description of XPath objects</a> if
|
||
necessary. The following is a common sequence checking whether the argument
|
||
passed is a string and converting it using the built-in XPath
|
||
<code>string()</code> function if this is not the case:</p>
|
||
<pre>if (obj->type != XPATH_STRING) {
|
||
valuePush(ctxt, obj);
|
||
xmlXPathStringFunction(ctxt, 1);
|
||
obj = valuePop(ctxt);
|
||
}</pre>
|
||
|
||
<p>Most common XPath functions are available directly at the C level and are
|
||
exported either in <code><libxml/xpath.h></code> or in
|
||
<code><libxml/xpathInternals.h></code>.</p>
|
||
|
||
<p>The extension function may also need to retrieve the data associated to
|
||
this module instance (the database connection in the previous example) this
|
||
can be done using the xsltGetExtData:</p>
|
||
<pre>void * xsltGetExtData(xsltTransformContextPtr ctxt,
|
||
const xmlChar *URI);</pre>
|
||
|
||
<p>Again the URI to be provided is the one which was used when registering
|
||
the module.</p>
|
||
|
||
<p>Once the function finishes, don't forget to:</p>
|
||
<ul>
|
||
<li>push the return value on the stack using <code>valuePush(ctxt,
|
||
obj)</code></li>
|
||
<li>deallocate the parameters passed to the function using
|
||
<code>xmlXPathFreeObject(obj)</code></li>
|
||
</ul>
|
||
|
||
<h3><a name="Examples">Examples for extension functions</a></h3>
|
||
|
||
<p>The module libxslt/functions.c contains the sources of the XSLT built-in
|
||
functions, including document(), key(), generate-id(), etc. as well as a full
|
||
example module at the end. Here is the test function implementation for the
|
||
libxslt:test function:</p>
|
||
<pre>/**
|
||
* xsltExtFunctionTest:
|
||
* @ctxt: the XPath Parser context
|
||
* @nargs: the number of arguments
|
||
*
|
||
* function libxslt:test() for testing the extensions support.
|
||
*/
|
||
static void
|
||
xsltExtFunctionTest(xmlXPathParserContextPtr ctxt, int nargs)
|
||
{
|
||
xsltTransformContextPtr tctxt;
|
||
void *data;
|
||
|
||
tctxt = xsltXPathGetTransformContext(ctxt);
|
||
if (tctxt == NULL) {
|
||
xsltGenericError(xsltGenericErrorContext,
|
||
"xsltExtFunctionTest: failed to get the transformation context\n");
|
||
return;
|
||
}
|
||
data = xsltGetExtData(tctxt, (const xmlChar *) XSLT_DEFAULT_URL);
|
||
if (data == NULL) {
|
||
xsltGenericError(xsltGenericErrorContext,
|
||
"xsltExtFunctionTest: failed to get module data\n");
|
||
return;
|
||
}
|
||
#ifdef WITH_XSLT_DEBUG_FUNCTION
|
||
xsltGenericDebug(xsltGenericDebugContext,
|
||
"libxslt:test() called with %d args\n", nargs);
|
||
#endif
|
||
}</pre>
|
||
|
||
<h3><a name="Registerin2">Registering an extension element</a></h3>
|
||
|
||
<p>There is a single call to do this registration:</p>
|
||
<pre>int xsltRegisterExtElement(xsltTransformContextPtr ctxt,
|
||
const xmlChar *name,
|
||
const xmlChar *URI,
|
||
xsltTransformFunction function);</pre>
|
||
|
||
<p>It is similar to the mechanism used to register an extension function,
|
||
except that the signature of an extension element implementation is
|
||
different.</p>
|
||
|
||
<p>The registration is bound to a single transformation instance referred to
|
||
by ctxt, name is the UTF8 encoded name for the NCName of the element, and URI
|
||
is the namespace name for the extension (no checking is done, a module could
|
||
register elements for a different namespace, but it is not recommended).</p>
|
||
|
||
<h3><a name="Implementi1">Implementing an extension element</a></h3>
|
||
|
||
<p>The implementation of the element must have the signature of an XSLT
|
||
transformation function:</p>
|
||
<pre>/**
|
||
* xsltTransformFunction:
|
||
* @ctxt: the XSLT transformation context
|
||
* @node: the input node
|
||
* @inst: the stylesheet node
|
||
* @comp: the compiled information from the stylesheet
|
||
*
|
||
* signature of the function associated to elements part of the
|
||
* stylesheet language like xsl:if or xsl:apply-templates.
|
||
*/
|
||
typedef void (*xsltTransformFunction)
|
||
(xsltTransformContextPtr ctxt,
|
||
xmlNodePtr node,
|
||
xmlNodePtr inst,
|
||
xsltStylePreCompPtr comp);</pre>
|
||
|
||
<p>The first argument is the XSLT transformation context. The second and
|
||
third arguments are xmlNodePtr i.e. internal memory <a
|
||
href="internals.html#libxml">representation of XML nodes</a>. They are
|
||
respectively <code>node</code> from the the input document being transformed
|
||
by the stylesheet and <code>inst</code> the extension element in the
|
||
stylesheet. The last argument is <code>comp</code> a pointer to a precompiled
|
||
representation of <code>inst</code> but usually for an extension function
|
||
this value is <code>NULL</code> by default (it could be added and associated
|
||
to the instruction in <code>inst->_private</code>).</p>
|
||
|
||
<p>The same functions are available from a function implementing an extension
|
||
element as in an extension function, including
|
||
<code>xsltGetExtData()</code>.</p>
|
||
|
||
<p>The goal of an extension element being usually to enrich the generated
|
||
output, it is expected that they will grow the currently generated output
|
||
tree. This can be done by grabbing ctxt->insert which is the current
|
||
libxml node being generated (Note this can also be the intermediate value
|
||
tree being built for example to initialize a variable, the processing should
|
||
be similar). The functions for libxml tree manipulation from <a
|
||
href="http://xmlsoft.org/html/libxml-tree.html"><libxml/tree.h></a> can
|
||
be employed to extend or modify the tree, but it is required to preserve the
|
||
insertion node and its ancestors since there are existing pointers to those
|
||
elements still in use in the XSLT template execution stack.</p>
|
||
|
||
<h3><a name="Example">Example for extension elements</a></h3>
|
||
|
||
<p>The module libxslt/transform.c contains the sources of the XSLT built-in
|
||
elements, including xsl:element, xsl:attribute, xsl:if, etc. There is a small
|
||
but full example in functions.c providing the implementation for the
|
||
libxslt:test element, it will output a comment in the result tree:</p>
|
||
<pre>/**
|
||
* xsltExtElementTest:
|
||
* @ctxt: an XSLT processing context
|
||
* @node: The current node
|
||
* @inst: the instruction in the stylesheet
|
||
* @comp: precomputed information
|
||
*
|
||
* Process a libxslt:test node
|
||
*/
|
||
static void
|
||
xsltExtElementTest(xsltTransformContextPtr ctxt, xmlNodePtr node,
|
||
xmlNodePtr inst,
|
||
xsltStylePreCompPtr comp)
|
||
{
|
||
xmlNodePtr comment;
|
||
|
||
if (ctxt == NULL) {
|
||
xsltGenericError(xsltGenericErrorContext,
|
||
"xsltExtElementTest: no transformation context\n");
|
||
return;
|
||
}
|
||
if (node == NULL) {
|
||
xsltGenericError(xsltGenericErrorContext,
|
||
"xsltExtElementTest: no current node\n");
|
||
return;
|
||
}
|
||
if (inst == NULL) {
|
||
xsltGenericError(xsltGenericErrorContext,
|
||
"xsltExtElementTest: no instruction\n");
|
||
return;
|
||
}
|
||
if (ctxt->insert == NULL) {
|
||
xsltGenericError(xsltGenericErrorContext,
|
||
"xsltExtElementTest: no insertion point\n");
|
||
return;
|
||
}
|
||
comment =
|
||
xmlNewComment((const xmlChar *)
|
||
"libxslt:test element test worked");
|
||
xmlAddChild(ctxt->insert, comment);
|
||
}</pre>
|
||
|
||
<h3><a name="shutdown">The shutdown of a module</a></h3>
|
||
|
||
<p>When the XSLT processor ends a transformation, the shutdown function (if
|
||
it exists) for each of the modules initialized is called. The
|
||
xsltExtShutdownFunction type defines the interface for a shutdown
|
||
function:</p>
|
||
<pre>/**
|
||
* xsltExtShutdownFunction:
|
||
* @ctxt: an XSLT transformation context
|
||
* @URI: the namespace URI for the extension
|
||
* @data: the data associated to this module
|
||
*
|
||
* A function called at shutdown time of an XSLT extension module
|
||
*/
|
||
typedef void (*xsltExtShutdownFunction) (xsltTransformContextPtr ctxt,
|
||
const xmlChar *URI,
|
||
void *data);</pre>
|
||
|
||
<p>This is really similar to a module initialization function except a third
|
||
argument is passed, it's the value that was returned by the initialization
|
||
function. This allows the routine to deallocate resources from the module for
|
||
example close the connection to the database to keep the same example.</p>
|
||
|
||
<h3><a name="Future">Future work</a></h3>
|
||
|
||
<p>Well, some of the pieces missing:</p>
|
||
<ul>
|
||
<li>a way to load shared libraries to instantiate new modules</li>
|
||
<li>a better detection of extension functions usage and their registration
|
||
without having to use the extension prefix which ought to be reserved to
|
||
element extensions.</li>
|
||
<li>more examples</li>
|
||
<li>implementations of the <a href="http://www.exslt.org/">EXSLT</a> common
|
||
extension libraries, Thomas Broyer nearly finished implementing them.</li>
|
||
</ul>
|
||
|
||
<p></p>
|
||
|
||
<h2><a name="Contributi">Contributions</a></h2>
|
||
<ul>
|
||
<li>Bjorn Reese is the author of the number support and worked on the
|
||
XSLTMark support</li>
|
||
<li>William Brack was an early adopted, contributed a number of patches and
|
||
spent quite some time debugging non-trivial problems in early versions of
|
||
libxslt</li>
|
||
<li><a href="mailto:igor@zlatkovic.com">Igor Zlatkovic</a> is now the
|
||
maintainer of the Windows port, <a
|
||
href="http://www.zlatkovic.com/projects/libxml/index.html">he provides
|
||
binaries</a></li>
|
||
<li>Thomas Broyer provided a lot of suggestions, and drafted most of the
|
||
extension API</li>
|
||
<li>John Fleck maintains <a href="tutorial/libxslttutorial.html">a tutorial
|
||
for libxslt</a></li>
|
||
<li><a
|
||
href="http://mail.gnome.org/archives/xml/2001-March/msg00014.html">Matt
|
||
Sergeant</a> developed <a
|
||
href="http://axkit.org/download/">XML::LibXSLT</a>, a perl wrapper for
|
||
libxml2/libxslt as part of the <a href="http://axkit.com/">AxKit XML
|
||
application server</a></li>
|
||
<li>there is a module for <a
|
||
href="http://acs-misc.sourceforge.net/nsxml.html">libxml/libxslt support
|
||
in OpenNSD/AOLServer</a></li>
|
||
<li><a href="mailto:dkuhlman@cutter.rexx.com">Dave Kuhlman</a> provides
|
||
libxml/libxslt <a href="http://www.rexx.com/~dkuhlman">wrappers for
|
||
Python</a></li>
|
||
<li><a href="mailto:Steve.Ball@explain.com.au">Steve Ball</a>, and
|
||
contributors maintain <a href="http://tclxml.sourceforge.net/">tcl
|
||
bindings for libxml2 and libxslt</a>, as well as <a
|
||
href="http://tclxml.sf.net/tkxmllint.html">tkxmllint</a> a GUI for
|
||
xmllint and <a href="http://tclxml.sf.net/tkxsltproc.html">tkxsltproc</a>
|
||
a GUI for xsltproc.</li>
|
||
<li>If you want to use libxslt in a Mac OS X/Cocoa or Objective-C
|
||
framework, Marc Liyanage provides <a
|
||
href="http://www.entropy.ch/software/macosx/#testxslt">an application
|
||
TestXSLT for XSLT and XML editing</a> including wrapper classes for the
|
||
XML parser and XSLT processor.</li>
|
||
</ul>
|
||
|
||
<p></p>
|
||
|
||
<p><a href="mailto:daniel@veillard.com">Daniel Veillard</a></p>
|
||
</body>
|
||
</html>
|