templates.h File Reference

#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include "xsltexports.h"
#include "xsltInternals.h"

Include dependency graph for templates.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
XSLTPUBFUN int XSLTCALL	xsltEvalXPathPredicate (xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp, xmlNsPtr *nsList, int nsNr)
XSLTPUBFUN xmlChar *XSLTCALL	xsltEvalTemplateString (xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst)
XSLTPUBFUN xmlChar *XSLTCALL	xsltEvalAttrValueTemplate (xsltTransformContextPtr ctxt, xmlNodePtr node, const xmlChar *name, const xmlChar *ns)
XSLTPUBFUN const xmlChar *XSLTCALL	xsltEvalStaticAttrValueTemplate (xsltStylesheetPtr style, xmlNodePtr node, const xmlChar *name, const xmlChar *ns, int *found)
XSLTPUBFUN xmlChar *XSLTCALL	xsltEvalXPathString (xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp)
XSLTPUBFUN xmlChar *XSLTCALL	xsltEvalXPathStringNs (xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp, int nsNr, xmlNsPtr *nsList)
XSLTPUBFUN xmlNodePtr *XSLTCALL	xsltTemplateProcess (xsltTransformContextPtr ctxt, xmlNodePtr node)
XSLTPUBFUN xmlAttrPtr XSLTCALL	xsltAttrListTemplateProcess (xsltTransformContextPtr ctxt, xmlNodePtr target, xmlAttrPtr cur)
XSLTPUBFUN xmlAttrPtr XSLTCALL	xsltAttrTemplateProcess (xsltTransformContextPtr ctxt, xmlNodePtr target, xmlAttrPtr attr)
XSLTPUBFUN xmlChar *XSLTCALL	xsltAttrTemplateValueProcess (xsltTransformContextPtr ctxt, const xmlChar *attr)
XSLTPUBFUN xmlChar *XSLTCALL	xsltAttrTemplateValueProcessNode (xsltTransformContextPtr ctxt, const xmlChar *str, xmlNodePtr node)

Function Documentation

xsltAttrListTemplateProcess()

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

xsltAttrListTemplateProcess: @ctxt: the XSLT transformation context @target: the element where the attributes will be grafted @attrs: the first attribute

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).

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.)

Definition at line 635 of file templates.c.

