uword
xmlctx
xmlnode
[All Packages] [Previous]
XSLT is a language for tranforming XML documents into other XML documents.
XSLT is designed for use as part of XSL, which is a stylesheet language for XML. In addition to XSLT, XSL includes an XML vocabulary for specifying formatting. XSL specifies the styling of an XML document by using XSLT to describe how the document is transformed into another XML document that uses the formatting vocabulary.
XSLT is also designed to be used indepently of XSL. However, XSLT is not intended as a completely general-purpose XML transformation language. Rather it is designed primarily for the kinds of transformation that are needed when XSLT is used as part of XSL.
A transformation expressed in XSLT describes rules for transforming a source tree into a result tree. The transformation is achieved by associating patterns with templates. A pattern is matched against elements in the source tree. A template is instantiated to create part of the result tree. The result tree is separate from the source tree. The structure of the result tree can be completely different from the structure of the source tree. In constructing the result tree, elements from the source tree can be filtered and reordered, and arbitrary structure can be added.
A transformation expressed in XSLT is called a stylesheet. This is because, in the case when XSLT is transforming into the XSL formatting vocabulary, the transformation functions as a stylesheet.
A stylesheet contains a set of template rules. A template rule has two parts: a pattern which is matched against nodes in the source tree and a template which can be instantiated to form part of the result tree. This allows a stylesheet to be applicable to a wide class of documents that have similar source tree structures.
A template is instantiated for a particular source element to create part of the result tree. A template can contain elements that specify literal result element structure. A template can also contain elements from the XSLT namespace that are instructions for creating result tree fragments. When a template is instantiated, each instruction is executed and replaced by the result tree fragment that it creates. Instructions can select and process descendant source elements. Processing a descendant element creates a result tree fragment by finding the applicable template rule and instantiating its template. Note that elements are only processed when they have been selected by the execution of an instruction. The result tree is constructed by finding the template rule for the root node and instantiating its template.
A software module called an XSL processor is used to read XML documents and transform them into other XML documents with different styles.
The C implementation of the XSL processor followed the XSL Transformations standard (version 1.0, November 16, 1999) and included the required behavior of an XSL processor as specified in the XSLT specification.
uword
xmlctx
xmlnode
xslprocess(xmlctx *docctx, xmlctx *xslctx, xmlctx *resctx, xmlnode **result)
uword
typedef unsigned int uword;
xmlctx
typedef struct xmlctx xmlctx;
Note: The contents of xmlctx are private and must not be accessed by users.
xmlnode
typedef struct xmlnode xmlnode;
Note: The contents of xmlnode are private and must not be accessed by users.
xslprocess
PURPOSE
This function processes an XSL Stylesheet with an XML document source.
SYNTAX
uword xslprocess(xmlctx *docctx, xmlctx *xslctx, xmlctx *resctx, xmlnode **result);
PARAMETERS
xmlctx (IN/OUT) - The XML document context
xslctx (IN) - The XSL stylesheet context
resctx (IN) - The result document fragment context
result (IN/OUT) - The result document fragment node