templates: interface for the template processing

This set of routine encapsulates XPath calls and Attribute Value Templates evaluation.

Details

xsltAttrListTemplateProcess ()

xmlAttrPtr	xsltAttrListTemplateProcess	(xsltTransformContextPtr ctxt, 
						 xmlNodePtr target, 
						 xmlAttrPtr attrs)

Processes all attributes of a Literal Result Element. Attribute references are applied via xsl:use-attribute-set attributes. Copies all non XSLT-attributes over to the @target element and evaluates Attribute Value Templates. Called by xsltApplySequenceConstructor() (transform.c).

`ctxt`:	the XSLT transformation context
`target`:	the element where the attributes will be grafted
`attrs`:	the first attribute
`Returns`:	a new list of attribute nodes, or NULL in case of error. (Don't assign the result to @target->properties; if the result is NULL, you'll get memory leaks, since the attributes will be disattached.)

xsltAttrTemplateProcess ()

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

Process one attribute of a Literal Result Element (in the stylesheet). Evaluates Attribute Value Templates and copies the attribute over to the result element. This does *not* process attribute sets (xsl:use-attribute-set).

`ctxt`:	the XSLT transformation context
`target`:	the element where the attribute will be grafted
`attr`:	the attribute node of a literal result element
`Returns`:	the generated attribute node.

xsltAttrTemplateValueProcess ()

xmlChar *	xsltAttrTemplateValueProcess	(xsltTransformContextPtr ctxt, 
						 const xmlChar * str)

Process the given node and return the new string value.

`ctxt`:	the XSLT transformation context
`str`:	the attribute template node value
`Returns`:	the computed string value or NULL, must be deallocated by the caller.

xsltAttrTemplateValueProcessNode ()

xmlChar *	xsltAttrTemplateValueProcessNode	(xsltTransformContextPtr ctxt, 
							 const xmlChar * str, 
							 xmlNodePtr inst)

Process the given string, allowing to pass a namespace mapping context and return the new string value. Called by: - xsltAttrTemplateValueProcess() (templates.c) - xsltEvalAttrValueTemplate() (templates.c) QUESTION: Why is this function public? It is not used outside of templates.c.

`ctxt`:	the XSLT transformation context
`str`:	the attribute template node value
`inst`:	the instruction (or LRE) in the stylesheet holding the attribute with an AVT
`Returns`:	the computed string value or NULL, must be deallocated by the caller.

xsltEvalAttrValueTemplate ()

xmlChar *	xsltEvalAttrValueTemplate	(xsltTransformContextPtr ctxt, 
						 xmlNodePtr inst, 
						 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
`inst`:	the instruction (or LRE) in the stylesheet holding the attribute with an AVT
`name`:	the attribute QName
`ns`:	the attribute namespace URI
`Returns`:	the computed string value or NULL, must be deallocated by the caller.

xsltEvalStaticAttrValueTemplate ()

const xmlChar *	xsltEvalStaticAttrValueTemplate	(xsltStylesheetPtr style, 
						 xmlNodePtr inst, 
						 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
`inst`:	the instruction (or LRE) in the stylesheet holding the attribute with an AVT
`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.

xsltEvalTemplateString ()

xmlChar *	xsltEvalTemplateString	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr contextNode, 
					 xmlNodePtr inst)

Processes the sequence constructor of the given instruction on @contextNode and converts the resulting tree to a string. This is needed by e.g. xsl:comment and xsl:processing-instruction.

`ctxt`:	the XSLT transformation context
`contextNode`:	the current node in the source tree
`inst`:	the XSLT instruction (xsl:comment, xsl:processing-instruction)
`Returns`:	the computed string value or NULL; it's up to the caller to free the result.

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

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.

xsltEvalXPathStringNs ()

xmlChar *	xsltEvalXPathStringNs	(xsltTransformContextPtr ctxt, 
					 xmlXPathCompExprPtr comp, 
					 int nsNr, 
					 xmlNsPtr * nsList)

Process the expression using XPath, allowing to pass a namespace mapping context and get a string

`ctxt`:	the XSLT transformation context
`comp`:	the compiled XPath expression
`nsNr`:	the number of namespaces in the list
`nsList`:	the list of in-scope namespaces to use
`Returns`:	the computed string value or NULL, must be deallocated by the caller.

xsltTemplateProcess ()

xmlNodePtr *	xsltTemplateProcess	(xsltTransformContextPtr ctxt, 
					 xmlNodePtr node)

Obsolete. Don't use it.

`ctxt`:	the XSLT transformation context
`node`:	the attribute template node
`Returns`:	NULL.

templates

Synopsis

Description