{
    xmlAttrPtr attr, copy, last = NULL;
    xmlNodePtr oldInsert, text;
    xmlNsPtr origNs = NULL, copyNs = NULL;
    const xmlChar *value;
    xmlChar *valueAVT;
    int hasAttr = 0;
 
    if ((ctxt == NULL) || (target == NULL) || (attrs == NULL) ||
        (target->type != XML_ELEMENT_NODE))
    return(NULL);
 
    oldInsert = ctxt->insert;
    ctxt->insert = target;
 
    /*
    * Apply attribute-sets.
    */
    attr = attrs;
    do {
#ifdef XSLT_REFACTORED
    if ((attr->psvi == xsltXSLTAttrMarker) &&
        xmlStrEqual(attr->name, (const xmlChar *)"use-attribute-sets"))
    {
        xsltApplyAttributeSet(ctxt, ctxt->node, (xmlNodePtr) attr, NULL);
    }
#else
    if ((attr->ns != NULL) &&
        xmlStrEqual(attr->name, (const xmlChar *)"use-attribute-sets") &&
        xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
    {
        xsltApplyAttributeSet(ctxt, ctxt->node, (xmlNodePtr) attr, NULL);
    }
#endif
    attr = attr->next;
    } while (attr != NULL);
 
    if (target->properties != NULL) {
        hasAttr = 1;
    }
 
    /*
    * Instantiate LRE-attributes.
    */
    attr = attrs;
    do {
    /*
    * Skip XSLT attributes.
    */
#ifdef XSLT_REFACTORED
    if (attr->psvi == xsltXSLTAttrMarker) {
        goto next_attribute;
    }
#else
    if ((attr->ns != NULL) &&
        xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
    {
        goto next_attribute;
    }
#endif
    /*
    * Get the value.
    */
    if (attr->children != NULL) {
        if ((attr->children->type != XML_TEXT_NODE) ||
        (attr->children->next != NULL))
        {
        xsltTransformError(ctxt, NULL, attr->parent,
            "Internal error: The children of an attribute node of a "
            "literal result element are not in the expected form.\n");
        goto error;
        }
        value = attr->children->content;
        if (value == NULL)
        value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
    } else
        value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
 
    /*
    * Get the namespace. Avoid lookups of same namespaces.
    */
    if (attr->ns != origNs) {
        origNs = attr->ns;
        if (attr->ns != NULL) {
#ifdef XSLT_REFACTORED
        copyNs = xsltGetSpecialNamespace(ctxt, attr->parent,
            attr->ns->href, attr->ns->prefix, target);
#else
        copyNs = xsltGetNamespace(ctxt, attr->parent,
            attr->ns, target);
#endif
        if (copyNs == NULL)
            goto error;
        } else
        copyNs = NULL;
    }
    /*
    * Create a new attribute.
    */
        if (hasAttr) {
        copy = xmlSetNsProp(target, copyNs, attr->name, NULL);
        } else {
            /*
            * Avoid checking for duplicate attributes if there aren't
            * any attribute sets.
            */
        copy = xmlNewDocProp(target->doc, attr->name, NULL);
 
        if (copy != NULL) {
                copy->ns = copyNs;
 
                /*
                * Attach it to the target element.
                */
                copy->parent = target;
                if (last == NULL) {
                    target->properties = copy;
                    last = copy;
                } else {
                    last->next = copy;
                    copy->prev = last;
                    last = copy;
                }
            }
        }
    if (copy == NULL) {
        if (attr->ns) {
        xsltTransformError(ctxt, NULL, attr->parent,
            "Internal error: Failed to create attribute '{%s}%s'.\n",
            attr->ns->href, attr->name);
        } else {
        xsltTransformError(ctxt, NULL, attr->parent,
            "Internal error: Failed to create attribute '%s'.\n",
            attr->name);
        }
        goto error;
    }
 
    /*
    * Set the value.
    */
    text = xmlNewText(NULL);
    if (text != NULL) {
        copy->last = copy->children = text;
        text->parent = (xmlNodePtr) copy;
        text->doc = copy->doc;
 
        if (attr->psvi != NULL) {
        /*
        * Evaluate the Attribute Value Template.
        */
        valueAVT = xsltEvalAVT(ctxt, attr->psvi, attr->parent);
        if (valueAVT == NULL) {
            /*
            * TODO: Damn, we need an easy mechanism to report
            * qualified names!
            */
            if (attr->ns) {
            xsltTransformError(ctxt, NULL, attr->parent,
                "Internal error: Failed to evaluate the AVT "
                "of attribute '{%s}%s'.\n",
                attr->ns->href, attr->name);
            } else {
            xsltTransformError(ctxt, NULL, attr->parent,
                "Internal error: Failed to evaluate the AVT "
                "of attribute '%s'.\n",
                attr->name);
            }
            text->content = xmlStrdup(BAD_CAST "");
            goto error;
        } else {
            text->content = valueAVT;
        }
        } else if ((ctxt->internalized) &&
        (target->doc != NULL) &&
        (target->doc->dict == ctxt->dict) &&
        xmlDictOwns(ctxt->dict, value))
        {
        text->content = (xmlChar *) value;
        } else {
        text->content = xmlStrdup(value);
        }
            if ((copy != NULL) && (text != NULL) &&
                (xmlIsID(copy->doc, copy->parent, copy)))
                xmlAddID(NULL, copy->doc, text->content, copy);
    }
 
next_attribute:
    attr = attr->next;
    } while (attr != NULL);
 
    ctxt->insert = oldInsert;
    return(target->properties);
 
error:
    ctxt->insert = oldInsert;
    return(NULL);
}

Referenced by xsltApplySequenceConstructor().

xsltAttrTemplateProcess()

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

xsltAttrTemplateProcess: @ctxt: the XSLT transformation context @target: the element where the attribute will be grafted @attr: the attribute node of a literal result element

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).

Returns the generated attribute node.

Definition at line 479 of file templates.c.

{
    const xmlChar *value;
    xmlAttrPtr ret;
 
    if ((ctxt == NULL) || (attr == NULL) || (target == NULL) ||
        (target->type != XML_ELEMENT_NODE))
    return(NULL);
 
    if (attr->type != XML_ATTRIBUTE_NODE)
    return(NULL);
 
    /*
    * Skip all XSLT attributes.
    */
#ifdef XSLT_REFACTORED
    if (attr->psvi == xsltXSLTAttrMarker)
    return(NULL);
#else
    if ((attr->ns != NULL) && xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
    return(NULL);
#endif
    /*
    * Get the value.
    */
    if (attr->children != NULL) {
    if ((attr->children->type != XML_TEXT_NODE) ||
        (attr->children->next != NULL))
    {
        xsltTransformError(ctxt, NULL, attr->parent,
        "Internal error: The children of an attribute node of a "
        "literal result element are not in the expected form.\n");
        return(NULL);
    }
    value = attr->children->content;
    if (value == NULL)
        value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
    } else
    value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
    /*
    * Overwrite duplicates.
    */
    ret = target->properties;
    while (ret != NULL) {
        if (((attr->ns != NULL) == (ret->ns != NULL)) &&
        xmlStrEqual(ret->name, attr->name) &&
        ((attr->ns == NULL) || xmlStrEqual(ret->ns->href, attr->ns->href)))
    {
        break;
    }
        ret = ret->next;
    }
    if (ret != NULL) {
        /* free the existing value */
    xmlFreeNodeList(ret->children);
    ret->children = ret->last = NULL;
    /*
    * Adjust ns-prefix if needed.
    */
    if ((ret->ns != NULL) &&
        (! xmlStrEqual(ret->ns->prefix, attr->ns->prefix)))
    {
        ret->ns = xsltGetNamespace(ctxt, attr->parent, attr->ns, target);
    }
    } else {
        /* create a new attribute */
    if (attr->ns != NULL)
        ret = xmlNewNsProp(target,
        xsltGetNamespace(ctxt, attr->parent, attr->ns, target),
            attr->name, NULL);
    else
        ret = xmlNewNsProp(target, NULL, attr->name, NULL);
    }
    /*
    * Set the value.
    */
    if (ret != NULL) {
        xmlNodePtr text;
 
        text = xmlNewText(NULL);
    if (text != NULL) {
        ret->last = ret->children = text;
        text->parent = (xmlNodePtr) ret;
        text->doc = ret->doc;
 
        if (attr->psvi != NULL) {
        /*
        * Evaluate the Attribute Value Template.
        */
        xmlChar *val;
        val = xsltEvalAVT(ctxt, attr->psvi, attr->parent);
        if (val == NULL) {
            /*
            * TODO: Damn, we need an easy mechanism to report
            * qualified names!
            */
            if (attr->ns) {
            xsltTransformError(ctxt, NULL, attr->parent,
                "Internal error: Failed to evaluate the AVT "
                "of attribute '{%s}%s'.\n",
                attr->ns->href, attr->name);
            } else {
            xsltTransformError(ctxt, NULL, attr->parent,
                "Internal error: Failed to evaluate the AVT "
                "of attribute '%s'.\n",
                attr->name);
            }
            text->content = xmlStrdup(BAD_CAST "");
        } else {
            text->content = val;
        }
        } else if ((ctxt->internalized) && (target != NULL) &&
                   (target->doc != NULL) &&
               (target->doc->dict == ctxt->dict) &&
               xmlDictOwns(ctxt->dict, value)) {
        text->content = (xmlChar *) value;
        } else {
        text->content = xmlStrdup(value);
        }
    }
    } else {
    if (attr->ns) {
        xsltTransformError(ctxt, NULL, attr->parent,
        "Internal error: Failed to create attribute '{%s}%s'.\n",
        attr->ns->href, attr->name);
    } else {
        xsltTransformError(ctxt, NULL, attr->parent,
        "Internal error: Failed to create attribute '%s'.\n",
        attr->name);
    }
    }
    return(ret);
}

xsltAttrTemplateValueProcess()

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

xsltAttrTemplateValueProcess: @ctxt: the XSLT transformation context @str: the attribute template node value

Process the given node and return the new string value.

Returns the computed string value or NULL, must be deallocated by the caller.

Definition at line 372 of file templates.c.

                                                                               {
    return(xsltAttrTemplateValueProcessNode(ctxt, str, NULL));
}

xsltAttrTemplateValueProcessNode()

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

xsltAttrTemplateValueProcessNode: @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

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.

Returns the computed string value or NULL, must be deallocated by the caller.

Definition at line 260 of file templates.c.

{
    xmlChar *ret = NULL;
    const xmlChar *cur;
    xmlChar *expr, *val;
    xmlNsPtr *nsList = NULL;
    int nsNr = 0;
 
    if (str == NULL) return(NULL);
    if (*str == 0)
    return(xmlStrndup((xmlChar *)"", 0));
 
    cur = str;
    while (*cur != 0) {
    if (*cur == '{') {
        if (*(cur+1) == '{') {  /* escaped '{' */
            cur++;
        ret = xmlStrncat(ret, str, cur - str);
        cur++;
        str = cur;
        continue;
        }
        ret = xmlStrncat(ret, str, cur - str);
        str = cur;
        cur++;
        while ((*cur != 0) && (*cur != '}')) {
        /* Need to check for literal (bug539741) */
        if ((*cur == '\'') || (*cur == '"')) {
            char delim = *(cur++);
            while ((*cur != 0) && (*cur != delim))
            cur++;
            if (*cur != 0)
            cur++;  /* skip the ending delimiter */
        } else
            cur++;
            }
        if (*cur == 0) {
            xsltTransformError(ctxt, NULL, inst,
            "xsltAttrTemplateValueProcessNode: unmatched '{'\n");
        ret = xmlStrncat(ret, str, cur - str);
        goto exit;
        }
        str++;
        expr = xmlStrndup(str, cur - str);
        if (expr == NULL)
        goto exit;
        else if (*expr == '{') {
        ret = xmlStrcat(ret, expr);
        xmlFree(expr);
        } else {
        xmlXPathCompExprPtr comp;
        /*
         * TODO: keep precompiled form around
         */
        if ((nsList == NULL) && (inst != NULL)) {
            int i = 0;
 
            nsList = xmlGetNsList(inst->doc, inst);
            if (nsList != NULL) {
            while (nsList[i] != NULL)
                i++;
            nsNr = i;
            }
        }
        comp = xmlXPathCtxtCompile(ctxt->xpathCtxt, expr);
                val = xsltEvalXPathStringNs(ctxt, comp, nsNr, nsList);
        xmlXPathFreeCompExpr(comp);
        xmlFree(expr);
        if (val != NULL) {
            ret = xmlStrcat(ret, val);
            xmlFree(val);
        }
        }
        cur++;
        str = cur;
    } else if (*cur == '}') {
        cur++;
        if (*cur == '}') {  /* escaped '}' */
        ret = xmlStrncat(ret, str, cur - str);
        cur++;
        str = cur;
        continue;
        } else {
            xsltTransformError(ctxt, NULL, inst,
             "xsltAttrTemplateValueProcessNode: unmatched '}'\n");
        }
    } else
        cur++;
    }
    if (cur != str) {
    ret = xmlStrncat(ret, str, cur - str);
    }
 
exit:
    if (nsList != NULL)
    xmlFree(nsList);
 
    return(ret);
}

Referenced by xsltAttrTemplateValueProcess(), and xsltEvalAttrValueTemplate().

xsltEvalAttrValueTemplate()

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

Definition at line 392 of file templates.c.

{
    xmlChar *ret;
    xmlChar *expr;
 
    if ((ctxt == NULL) || (inst == NULL) || (name == NULL) ||
        (inst->type != XML_ELEMENT_NODE))
    return(NULL);
 
    expr = xsltGetNsProp(inst, name, ns);
    if (expr == NULL)
    return(NULL);
 
    /*
     * TODO: though now {} is detected ahead, it would still be good to
     *       optimize both functions to keep the splitted value if the
     *       attribute content and the XPath precompiled expressions around
     */
 
    ret = xsltAttrTemplateValueProcessNode(ctxt, expr, inst);
#ifdef WITH_XSLT_DEBUG_TEMPLATES
    XSLT_TRACE(ctxt,XSLT_TRACE_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
     "xsltEvalAttrValueTemplate: %s returns %s\n", expr, ret));
#endif
    if (expr != NULL)
    xmlFree(expr);
    return(ret);
}

Referenced by xsltAttribute(), xsltDefaultSortFunction(), xsltDocumentElem(), xsltElement(), xsltNumberFormat(), and xsltProcessingInstruction().

xsltEvalStaticAttrValueTemplate()

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

Definition at line 438 of file templates.c.

                                                                {
    const xmlChar *ret;
    xmlChar *expr;
 
    if ((style == NULL) || (inst == NULL) || (name == NULL) ||
        (inst->type != XML_ELEMENT_NODE))
    return(NULL);
 
    expr = xsltGetNsProp(inst, name, ns);
    if (expr == NULL) {
    *found = 0;
    return(NULL);
    }
    *found = 1;
 
    ret = xmlStrchr(expr, '{');
    if (ret != NULL) {
    xmlFree(expr);
    return(NULL);
    }
    ret = xmlDictLookup(style->dict, expr, -1);
    xmlFree(expr);
    return(ret);
}

Referenced by xsltAttributeComp(), xsltDocumentComp(), xsltElementComp(), xsltNumberComp(), xsltProcessingInstructionComp(), and xsltSortComp().

xsltEvalTemplateString()

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

xsltEvalTemplateString: @ctxt: the XSLT transformation context @contextNode: the current node in the source tree @inst: the XSLT instruction (xsl:comment, xsl:processing-instruction)

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.

Returns the computed string value or NULL; it's up to the caller to free the result.

Definition at line 189 of file templates.c.

{
    xmlNodePtr oldInsert, insert = NULL;
    xmlChar *ret;
    const xmlChar *oldLastText;
    int oldLastTextSize, oldLastTextUse;
 
    if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL) ||
        (inst->type != XML_ELEMENT_NODE))
    return(NULL);
 
    if (inst->children == NULL)
    return(NULL);
 
    /*
    * This creates a temporary element-node to add the resulting
    * text content to.
    * OPTIMIZE TODO: Keep such an element-node in the transformation
    *  context to avoid creating it every time.
    */
    insert = xmlNewDocNode(ctxt->output, NULL,
                       (const xmlChar *)"fake", NULL);
    if (insert == NULL) {
    xsltTransformError(ctxt, NULL, contextNode,
        "Failed to create temporary node\n");
    return(NULL);
    }
    oldInsert = ctxt->insert;
    ctxt->insert = insert;
    oldLastText = ctxt->lasttext;
    oldLastTextSize = ctxt->lasttsize;
    oldLastTextUse = ctxt->lasttuse;
    /*
    * OPTIMIZE TODO: if inst->children consists only of text-nodes.
    */
    xsltApplyOneTemplate(ctxt, contextNode, inst->children, NULL, NULL);
 
    ctxt->insert = oldInsert;
    ctxt->lasttext = oldLastText;
    ctxt->lasttsize = oldLastTextSize;
    ctxt->lasttuse = oldLastTextUse;
 
    ret = xmlNodeGetContent(insert);
    if (insert != NULL)
    xmlFreeNode(insert);
    return(ret);
}

