templates

Gnome XSLT Library Reference Manual
<<< Previous Page	Home	Up	Next Page >>>

Details

xsltEvalXPathPredicate ()

int         xsltEvalXPathPredicate          (xsltTransformContextPtr ctxt,
                                             xmlXPathCompExprPtr comp,
                                             xmlNsPtr *nsList,
                                             int nsNr);

Process the expression using XPath and evaluate the result as an XPath predicate

`ctxt` :	the XSLT transformation context
`comp` :	the XPath compiled expression
`nsList` :	the namespaces in scope
`nsNr` :	the number of namespaces in scope
Returns :	1 is the predicate was true, 0 otherwise

xsltEvalTemplateString ()

xmlChar*    xsltEvalTemplateString          (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             xmlNodePtr parent);

Evaluate a template string value, i.e. the parent list is interpreter as template content and the resulting tree string value is returned This is needed for example by xsl:comment and xsl:processing-instruction

`ctxt` :	the XSLT transformation context
`node` :	the stylesheet node
`parent` :	the content parent
Returns :	the computed string value or NULL, must be deallocated by the caller.

xsltEvalAttrValueTemplate ()

xmlChar*    xsltEvalAttrValueTemplate       (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node,
                                             const xmlChar *name,
                                             const xmlChar *ns);

Evaluate a attribute value template, i.e. the attribute value can contain expressions contained in curly braces ({}) and those are substituted by they computed value.

`ctxt` :	the XSLT transformation context
`node` :	the stylesheet node
`name` :	the attribute QName
`ns` :	the attribute namespace URI
Returns :	the computed string value or NULL, must be deallocated by the caller.

xsltEvalStaticAttrValueTemplate ()

xmlChar*    xsltEvalStaticAttrValueTemplate (xsltStylesheetPtr style,
                                             xmlNodePtr node,
                                             const xmlChar *name,
                                             const xmlChar *ns,
                                             int *found);

Check if an attribute value template has a static value, i.e. the attribute value does not contain expressions contained in curly braces ({})

`style` :	the XSLT stylesheet
`node` :	the stylesheet node
`name` :	the attribute Name
`ns` :	the attribute namespace URI
`found` :	indicator whether the attribute is present
Returns :	the static string value or NULL, must be deallocated by the caller.

xsltEvalXPathString ()

xmlChar*    xsltEvalXPathString             (xsltTransformContextPtr ctxt,
                                             xmlXPathCompExprPtr comp);

Process the expression using XPath and get a string

`ctxt` :	the XSLT transformation context
`comp` :	the compiled XPath expression
Returns :	the computed string value or NULL, must be deallocated by the caller.

xsltTemplateProcess ()

xmlNodePtr* xsltTemplateProcess             (xsltTransformContextPtr ctxt,
                                             xmlNodePtr node);

Process the given node and return the new string value.

`ctxt` :	the XSLT transformation context
`node` :	the attribute template node
Returns :	the computed tree replacement

xsltAttrListTemplateProcess ()

xmlAttrPtr  xsltAttrListTemplateProcess     (xsltTransformContextPtr ctxt,
                                             xmlNodePtr target,
                                             xmlAttrPtr cur);

Do a copy of an attribute list with attribute template processing

`ctxt` :	the XSLT transformation context
`target` :	the element where the attributes will be grafted
`cur` :	the first attribute
Returns :	a new xmlAttrPtr, or NULL in case of error.

xsltAttrTemplateProcess ()

xmlAttrPtr  xsltAttrTemplateProcess         (xsltTransformContextPtr ctxt,
                                             xmlNodePtr target,
                                             xmlAttrPtr attr);

Process the given attribute and return the new processed copy.

`ctxt` :	the XSLT transformation context
`target` :	the result node
`attr` :
Returns :	the attribute replacement.

xsltAttrTemplateValueProcess ()

xmlChar*    xsltAttrTemplateValueProcess    (xsltTransformContextPtr ctxt,
                                             const xmlChar *attr);