Referenced by xsltAttribute(), xsltComment(), xsltMessage(), and xsltProcessingInstruction().

xsltEvalXPathPredicate()

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

xsltEvalXPathPredicate: @ctxt: the XSLT transformation context @comp: the XPath compiled expression @nsList: the namespaces in scope @nsNr: the number of namespaces in scope

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

Returns 1 is the predicate was true, 0 otherwise

Definition at line 39 of file templates.c.

                                           {
    int ret;
    xmlXPathObjectPtr res;
    int oldNsNr;
    xmlNsPtr *oldNamespaces;
    xmlNodePtr oldInst;
    int oldProximityPosition, oldContextSize;
 
    if ((ctxt == NULL) || (ctxt->inst == NULL)) {
        xsltTransformError(ctxt, NULL, NULL,
            "xsltEvalXPathPredicate: No context or instruction\n");
        return(0);
    }
 
    oldContextSize = ctxt->xpathCtxt->contextSize;
    oldProximityPosition = ctxt->xpathCtxt->proximityPosition;
    oldNsNr = ctxt->xpathCtxt->nsNr;
    oldNamespaces = ctxt->xpathCtxt->namespaces;
    oldInst = ctxt->inst;
 
    ctxt->xpathCtxt->node = ctxt->node;
    ctxt->xpathCtxt->namespaces = nsList;
    ctxt->xpathCtxt->nsNr = nsNr;
 
    res = xmlXPathCompiledEval(comp, ctxt->xpathCtxt);
 
    if (res != NULL) {
    ret = xmlXPathEvalPredicate(ctxt->xpathCtxt, res);
    xmlXPathFreeObject(res);
#ifdef WITH_XSLT_DEBUG_TEMPLATES
    XSLT_TRACE(ctxt,XSLT_TRACE_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
         "xsltEvalXPathPredicate: returns %d\n", ret));
#endif
    } else {
#ifdef WITH_XSLT_DEBUG_TEMPLATES
    XSLT_TRACE(ctxt,XSLT_TRACE_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
         "xsltEvalXPathPredicate: failed\n"));
#endif
    ctxt->state = XSLT_STATE_STOPPED;
    ret = 0;
    }
    ctxt->xpathCtxt->nsNr = oldNsNr;
 
    ctxt->xpathCtxt->namespaces = oldNamespaces;
    ctxt->inst = oldInst;
    ctxt->xpathCtxt->contextSize = oldContextSize;
    ctxt->xpathCtxt->proximityPosition = oldProximityPosition;
 
    return(ret);
}

Referenced by xsltTestPredicateMatch().

xsltEvalXPathString()

XSLTPUBFUN xmlChar *XSLTCALL xsltEvalXPathString	(	xsltTransformContextPtr	ctxt,
		xmlXPathCompExprPtr	comp
	)

xsltEvalXPathString: @ctxt: the XSLT transformation context @comp: the compiled XPath expression

Process the expression using XPath and get a string

Returns the computed string value or NULL, must be deallocated by the caller.

Definition at line 171 of file templates.c.

                                                                            {
    return(xsltEvalXPathStringNs(ctxt, comp, 0, NULL));
}

Referenced by xsltDocumentElem().

xsltEvalXPathStringNs()

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

xsltEvalXPathStringNs: @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

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

Returns the computed string value or NULL, must be deallocated by the caller.

Definition at line 105 of file templates.c.

                                              {
    xmlChar *ret = NULL;
    xmlXPathObjectPtr res;
    xmlNodePtr oldInst;
    xmlNodePtr oldNode;
    int oldPos, oldSize;
    int oldNsNr;
    xmlNsPtr *oldNamespaces;
 
    if ((ctxt == NULL) || (ctxt->inst == NULL)) {
        xsltTransformError(ctxt, NULL, NULL,
            "xsltEvalXPathStringNs: No context or instruction\n");
        return(0);
    }
 
    oldInst = ctxt->inst;
    oldNode = ctxt->node;
    oldPos = ctxt->xpathCtxt->proximityPosition;
    oldSize = ctxt->xpathCtxt->contextSize;
    oldNsNr = ctxt->xpathCtxt->nsNr;
    oldNamespaces = ctxt->xpathCtxt->namespaces;
 
    ctxt->xpathCtxt->node = ctxt->node;
    /* TODO: do we need to propagate the namespaces here ? */
    ctxt->xpathCtxt->namespaces = nsList;
    ctxt->xpathCtxt->nsNr = nsNr;
    res = xmlXPathCompiledEval(comp, ctxt->xpathCtxt);
    if (res != NULL) {
    if (res->type != XPATH_STRING)
        res = xmlXPathConvertString(res);
    if (res->type == XPATH_STRING) {
            ret = res->stringval;
        res->stringval = NULL;
    } else {
        xsltTransformError(ctxt, NULL, NULL,
         "xpath : string() function didn't return a String\n");
    }
    xmlXPathFreeObject(res);
    } else {
    ctxt->state = XSLT_STATE_STOPPED;
    }
#ifdef WITH_XSLT_DEBUG_TEMPLATES
    XSLT_TRACE(ctxt,XSLT_TRACE_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
     "xsltEvalXPathString: returns %s\n", ret));
#endif
    ctxt->inst = oldInst;
    ctxt->node = oldNode;
    ctxt->xpathCtxt->contextSize = oldSize;
    ctxt->xpathCtxt->proximityPosition = oldPos;
    ctxt->xpathCtxt->nsNr = oldNsNr;
    ctxt->xpathCtxt->namespaces = oldNamespaces;
    return(ret);
}

Referenced by xsltAttrTemplateValueProcessNode(), xsltEvalAVT(), and xsltEvalXPathString().

xsltTemplateProcess()

XSLTPUBFUN xmlNodePtr *XSLTCALL xsltTemplateProcess	(	xsltTransformContextPtr ctxt	ATTRIBUTE_UNUSED,
		xmlNodePtr	node
	)

xsltTemplateProcess: @ctxt: the XSLT transformation context @node: the attribute template node

Obsolete. Don't use it.

Returns NULL.

Definition at line 847 of file templates.c.

                                                                                    {
    if (node == NULL)
    return(NULL);
 
    return(0);
}