transform.h File Reference

#include <libxml/parser.h>
#include <libxml/xmlIO.h>
#include "xsltexports.h"
#include <libxslt/xsltInternals.h>

Include dependency graph for transform.h:

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

Go to the source code of this file.

Functions
XSLTPUBFUN void XSLTCALL	xsltSetXIncludeDefault (int xinclude)
XSLTPUBFUN int XSLTCALL	xsltGetXIncludeDefault (void)
XSLTPUBFUN xsltTransformContextPtr XSLTCALL	xsltNewTransformContext (xsltStylesheetPtr style, xmlDocPtr doc)
XSLTPUBFUN void XSLTCALL	xsltFreeTransformContext (xsltTransformContextPtr ctxt)
XSLTPUBFUN xmlDocPtr XSLTCALL	xsltApplyStylesheetUser (xsltStylesheetPtr style, xmlDocPtr doc, const char **params, const char *output, FILE *profile, xsltTransformContextPtr userCtxt)
XSLTPUBFUN void XSLTCALL	xsltProcessOneNode (xsltTransformContextPtr ctxt, xmlNodePtr node, xsltStackElemPtr params)
XSLTPUBFUN void XSLTCALL	xsltApplyStripSpaces (xsltTransformContextPtr ctxt, xmlNodePtr node)
XSLTPUBFUN xmlDocPtr XSLTCALL	xsltApplyStylesheet (xsltStylesheetPtr style, xmlDocPtr doc, const char **params)
XSLTPUBFUN xmlDocPtr XSLTCALL	xsltProfileStylesheet (xsltStylesheetPtr style, xmlDocPtr doc, const char **params, FILE *output)
XSLTPUBFUN int XSLTCALL	xsltRunStylesheet (xsltStylesheetPtr style, xmlDocPtr doc, const char **params, const char *output, xmlSAXHandlerPtr SAX, xmlOutputBufferPtr IObuf)
XSLTPUBFUN int XSLTCALL	xsltRunStylesheetUser (xsltStylesheetPtr style, xmlDocPtr doc, const char **params, const char *output, xmlSAXHandlerPtr SAX, xmlOutputBufferPtr IObuf, FILE *profile, xsltTransformContextPtr userCtxt)
XSLTPUBFUN void XSLTCALL	xsltApplyOneTemplate (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr list, xsltTemplatePtr templ, xsltStackElemPtr params)
XSLTPUBFUN void XSLTCALL	xsltDocumentElem (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltSort (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltCopy (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltText (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltElement (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltComment (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltAttribute (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltProcessingInstruction (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltCopyOf (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltValueOf (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltNumber (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltApplyImports (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltCallTemplate (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltApplyTemplates (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltChoose (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltIf (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltForEach (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
XSLTPUBFUN void XSLTCALL	xsltRegisterAllElement (xsltTransformContextPtr ctxt)
XSLTPUBFUN xmlNodePtr XSLTCALL	xsltCopyTextString (xsltTransformContextPtr ctxt, xmlNodePtr target, const xmlChar *string, int noescape)
XSLTPUBFUN void XSLTCALL	xsltLocalVariablePop (xsltTransformContextPtr ctxt, int limitNr, int level)
XSLTPUBFUN int XSLTCALL	xsltLocalVariablePush (xsltTransformContextPtr ctxt, xsltStackElemPtr variable, int level)
XSLTPUBFUN void XSLTCALL	xslHandleDebugger (xmlNodePtr cur, xmlNodePtr node, xsltTemplatePtr templ, xsltTransformContextPtr ctxt)

Function Documentation

xslHandleDebugger()

XSLTPUBFUN void XSLTCALL xslHandleDebugger	(	xmlNodePtr	cur,
		xmlNodePtr	node,
		xsltTemplatePtr	templ,
		xsltTransformContextPtr	ctxt
	)

Referenced by xsltApplyAttributeSet(), xsltApplySequenceConstructor(), xsltApplyTemplates(), xsltAttribute(), xsltCallTemplate(), xsltChoose(), xsltEvalGlobalVariable(), and xsltForEach().

xsltApplyImports()

XSLTPUBFUN void XSLTCALL xsltApplyImports	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	contextNode,
		xmlNodePtr	inst,
		xsltElemPreCompPtr comp	ATTRIBUTE_UNUSED
	)

xsltApplyImports: @ctxt: an XSLT transformation context @contextNode: the current node in the source tree. @inst: the element node of the XSLT 'apply-imports' instruction @comp: the compiled instruction

Process the XSLT apply-imports element.

Definition at line 4650 of file transform.c.

{
    xsltTemplatePtr templ;
 
    if ((ctxt == NULL) || (inst == NULL))
    return;
 
    if (comp == NULL) {
    xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltApplyImports(): "
        "The XSLT 'apply-imports' instruction was not compiled.\n");
    return;
    }
    /*
    * NOTE that ctxt->currentTemplateRule and ctxt->templ is not the
    * same; the former is the "Current Template Rule" as defined by the
    * XSLT spec, the latter is simply the template struct being
    * currently processed.
    */
    if (ctxt->currentTemplateRule == NULL) {
    /*
    * SPEC XSLT 2.0:
    * "[ERR XTDE0560] It is a non-recoverable dynamic error if
    *  xsl:apply-imports or xsl:next-match is evaluated when the
    *  current template rule is null."
    */
    xsltTransformError(ctxt, NULL, inst,
         "It is an error to call 'apply-imports' "
         "when there's no current template rule.\n");
    return;
    }
    /*
    * TODO: Check if this is correct.
    */
    templ = xsltGetTemplate(ctxt, contextNode,
    ctxt->currentTemplateRule->style);
 
    if (templ != NULL) {
    xsltTemplatePtr oldCurTemplRule = ctxt->currentTemplateRule;
    /*
    * Set the current template rule.
    */
    ctxt->currentTemplateRule = templ;
    /*
    * URGENT TODO: Need xsl:with-param be handled somehow here?
    */
    xsltApplyXSLTTemplate(ctxt, contextNode, templ->content,
        templ, NULL);
 
    ctxt->currentTemplateRule = oldCurTemplRule;
    }
    else {
        /* Use built-in templates. */
        xsltDefaultProcessOneNode(ctxt, contextNode, NULL);
    }
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltApplyOneTemplate()

XSLTPUBFUN void XSLTCALL xsltApplyOneTemplate	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	contextNode,
		xmlNodePtr	list,
		xsltTemplatePtr templ	ATTRIBUTE_UNUSED,
		xsltStackElemPtr	params
	)

xsltApplyOneTemplate: @ctxt: a XSLT process context @contextNode: the node in the source tree. @list: the nodes of a sequence constructor @templ: not used @params: a set of parameters (xsl:param) or NULL

Processes a sequence constructor on the current node in the source tree.

@params are the already computed variable stack items; this function pushes them on the variable stack, and pops them before exiting; it's left to the caller to free or reuse @params afterwards. The initial states of the variable stack will always be restored before this function exits. NOTE that this does not initiate a new distinct variable scope; i.e. variables already on the stack are visible to the process. The caller's side needs to start a new variable scope if needed (e.g. in exsl:function).

@templ is obsolete and not used anymore (e.g. <exslt:function> does not provide a @templ); a non-NULL @templ might raise an error in the future.

BIG NOTE: This function is not intended to process the content of an xsl:template; it does not expect xsl:param instructions in @list and will report errors if found.

Called by:

• xsltEvalVariable() (variables.c)
• exsltFuncFunctionFunction() (libexsl/functions.c)

Definition at line 3313 of file transform.c.

{
    if ((ctxt == NULL) || (list == NULL))
    return;
    CHECK_STOPPED;
 
    if (params) {
    /*
     * This code should be obsolete - was previously used
     * by libexslt/functions.c, but due to bug 381319 the
     * logic there was changed.
     */
    int oldVarsNr = ctxt->varsNr;
 
    /*
    * Push the given xsl:param(s) onto the variable stack.
    */
    while (params != NULL) {
        xsltLocalVariablePush(ctxt, params, -1);
        params = params->next;
    }
    xsltApplySequenceConstructor(ctxt, contextNode, list, templ);
    /*
    * Pop the given xsl:param(s) from the stack but don't free them.
    */
    xsltLocalVariablePop(ctxt, oldVarsNr, -2);
    } else
    xsltApplySequenceConstructor(ctxt, contextNode, list, templ);
}

Referenced by xsltEvalGlobalVariable(), xsltEvalTemplateString(), and xsltEvalVariable().

xsltApplyStripSpaces()

XSLTPUBFUN void XSLTCALL xsltApplyStripSpaces	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node
	)

Private Interfaces.

xsltApplyStripSpaces: @ctxt: a XSLT process context @node: the root of the XML tree

Strip the unwanted ignorable spaces from the input tree

Definition at line 5649 of file transform.c.

                                                                    {
    xmlNodePtr current;
#ifdef WITH_XSLT_DEBUG_PROCESS
    int nb = 0;
#endif
 
 
    current = node;
    while (current != NULL) {
    /*
     * Cleanup children empty nodes if asked for
     */
    if ((IS_XSLT_REAL_NODE(current)) &&
        (current->children != NULL) &&
        (xsltFindElemSpaceHandling(ctxt, current))) {
        xmlNodePtr delete = NULL, cur = current->children;
 
        while (cur != NULL) {
        if (IS_BLANK_NODE(cur))
            delete = cur;
 
        cur = cur->next;
        if (delete != NULL) {
            xmlUnlinkNode(delete);
            xmlFreeNode(delete);
            delete = NULL;
#ifdef WITH_XSLT_DEBUG_PROCESS
            nb++;
#endif
        }
        }
    }
 
    /*
     * Skip to next node in document order.
     */
    if (node->type == XML_ENTITY_REF_NODE) {
        /* process deep in entities */
        xsltApplyStripSpaces(ctxt, node->children);
    }
    if ((current->children != NULL) &&
            (current->type != XML_ENTITY_REF_NODE)) {
        current = current->children;
    } else if (current->next != NULL) {
        current = current->next;
    } else {
        do {
        current = current->parent;
        if (current == NULL)
            break;
        if (current == node)
            goto done;
        if (current->next != NULL) {
            current = current->next;
            break;
        }
        } while (current != NULL);
    }
    }
 
done:
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_STRIP_SPACES,xsltGenericDebug(xsltGenericDebugContext,
         "xsltApplyStripSpaces: removed %d ignorable blank node\n", nb));
#endif
    return;
}

Referenced by xsltApplyStripSpaces(), xsltApplyStylesheetInternal(), and xsltLoadDocument().

xsltApplyStylesheet()

XSLTPUBFUN xmlDocPtr XSLTCALL xsltApplyStylesheet	(	xsltStylesheetPtr	style,
		xmlDocPtr	doc,
		const char **	params
	)

xsltApplyStylesheet: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated arry of parameters names/values tuples

Apply the stylesheet to the document NOTE: This may lead to a non-wellformed output XML wise !

Returns the result document or NULL in case of error

Definition at line 6230 of file transform.c.

{
    return (xsltApplyStylesheetInternal(style, doc, params, NULL, NULL, NULL));
}

Referenced by node_transform_node_params().

xsltApplyStylesheetUser()

XSLTPUBFUN xmlDocPtr XSLTCALL xsltApplyStylesheetUser	(	xsltStylesheetPtr	style,
		xmlDocPtr	doc,
		const char **	params,
		const char *	output,
		FILE *	profile,
		xsltTransformContextPtr	userCtxt
	)

xsltApplyStylesheetUser: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated array of parameters names/values tuples @output: the targetted output @profile: profile FILE * output or NULL @userCtxt: user provided transform context

Apply the stylesheet to the document and allow the user to provide its own transformation context.

Returns the result document or NULL in case of error

Definition at line 6273 of file transform.c.

{
    xmlDocPtr res;
 
    res = xsltApplyStylesheetInternal(style, doc, params, output,
                                  profile, userCtxt);
    return (res);
}

Referenced by node_transform_node_params().

xsltApplyTemplates()

XSLTPUBFUN void XSLTCALL xsltApplyTemplates	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltApplyTemplates: @ctxt: a XSLT transformation context @node: the 'current node' in the source tree @inst: the element node of an XSLT 'apply-templates' instruction @castedComp: the compiled instruction

Processes the XSLT 'apply-templates' instruction on the current node.

Definition at line 4822 of file transform.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemApplyTemplatesPtr comp =
    (xsltStyleItemApplyTemplatesPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    int i;
    xmlNodePtr cur, oldContextNode;
    xmlNodeSetPtr list = NULL, oldList;
    xsltStackElemPtr withParams = NULL;
    int oldXPProximityPosition, oldXPContextSize;
    const xmlChar *oldMode, *oldModeURI;
    xmlDocPtr oldXPDoc;
    xsltDocumentPtr oldDocInfo;
    xmlXPathContextPtr xpctxt;
 
    if (comp == NULL) {
    xsltTransformError(ctxt, NULL, inst,
         "xsl:apply-templates : compilation failed\n");
    return;
    }
    if ((ctxt == NULL) || (node == NULL) || (inst == NULL) || (comp == NULL))
    return;
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    if ((node != NULL) && (node->name != NULL))
    XSLT_TRACE(ctxt,XSLT_TRACE_APPLY_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
         "xsltApplyTemplates: node: '%s'\n", node->name));
#endif
 
    xpctxt = ctxt->xpathCtxt;
    /*
    * Save context states.
    */
    oldContextNode = ctxt->node;
    oldMode = ctxt->mode;
    oldModeURI = ctxt->modeURI;
    oldDocInfo = ctxt->document;
    oldList = ctxt->nodeList;
 
    /*
     * The xpath context size and proximity position, as
     * well as the xpath and context documents, may be changed
     * so we save their initial state and will restore on exit
     */
    oldXPContextSize = xpctxt->contextSize;
    oldXPProximityPosition = xpctxt->proximityPosition;
    oldXPDoc = xpctxt->doc;
 
    /*
    * Set up contexts.
    */
    ctxt->mode = comp->mode;
    ctxt->modeURI = comp->modeURI;
 
    if (comp->select != NULL) {
    xmlXPathObjectPtr res = NULL;
 
    if (comp->comp == NULL) {
        xsltTransformError(ctxt, NULL, inst,
         "xsl:apply-templates : compilation failed\n");
        goto error;
    }
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_APPLY_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
         "xsltApplyTemplates: select %s\n", comp->select));
#endif
 
    res = xsltPreCompEval(ctxt, node, comp);
 
    if (res != NULL) {
        if (res->type == XPATH_NODESET) {
        list = res->nodesetval; /* consume the node set */
        res->nodesetval = NULL;
        } else {
        xsltTransformError(ctxt, NULL, inst,
            "The 'select' expression did not evaluate to a "
            "node set.\n");
        ctxt->state = XSLT_STATE_STOPPED;
        xmlXPathFreeObject(res);
        goto error;
        }
        xmlXPathFreeObject(res);
        /*
        * Note: An xsl:apply-templates with a 'select' attribute,
        * can change the current source doc.
        */
    } else {
        xsltTransformError(ctxt, NULL, inst,
        "Failed to evaluate the 'select' expression.\n");
        ctxt->state = XSLT_STATE_STOPPED;
        goto error;
    }
    if (list == NULL) {
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_APPLY_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
        "xsltApplyTemplates: select didn't evaluate to a node list\n"));
#endif
        goto exit;
    }
    /*
    *
    * NOTE: Previously a document info (xsltDocument) was
    * created and attached to the Result Tree Fragment.
    * But such a document info is created on demand in
    * xsltKeyFunction() (functions.c), so we need to create
    * it here beforehand.
    * In order to take care of potential keys we need to
    * do some extra work for the case when a Result Tree Fragment
    * is converted into a nodeset (e.g. exslt:node-set()) :
    * We attach a "pseudo-doc" (xsltDocument) to _private.
    * This xsltDocument, together with the keyset, will be freed
    * when the Result Tree Fragment is freed.
    *
    */
#if 0
    if ((ctxt->nbKeys > 0) &&
        (list->nodeNr != 0) &&
        (list->nodeTab[0]->doc != NULL) &&
        XSLT_IS_RES_TREE_FRAG(list->nodeTab[0]->doc))
    {
        /*
        * NOTE that it's also OK if @effectiveDocInfo will be
        * set to NULL.
        */
        isRTF = 1;
        effectiveDocInfo = list->nodeTab[0]->doc->_private;
    }
#endif
    } else {
    /*
     * Build an XPath node set with the children
     */
    list = xmlXPathNodeSetCreate(NULL);
    if (list == NULL)
        goto error;
    if (node->type != XML_NAMESPACE_DECL)
        cur = node->children;
    else
        cur = NULL;
    while (cur != NULL) {
            if (IS_XSLT_REAL_NODE(cur))
        xmlXPathNodeSetAddUnique(list, cur);
        cur = cur->next;
    }
    }
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    if (list != NULL)
    XSLT_TRACE(ctxt,XSLT_TRACE_APPLY_TEMPLATES,xsltGenericDebug(xsltGenericDebugContext,
    "xsltApplyTemplates: list of %d nodes\n", list->nodeNr));
#endif
 
    if ((list == NULL) || (list->nodeNr == 0))
    goto exit;
 
    /*
    * Set the context's node set and size; this is also needed for
    * for xsltDoSortFunction().
    */
    ctxt->nodeList = list;
    /*
    * Process xsl:with-param and xsl:sort instructions.
    * (The code became so verbose just to avoid the
    *  xmlNodePtr sorts[XSLT_MAX_SORT] if there's no xsl:sort)
    * BUG TODO: We are not using namespaced potentially defined on the
    * xsl:sort or xsl:with-param elements; XPath expression might fail.
    */
    if (inst->children) {
    xsltStackElemPtr param;
 
    cur = inst->children;
    while (cur) {
 
#ifdef WITH_DEBUGGER
        if (ctxt->debugStatus != XSLT_DEBUG_NONE)
        xslHandleDebugger(cur, node, NULL, ctxt);
#endif
        if (ctxt->state == XSLT_STATE_STOPPED)
        break;
        if (cur->type == XML_TEXT_NODE) {
        cur = cur->next;
        continue;
        }
        if (! IS_XSLT_ELEM(cur))
        break;
        if (IS_XSLT_NAME(cur, "with-param")) {
        param = xsltParseStylesheetCallerParam(ctxt, cur);
        if (param != NULL) {
            param->next = withParams;
            withParams = param;
        }
        }
        if (IS_XSLT_NAME(cur, "sort")) {
        xsltTemplatePtr oldCurTempRule =
            ctxt->currentTemplateRule;
        int nbsorts = 0;
        xmlNodePtr sorts[XSLT_MAX_SORT];
 
        sorts[nbsorts++] = cur;
        cur = cur->next;
 
        while (cur) {
 
#ifdef WITH_DEBUGGER
            if (ctxt->debugStatus != XSLT_DEBUG_NONE)
            xslHandleDebugger(cur, node, NULL, ctxt);
#endif
            if (ctxt->state == XSLT_STATE_STOPPED)
            break;
 
            if (cur->type == XML_TEXT_NODE) {
            cur = cur->next;
            continue;
            }
 
            if (! IS_XSLT_ELEM(cur))
            break;
            if (IS_XSLT_NAME(cur, "with-param")) {
            param = xsltParseStylesheetCallerParam(ctxt, cur);
            if (param != NULL) {
                param->next = withParams;
                withParams = param;
            }
            }
            if (IS_XSLT_NAME(cur, "sort")) {
            if (nbsorts >= XSLT_MAX_SORT) {
                xsltTransformError(ctxt, NULL, cur,
                "The number (%d) of xsl:sort instructions exceeds the "
                "maximum allowed by this processor's settings.\n",
                nbsorts);
                ctxt->state = XSLT_STATE_STOPPED;
                break;
            } else {
                sorts[nbsorts++] = cur;
            }
            }
            cur = cur->next;
        }
        /*
        * The "current template rule" is cleared for xsl:sort.
        */
        ctxt->currentTemplateRule = NULL;
        /*
        * Sort.
        */
        xsltDoSortFunction(ctxt, sorts, nbsorts);
        ctxt->currentTemplateRule = oldCurTempRule;
        break;
        }
        cur = cur->next;
    }
    }
    xpctxt->contextSize = list->nodeNr;
    /*
    * Apply templates for all selected source nodes.
    */
    for (i = 0; i < list->nodeNr; i++) {
    cur = list->nodeTab[i];
    /*
    * The node becomes the "current node".
    */
    ctxt->node = cur;
    /*
    * An xsl:apply-templates can change the current context doc.
    * OPTIMIZE TODO: Get rid of the need to set the context doc.
    */
    if ((cur->type != XML_NAMESPACE_DECL) && (cur->doc != NULL))
        xpctxt->doc = cur->doc;
 
    xpctxt->proximityPosition = i + 1;
    /*
    * Find and apply a template for this node.
    */
    xsltProcessOneNode(ctxt, cur, withParams);
    }
 
exit:
error:
    /*
    * Free the parameter list.
    */
    if (withParams != NULL)
    xsltFreeStackElemList(withParams);
    if (list != NULL)
    xmlXPathFreeNodeSet(list);
    /*
    * Restore context states.
    */
    xpctxt->doc = oldXPDoc;
    xpctxt->contextSize = oldXPContextSize;
    xpctxt->proximityPosition = oldXPProximityPosition;
 
    ctxt->document = oldDocInfo;
    ctxt->nodeList = oldList;
    ctxt->node = oldContextNode;
    ctxt->mode = oldMode;
    ctxt->modeURI = oldModeURI;
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltAttribute()

XSLTPUBFUN void XSLTCALL xsltAttribute	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	contextNode,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltAttribute: @ctxt: a XSLT process context @contextNode: the current node in the source tree @inst: the xsl:attribute element @castedComp: precomputed information

Process the xslt attribute node on the source node

Definition at line 748 of file attributes.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemAttributePtr comp =
    (xsltStyleItemAttributePtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    xmlNodePtr targetElem;
    xmlChar *prop = NULL;
    const xmlChar *name = NULL, *prefix = NULL, *nsName = NULL;
    xmlChar *value = NULL;
    xmlNsPtr ns = NULL;
    xmlAttrPtr attr;
 
    if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL) ||
        (inst->type != XML_ELEMENT_NODE) )
        return;
 
    /*
    * A comp->has_name == 0 indicates that we need to skip this instruction,
    * since it was evaluated to be invalid already during compilation.
    */
    if (!comp->has_name)
        return;
    /*
    * BIG NOTE: This previously used xsltGetSpecialNamespace() and
    *  xsltGetNamespace(), but since both are not appropriate, we
    *  will process namespace lookup here to avoid adding yet another
    *  ns-lookup function to namespaces.c.
    */
    /*
    * SPEC XSLT 1.0: Error cases:
    * - Creating nodes other than text nodes during the instantiation of
    *   the content of the xsl:attribute element; implementations may
    *   either signal the error or ignore the offending nodes."
    */
 
    if (comp == NULL) {
        xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltAttribute(): "
        "The XSLT 'attribute' instruction was not compiled.\n");
        return;
    }
    /*
    * TODO: Shouldn't ctxt->insert == NULL be treated as an internal error?
    *   So report an internal error?
    */
    if (ctxt->insert == NULL)
        return;
    /*
    * SPEC XSLT 1.0:
    *  "Adding an attribute to a node that is not an element;
    *  implementations may either signal the error or ignore the attribute."
    *
    * TODO: I think we should signal such errors in the future, and maybe
    *  provide an option to ignore such errors.
    */
    targetElem = ctxt->insert;
    if (targetElem->type != XML_ELEMENT_NODE)
    return;
 
    /*
    * SPEC XSLT 1.0:
    * "Adding an attribute to an element after children have been added
    *  to it; implementations may either signal the error or ignore the
    *  attribute."
    *
    * TODO: We should decide whether not to report such errors or
    *  to ignore them; note that we *ignore* if the parent is not an
    *  element, but here we report an error.
    */
    if (targetElem->children != NULL) {
    /*
    * NOTE: Ah! This seems to be intended to support streamed
    *  result generation!.
    */
        xsltTransformError(ctxt, NULL, inst,
        "xsl:attribute: Cannot add attributes to an "
        "element if children have been already added "
        "to the element.\n");
        return;
    }
 
    /*
    * Process the name
    * ----------------
    */
 
#ifdef WITH_DEBUGGER
    if (ctxt->debugStatus != XSLT_DEBUG_NONE)
        xslHandleDebugger(inst, contextNode, NULL, ctxt);
#endif
 
    if (comp->name == NULL) {
    /* TODO: fix attr acquisition wrt to the XSLT namespace */
        prop = xsltEvalAttrValueTemplate(ctxt, inst,
        (const xmlChar *) "name", XSLT_NAMESPACE);
        if (prop == NULL) {
            xsltTransformError(ctxt, NULL, inst,
        "xsl:attribute: The attribute 'name' is missing.\n");
            goto error;
        }
    if (xmlValidateQName(prop, 0)) {
        xsltTransformError(ctxt, NULL, inst,
        "xsl:attribute: The effective name '%s' is not a "
        "valid QName.\n", prop);
        /* we fall through to catch any further errors, if possible */
    }
 
    /*
    * Reject a name of "xmlns".
    */
    if (xmlStrEqual(prop, BAD_CAST "xmlns")) {
            xsltTransformError(ctxt, NULL, inst,
                "xsl:attribute: The effective name 'xmlns' is not allowed.\n");
        xmlFree(prop);
        goto error;
    }
 
    name = xsltSplitQName(ctxt->dict, prop, &prefix);
    xmlFree(prop);
    } else {
    /*
    * The "name" value was static.
    */
#ifdef XSLT_REFACTORED
    prefix = comp->nsPrefix;
    name = comp->name;
#else
    name = xsltSplitQName(ctxt->dict, comp->name, &prefix);
#endif
    }
 
    /*
    * Process namespace semantics
    * ---------------------------
    *
    * Evaluate the namespace name.
    */
    if (comp->has_ns) {
    /*
    * The "namespace" attribute was existent.
    */
    if (comp->ns != NULL) {
        /*
        * No AVT; just plain text for the namespace name.
        */
        if (comp->ns[0] != 0)
        nsName = comp->ns;
    } else {
        xmlChar *tmpNsName;
        /*
        * Eval the AVT.
        */
        /* TODO: check attr acquisition wrt to the XSLT namespace */
        tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
        (const xmlChar *) "namespace", XSLT_NAMESPACE);
        /*
        * This fixes bug #302020: The AVT might also evaluate to the
        * empty string; this means that the empty string also indicates
        * "no namespace".
        * SPEC XSLT 1.0:
        *  "If the string is empty, then the expanded-name of the
        *  attribute has a null namespace URI."
        */
        if ((tmpNsName != NULL) && (tmpNsName[0] != 0))
        nsName = xmlDictLookup(ctxt->dict, BAD_CAST tmpNsName, -1);
        xmlFree(tmpNsName);
    }
 
        if (xmlStrEqual(nsName, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
            xsltTransformError(ctxt, NULL, inst,
                "xsl:attribute: Namespace http://www.w3.org/2000/xmlns/ "
                "forbidden.\n");
            goto error;
        }
        if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) {
            prefix = BAD_CAST "xml";
        } else if (xmlStrEqual(prefix, BAD_CAST "xml")) {
            prefix = NULL;
        }
    } else if (prefix != NULL) {
    /*
    * SPEC XSLT 1.0:
    *  "If the namespace attribute is not present, then the QName is
    *  expanded into an expanded-name using the namespace declarations
    *  in effect for the xsl:attribute element, *not* including any
    *  default namespace declaration."
    */
    ns = xmlSearchNs(inst->doc, inst, prefix);
    if (ns == NULL) {
        /*
        * Note that this is treated as an error now (checked with
        *  Saxon, Xalan-J and MSXML).
        */
        xsltTransformError(ctxt, NULL, inst,
        "xsl:attribute: The QName '%s:%s' has no "
        "namespace binding in scope in the stylesheet; "
        "this is an error, since the namespace was not "
        "specified by the instruction itself.\n", prefix, name);
    } else
        nsName = ns->href;
    }
 
    /*
    * Find/create a matching ns-decl in the result tree.
    */
    ns = NULL;
 
#if 0
    if (0) {
    /*
    * OPTIMIZE TODO: How do we know if we are adding to a
    *  fragment or to the result tree?
    *
    * If we are adding to a result tree fragment (i.e., not to the
    * actual result tree), we'll don't bother searching for the
    * ns-decl, but just store it in the dummy-doc of the result
    * tree fragment.
    */
    if (nsName != NULL) {
        /*
        * TODO: Get the doc of @targetElem.
        */
        ns = xsltTreeAcquireStoredNs(some doc, nsName, prefix);
    }
    }
#endif
 
    if (nsName != NULL) {
    /*
    * Something about ns-prefixes:
    * SPEC XSLT 1.0:
    *  "XSLT processors may make use of the prefix of the QName specified
    *  in the name attribute when selecting the prefix used for outputting
    *  the created attribute as XML; however, they are not required to do
    *  so and, if the prefix is xmlns, they must not do so"
    */
    /*
    * xsl:attribute can produce a scenario where the prefix is NULL,
    * so generate a prefix.
    */
    if ((prefix == NULL) || xmlStrEqual(prefix, BAD_CAST "xmlns")) {
        xmlChar *pref = xmlStrdup(BAD_CAST "ns_1");
 
        ns = xsltGetSpecialNamespace(ctxt, inst, nsName, pref, targetElem);
 
        xmlFree(pref);
    } else {
        ns = xsltGetSpecialNamespace(ctxt, inst, nsName, prefix,
        targetElem);
    }
    if (ns == NULL) {
        xsltTransformError(ctxt, NULL, inst,
        "Namespace fixup error: Failed to acquire an in-scope "
        "namespace binding for the generated attribute '{%s}%s'.\n",
        nsName, name);
        goto error;
    }
    }
    /*
    * Construction of the value
    * -------------------------
    */
    if (inst->children == NULL) {
    /*
    * No content.
    * TODO: Do we need to put the empty string in ?
    */
    attr = xmlSetNsProp(ctxt->insert, ns, name, (const xmlChar *) "");
    } else if ((inst->children->next == NULL) &&
        ((inst->children->type == XML_TEXT_NODE) ||
         (inst->children->type == XML_CDATA_SECTION_NODE)))
    {
    xmlNodePtr copyTxt;
 
    /*
    * xmlSetNsProp() will take care of duplicates.
    */
    attr = xmlSetNsProp(ctxt->insert, ns, name, NULL);
    if (attr == NULL) /* TODO: report error ? */
        goto error;
    /*
    * This was taken over from xsltCopyText() (transform.c).
    */
    if (ctxt->internalized &&
        (ctxt->insert->doc != NULL) &&
        (ctxt->insert->doc->dict == ctxt->dict))
    {
        copyTxt = xmlNewText(NULL);
        if (copyTxt == NULL) /* TODO: report error */
        goto error;
        /*
        * This is a safe scenario where we don't need to lookup
        * the dict.
        */
        copyTxt->content = inst->children->content;
        /*
        * Copy "disable-output-escaping" information.
        * TODO: Does this have any effect for attribute values
        *  anyway?
        */
        if (inst->children->name == xmlStringTextNoenc)
        copyTxt->name = xmlStringTextNoenc;
    } else {
        /*
        * Copy the value.
        */
        copyTxt = xmlNewText(inst->children->content);
        if (copyTxt == NULL) /* TODO: report error */
        goto error;
    }
    attr->children = attr->last = copyTxt;
    copyTxt->parent = (xmlNodePtr) attr;
    copyTxt->doc = attr->doc;
    /*
    * Copy "disable-output-escaping" information.
    * TODO: Does this have any effect for attribute values
    *  anyway?
    */
    if (inst->children->name == xmlStringTextNoenc)
        copyTxt->name = xmlStringTextNoenc;
 
        /*
         * since we create the attribute without content IDness must be
         * asserted as a second step
         */
        if ((copyTxt->content != NULL) &&
            (xmlIsID(attr->doc, attr->parent, attr)))
            xmlAddID(NULL, attr->doc, copyTxt->content, attr);
    } else {
    /*
    * The sequence constructor might be complex, so instantiate it.
    */
    value = xsltEvalTemplateString(ctxt, contextNode, inst);
    if (value != NULL) {
        attr = xmlSetNsProp(ctxt->insert, ns, name, value);
        xmlFree(value);
    } else {
        /*
        * TODO: Do we have to add the empty string to the attr?
        * TODO: Does a  value of NULL indicate an
        *  error in xsltEvalTemplateString() ?
        */
        attr = xmlSetNsProp(ctxt->insert, ns, name,
        (const xmlChar *) "");
    }
    }
 
error:
    return;
}

Referenced by xsltApplyAttributeSet(), xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltCallTemplate()

XSLTPUBFUN void XSLTCALL xsltCallTemplate	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltCallTemplate: @ctxt: a XSLT transformation context @node: the "current node" in the source tree @inst: the XSLT 'call-template' instruction @castedComp: the compiled information of the instruction

Processes the XSLT call-template instruction on the source node.

Definition at line 4719 of file transform.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemCallTemplatePtr comp =
    (xsltStyleItemCallTemplatePtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    xsltStackElemPtr withParams = NULL;
 
    if (ctxt->insert == NULL)
    return;
    if (comp == NULL) {
    xsltTransformError(ctxt, NULL, inst,
         "The XSLT 'call-template' instruction was not compiled.\n");
    return;
    }
 
    /*
     * The template must have been precomputed
     */
    if (comp->templ == NULL) {
    comp->templ = xsltFindTemplate(ctxt, comp->name, comp->ns);
    if (comp->templ == NULL) {
        if (comp->ns != NULL) {
            xsltTransformError(ctxt, NULL, inst,
            "The called template '{%s}%s' was not found.\n",
            comp->ns, comp->name);
        } else {
            xsltTransformError(ctxt, NULL, inst,
            "The called template '%s' was not found.\n",
            comp->name);
        }
        return;
    }
    }
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    if ((comp != NULL) && (comp->name != NULL))
    XSLT_TRACE(ctxt,XSLT_TRACE_CALL_TEMPLATE,xsltGenericDebug(xsltGenericDebugContext,
             "call-template: name %s\n", comp->name));
#endif
 
    if (inst->children) {
    xmlNodePtr cur;
    xsltStackElemPtr param;
 
    cur = inst->children;
    while (cur != NULL) {
#ifdef WITH_DEBUGGER
        if (ctxt->debugStatus != XSLT_DEBUG_NONE)
        xslHandleDebugger(cur, node, comp->templ, ctxt);
#endif
        if (ctxt->state == XSLT_STATE_STOPPED) break;
        /*
        * TODO: The "with-param"s could be part of the "call-template"
        *   structure. Avoid to "search" for params dynamically
        *   in the XML tree every time.
        */
        if (IS_XSLT_ELEM(cur)) {
        if (IS_XSLT_NAME(cur, "with-param")) {
            param = xsltParseStylesheetCallerParam(ctxt, cur);
            if (param != NULL) {
            param->next = withParams;
            withParams = param;
            }
        } else {
            xsltGenericError(xsltGenericErrorContext,
            "xsl:call-template: misplaced xsl:%s\n", cur->name);
        }
        } else {
        xsltGenericError(xsltGenericErrorContext,
            "xsl:call-template: misplaced %s element\n", cur->name);
        }
        cur = cur->next;
    }
    }
    /*
     * Create a new frame using the params first
     */
    xsltApplyXSLTTemplate(ctxt, node, comp->templ->content, comp->templ,
    withParams);
    if (withParams != NULL)
    xsltFreeStackElemList(withParams);
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    if ((comp != NULL) && (comp->name != NULL))
    XSLT_TRACE(ctxt,XSLT_TRACE_CALL_TEMPLATE,xsltGenericDebug(xsltGenericDebugContext,
             "call-template returned: name %s\n", comp->name));
#endif
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltChoose()

XSLTPUBFUN void XSLTCALL xsltChoose	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	contextNode,
		xmlNodePtr	inst,
		xsltElemPreCompPtr comp	ATTRIBUTE_UNUSED
	)

xsltChoose: @ctxt: a XSLT process context @contextNode: the current node in the source tree @inst: the xsl:choose instruction @comp: compiled information of the instruction

Processes the xsl:choose instruction on the source node.

Definition at line 5136 of file transform.c.

{
    xmlNodePtr cur;
 
    if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL))
    return;
 
    /*
    * TODO: Content model checks should be done only at compilation
    * time.
    */
    cur = inst->children;
    if (cur == NULL) {
    xsltTransformError(ctxt, NULL, inst,
        "xsl:choose: The instruction has no content.\n");
    return;
    }
 
#ifdef XSLT_REFACTORED
    /*
    * We don't check the content model during transformation.
    */
#else
    if ((! IS_XSLT_ELEM(cur)) || (! IS_XSLT_NAME(cur, "when"))) {
    xsltTransformError(ctxt, NULL, inst,
         "xsl:choose: xsl:when expected first\n");
    return;
    }
#endif
 
    {
    int testRes = 0, res = 0;
 
#ifdef XSLT_REFACTORED
    xsltStyleItemWhenPtr wcomp = NULL;
#else
    xsltStylePreCompPtr wcomp = NULL;
#endif
 
    /*
    * Process xsl:when ---------------------------------------------------
    */
    while (IS_XSLT_ELEM(cur) && IS_XSLT_NAME(cur, "when")) {
        wcomp = cur->psvi;
 
        if ((wcomp == NULL) || (wcomp->test == NULL) ||
        (wcomp->comp == NULL))
        {
        xsltTransformError(ctxt, NULL, cur,
            "Internal error in xsltChoose(): "
            "The XSLT 'when' instruction was not compiled.\n");
        goto error;
        }
 
 
#ifdef WITH_DEBUGGER
        if (xslDebugStatus != XSLT_DEBUG_NONE) {
        /*
        * TODO: Isn't comp->templ always NULL for xsl:choose?
        */
        xslHandleDebugger(cur, contextNode, NULL, ctxt);
        }
#endif
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_CHOOSE,xsltGenericDebug(xsltGenericDebugContext,
        "xsltChoose: test %s\n", wcomp->test));
#endif
 
#ifdef XSLT_FAST_IF
        res = xsltPreCompEvalToBoolean(ctxt, contextNode, wcomp);
 
        if (res == -1) {
        ctxt->state = XSLT_STATE_STOPPED;
        goto error;
        }
        testRes = (res == 1) ? 1 : 0;
 
#else /* XSLT_FAST_IF */
 
        res = xsltPreCompEval(ctxt, cotextNode, wcomp);
 
        if (res != NULL) {
        if (res->type != XPATH_BOOLEAN)
            res = xmlXPathConvertBoolean(res);
        if (res->type == XPATH_BOOLEAN)
            testRes = res->boolval;
        else {
#ifdef WITH_XSLT_DEBUG_PROCESS
            XSLT_TRACE(ctxt,XSLT_TRACE_CHOOSE,xsltGenericDebug(xsltGenericDebugContext,
            "xsltChoose: test didn't evaluate to a boolean\n"));
#endif
            goto error;
        }
        xmlXPathFreeObject(res);
        res = NULL;
        } else {
        ctxt->state = XSLT_STATE_STOPPED;
        goto error;
        }
 
#endif /* else of XSLT_FAST_IF */
 
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_CHOOSE,xsltGenericDebug(xsltGenericDebugContext,
        "xsltChoose: test evaluate to %d\n", testRes));
#endif
        if (testRes)
        goto test_is_true;
 
        cur = cur->next;
    }
 
    /*
    * Process xsl:otherwise ----------------------------------------------
    */
    if (IS_XSLT_ELEM(cur) && IS_XSLT_NAME(cur, "otherwise")) {
 
#ifdef WITH_DEBUGGER
        if (xslDebugStatus != XSLT_DEBUG_NONE)
        xslHandleDebugger(cur, contextNode, NULL, ctxt);
#endif
 
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_CHOOSE,xsltGenericDebug(xsltGenericDebugContext,
        "evaluating xsl:otherwise\n"));
#endif
        goto test_is_true;
    }
    goto exit;
 
test_is_true:
 
    goto process_sequence;
    }
 
process_sequence:
 
    /*
    * Instantiate the sequence constructor.
    */
    xsltApplySequenceConstructor(ctxt, ctxt->node, cur->children,
    NULL);
 
exit:
error:
    return;
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltComment()

XSLTPUBFUN void XSLTCALL xsltComment	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr comp	ATTRIBUTE_UNUSED
	)

xsltComment: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt comment node @comp: precomputed information

Process the xslt comment node on the source node

Definition at line 4265 of file transform.c.

                                                                          {
    xmlChar *value = NULL;
    xmlNodePtr commentNode;
    int len;
 
    value = xsltEvalTemplateString(ctxt, node, inst);
    /* TODO: use or generate the compiled form */
    len = xmlStrlen(value);
    if (len > 0) {
        if ((value[len-1] == '-') ||
        (xmlStrstr(value, BAD_CAST "--"))) {
        xsltTransformError(ctxt, NULL, inst,
            "xsl:comment : '--' or ending '-' not allowed in comment\n");
        /* fall through to try to catch further errors */
    }
    }
#ifdef WITH_XSLT_DEBUG_PROCESS
    if (value == NULL) {
    XSLT_TRACE(ctxt,XSLT_TRACE_COMMENT,xsltGenericDebug(xsltGenericDebugContext,
         "xsltComment: empty\n"));
    } else {
    XSLT_TRACE(ctxt,XSLT_TRACE_COMMENT,xsltGenericDebug(xsltGenericDebugContext,
         "xsltComment: content %s\n", value));
    }
#endif
 
    commentNode = xmlNewComment(value);
    commentNode = xsltAddChild(ctxt->insert, commentNode);
 
    if (value != NULL)
    xmlFree(value);
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltCopy()

XSLTPUBFUN void XSLTCALL xsltCopy	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltCopy: @ctxt: an XSLT process context @node: the node in the source tree @inst: the element node of the XSLT-copy instruction @castedComp: computed information of the XSLT-copy instruction

Execute the XSLT-copy instruction on the source node.

Definition at line 3901 of file transform.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemCopyPtr comp = (xsltStyleItemCopyPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    xmlNodePtr copy, oldInsert;
 
    oldInsert = ctxt->insert;
    if (ctxt->insert != NULL) {
    switch (node->type) {
        case XML_TEXT_NODE:
        case XML_CDATA_SECTION_NODE:
        /*
         * This text comes from the stylesheet
         * For stylesheets, the set of whitespace-preserving
         * element names consists of just xsl:text.
         */
#ifdef WITH_XSLT_DEBUG_PROCESS
        if (node->type == XML_CDATA_SECTION_NODE) {
            XSLT_TRACE(ctxt,XSLT_TRACE_COPY,xsltGenericDebug(xsltGenericDebugContext,
             "xsltCopy: CDATA text %s\n", node->content));
        } else {
            XSLT_TRACE(ctxt,XSLT_TRACE_COPY,xsltGenericDebug(xsltGenericDebugContext,
             "xsltCopy: text %s\n", node->content));
                }
#endif
        xsltCopyText(ctxt, ctxt->insert, node, 0);
        break;
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE:
        break;
        case XML_ELEMENT_NODE:
        /*
        * REVISIT NOTE: The "fake" is a doc-node, not an element node.
        * REMOVED:
        *   if (xmlStrEqual(node->name, BAD_CAST " fake node libxslt"))
        *    return;
        */
 
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_COPY,xsltGenericDebug(xsltGenericDebugContext,
                 "xsltCopy: node %s\n", node->name));
#endif
        copy = xsltShallowCopyElem(ctxt, node, ctxt->insert, 0);
        ctxt->insert = copy;
        if (comp->use != NULL) {
            xsltApplyAttributeSet(ctxt, node, inst, comp->use);
        }
        break;
        case XML_ATTRIBUTE_NODE: {
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_COPY,xsltGenericDebug(xsltGenericDebugContext,
                 "xsltCopy: attribute %s\n", node->name));
#endif
        /*
        * REVISIT: We could also raise an error if the parent is not
        * an element node.
        * OPTIMIZE TODO: Can we set the value/children of the
        * attribute without an intermediate copy of the string value?
        */
        xsltShallowCopyAttr(ctxt, inst, ctxt->insert, (xmlAttrPtr) node);
        break;
        }
        case XML_PI_NODE:
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_COPY,xsltGenericDebug(xsltGenericDebugContext,
                 "xsltCopy: PI %s\n", node->name));
#endif
        copy = xmlNewDocPI(ctxt->insert->doc, node->name,
                           node->content);
        copy = xsltAddChild(ctxt->insert, copy);
        break;
        case XML_COMMENT_NODE:
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_COPY,xsltGenericDebug(xsltGenericDebugContext,
                 "xsltCopy: comment\n"));
#endif
        copy = xmlNewComment(node->content);
        copy = xsltAddChild(ctxt->insert, copy);
        break;
        case XML_NAMESPACE_DECL:
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_COPY,xsltGenericDebug(xsltGenericDebugContext,
                 "xsltCopy: namespace declaration\n"));
#endif
        xsltShallowCopyNsNode(ctxt, inst, ctxt->insert, (xmlNsPtr)node);
        break;
        default:
        break;
 
    }
    }
 
    switch (node->type) {
    case XML_DOCUMENT_NODE:
    case XML_HTML_DOCUMENT_NODE:
    case XML_ELEMENT_NODE:
        xsltApplySequenceConstructor(ctxt, ctxt->node, inst->children,
        NULL);
        break;
    default:
        break;
    }
    ctxt->insert = oldInsert;
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltCopyOf()

XSLTPUBFUN void XSLTCALL xsltCopyOf	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltCopyOf: @ctxt: an XSLT transformation context @node: the current node in the source tree @inst: the element node of the XSLT copy-of instruction @castedComp: precomputed information of the XSLT copy-of instruction

Process the XSLT copy-of instruction.

Definition at line 4375 of file transform.c.

                                                               {
#ifdef XSLT_REFACTORED
    xsltStyleItemCopyOfPtr comp = (xsltStyleItemCopyOfPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    xmlXPathObjectPtr res = NULL;
    xmlNodeSetPtr list = NULL;
    int i;
 
    if ((ctxt == NULL) || (node == NULL) || (inst == NULL))
    return;
    if ((comp == NULL) || (comp->select == NULL) || (comp->comp == NULL)) {
    xsltTransformError(ctxt, NULL, inst,
         "xsl:copy-of : compilation failed\n");
    return;
    }
 
     /*
    * SPEC XSLT 1.0:
    *  "The xsl:copy-of element can be used to insert a result tree
    *  fragment into the result tree, without first converting it to
    *  a string as xsl:value-of does (see [7.6.1 Generating Text with
    *  xsl:value-of]). The required select attribute contains an
    *  expression. When the result of evaluating the expression is a
    *  result tree fragment, the complete fragment is copied into the
    *  result tree. When the result is a node-set, all the nodes in the
    *  set are copied in document order into the result tree; copying
    *  an element node copies the attribute nodes, namespace nodes and
    *  children of the element node as well as the element node itself;
    *  a root node is copied by copying its children. When the result
    *  is neither a node-set nor a result tree fragment, the result is
    *  converted to a string and then inserted into the result tree,
    *  as with xsl:value-of.
    */
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_COPY_OF,xsltGenericDebug(xsltGenericDebugContext,
     "xsltCopyOf: select %s\n", comp->select));
#endif
 
    /*
    * Evaluate the "select" expression.
    */
    res = xsltPreCompEval(ctxt, node, comp);
 
    if (res != NULL) {
    if (res->type == XPATH_NODESET) {
        /*
        * Node-set
        * --------
        */
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_COPY_OF,xsltGenericDebug(xsltGenericDebugContext,
         "xsltCopyOf: result is a node set\n"));
#endif
        list = res->nodesetval;
        if (list != NULL) {
        xmlNodePtr cur;
        /*
        * The list is already sorted in document order by XPath.
        * Append everything in this order under ctxt->insert.
        */
        for (i = 0;i < list->nodeNr;i++) {
            cur = list->nodeTab[i];
            if (cur == NULL)
            continue;
            if ((cur->type == XML_DOCUMENT_NODE) ||
            (cur->type == XML_HTML_DOCUMENT_NODE))
            {
            xsltCopyTreeList(ctxt, inst,
                cur->children, ctxt->insert, 0, 0);
            } else if (cur->type == XML_ATTRIBUTE_NODE) {
            xsltShallowCopyAttr(ctxt, inst,
                ctxt->insert, (xmlAttrPtr) cur);
            } else {
            xsltCopyTree(ctxt, inst, cur, ctxt->insert, 0, 0);
            }
        }
        }
    } else if (res->type == XPATH_XSLT_TREE) {
        /*
        * Result tree fragment
        * --------------------
        * E.g. via <xsl:variable ...><foo/></xsl:variable>
        * Note that the root node of such trees is an xmlDocPtr in Libxslt.
        */
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_COPY_OF,xsltGenericDebug(xsltGenericDebugContext,
         "xsltCopyOf: result is a result tree fragment\n"));
#endif
        list = res->nodesetval;
        if ((list != NULL) && (list->nodeTab != NULL) &&
        (list->nodeTab[0] != NULL) &&
        (IS_XSLT_REAL_NODE(list->nodeTab[0])))
        {
        xsltCopyTreeList(ctxt, inst,
            list->nodeTab[0]->children, ctxt->insert, 0, 0);
        }
    } else {
        xmlChar *value = NULL;
        /*
        * Convert to a string.
        */
        value = xmlXPathCastToString(res);
        if (value == NULL) {
        xsltTransformError(ctxt, NULL, inst,
            "Internal error in xsltCopyOf(): "
            "failed to cast an XPath object to string.\n");
        ctxt->state = XSLT_STATE_STOPPED;
        } else {
        if (value[0] != 0) {
            /*
            * Append content as text node.
            */
            xsltCopyTextString(ctxt, ctxt->insert, value, 0);
        }
        xmlFree(value);
 
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_COPY_OF,xsltGenericDebug(xsltGenericDebugContext,
            "xsltCopyOf: result %s\n", res->stringval));
#endif
        }
    }
    } else {
    ctxt->state = XSLT_STATE_STOPPED;
    }
 
    if (res != NULL)
    xmlXPathFreeObject(res);
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltCopyTextString()

XSLTPUBFUN xmlNodePtr XSLTCALL xsltCopyTextString	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	target,
		const xmlChar *	string,
		int	noescape
	)

xsltCopyTextString: @ctxt: a XSLT process context @target: the element where the text will be attached @string: the text string @noescape: should disable-escaping be activated for this text node.

Adds @string to a newly created or an existent text node child of @target.

Returns: the text node, where the text content of @cur is copied to. NULL in case of API or internal errors.

Definition at line 881 of file transform.c.

{
    xmlNodePtr copy;
    int len;
 
    if (string == NULL)
    return(NULL);
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_COPY_TEXT,xsltGenericDebug(xsltGenericDebugContext,
             "xsltCopyTextString: copy text %s\n",
             string));
#endif
 
    /*
    * Play safe and reset the merging mechanism for every new
    * target node.
    */
    if ((target == NULL) || (target->children == NULL)) {
    ctxt->lasttext = NULL;
    }
 
    /* handle coalescing of text nodes here */
    len = xmlStrlen(string);
    if ((ctxt->type == XSLT_OUTPUT_XML) &&
    (ctxt->style->cdataSection != NULL) &&
    (target != NULL) &&
    (target->type == XML_ELEMENT_NODE) &&
    (((target->ns == NULL) &&
      (xmlHashLookup2(ctxt->style->cdataSection,
                  target->name, NULL) != NULL)) ||
     ((target->ns != NULL) &&
      (xmlHashLookup2(ctxt->style->cdataSection,
                      target->name, target->ns->href) != NULL))))
    {
    /*
    * Process "cdata-section-elements".
    */
    if ((target->last != NULL) &&
        (target->last->type == XML_CDATA_SECTION_NODE))
    {
        return(xsltAddTextString(ctxt, target->last, string, len));
    }
    copy = xmlNewCDataBlock(ctxt->output, string, len);
    } else if (noescape) {
    /*
    * Process "disable-output-escaping".
    */
    if ((target != NULL) && (target->last != NULL) &&
        (target->last->type == XML_TEXT_NODE) &&
        (target->last->name == xmlStringTextNoenc))
    {
        return(xsltAddTextString(ctxt, target->last, string, len));
    }
    copy = xmlNewTextLen(string, len);
    if (copy != NULL)
        copy->name = xmlStringTextNoenc;
    } else {
    /*
    * Default processing.
    */
    if ((target != NULL) && (target->last != NULL) &&
        (target->last->type == XML_TEXT_NODE) &&
        (target->last->name == xmlStringText)) {
        return(xsltAddTextString(ctxt, target->last, string, len));
    }
    copy = xmlNewTextLen(string, len);
    }
    if (copy != NULL && target != NULL)
    copy = xsltAddChild(target, copy);
    if (copy != NULL) {
    ctxt->lasttext = copy->content;
    ctxt->lasttsize = len;
    ctxt->lasttuse = len;
    } else {
    xsltTransformError(ctxt, NULL, target,
             "xsltCopyTextString: text copy failed\n");
    ctxt->lasttext = NULL;
    }
    return(copy);
}

Referenced by xsltCopyOf(), xsltCopyTree(), xsltNumberFormat(), and xsltValueOf().

xsltDocumentElem()

XSLTPUBFUN void XSLTCALL xsltDocumentElem	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltDocumentElem: @ctxt: an XSLT processing context @node: The current node @inst: the instruction in the stylesheet @castedComp: precomputed information

Process an EXSLT/XSLT-1.1 document element

Definition at line 3363 of file transform.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemDocumentPtr comp = (xsltStyleItemDocumentPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    xsltStylesheetPtr style = NULL;
    int ret;
    xmlChar *filename = NULL, *prop, *elements;
    xmlChar *element, *end;
    xmlDocPtr res = NULL;
    xmlDocPtr oldOutput;
    xmlNodePtr oldInsert, root;
    const char *oldOutputFile;
    xsltOutputType oldType;
    xmlChar *URL = NULL;
    const xmlChar *method;
    const xmlChar *doctypePublic;
    const xmlChar *doctypeSystem;
    const xmlChar *version;
    const xmlChar *encoding;
    int redirect_write_append = 0;
 
    if ((ctxt == NULL) || (node == NULL) || (inst == NULL) || (comp == NULL))
        return;
 
    if (comp->filename == NULL) {
 
        if (xmlStrEqual(inst->name, (const xmlChar *) "output")) {
        /*
        * The element "output" is in the namespace XSLT_SAXON_NAMESPACE
        *   (http://icl.com/saxon)
        * The @file is in no namespace.
        */
#ifdef WITH_XSLT_DEBUG_EXTRA
            xsltGenericDebug(xsltGenericDebugContext,
                             "Found saxon:output extension\n");
#endif
            URL = xsltEvalAttrValueTemplate(ctxt, inst,
                                                 (const xmlChar *) "file",
                                                 XSLT_SAXON_NAMESPACE);
 
        if (URL == NULL)
        URL = xsltEvalAttrValueTemplate(ctxt, inst,
                                                 (const xmlChar *) "href",
                                                 XSLT_SAXON_NAMESPACE);
        } else if (xmlStrEqual(inst->name, (const xmlChar *) "write")) {
#ifdef WITH_XSLT_DEBUG_EXTRA
            xsltGenericDebug(xsltGenericDebugContext,
                             "Found xalan:write extension\n");
#endif
            URL = xsltEvalAttrValueTemplate(ctxt, inst,
                                                 (const xmlChar *)
                                                 "select",
                                                 XSLT_XALAN_NAMESPACE);
        if (URL != NULL) {
        xmlXPathCompExprPtr cmp;
        xmlChar *val;
 
        /*
         * Trying to handle bug #59212
         * The value of the "select" attribute is an
         * XPath expression.
         * (see http://xml.apache.org/xalan-j/extensionslib.html#redirect)
         */
        cmp = xmlXPathCtxtCompile(ctxt->xpathCtxt, URL);
                val = xsltEvalXPathString(ctxt, cmp);
        xmlXPathFreeCompExpr(cmp);
        xmlFree(URL);
        URL = val;
        }
        if (URL == NULL)
        URL = xsltEvalAttrValueTemplate(ctxt, inst,
                             (const xmlChar *)
                             "file",
                             XSLT_XALAN_NAMESPACE);
        if (URL == NULL)
        URL = xsltEvalAttrValueTemplate(ctxt, inst,
                             (const xmlChar *)
                             "href",
                             XSLT_XALAN_NAMESPACE);
        } else if (xmlStrEqual(inst->name, (const xmlChar *) "document")) {
            URL = xsltEvalAttrValueTemplate(ctxt, inst,
                                                 (const xmlChar *) "href",
                                                 NULL);
        }
 
    } else {
        URL = xmlStrdup(comp->filename);
    }
 
    if (URL == NULL) {
    xsltTransformError(ctxt, NULL, inst,
                 "xsltDocumentElem: href/URI-Reference not found\n");
    return;
    }
 
    /*
     * If the computation failed, it's likely that the URL wasn't escaped
     */
    filename = xmlBuildURI(URL, (const xmlChar *) ctxt->outputFile);
    if (filename == NULL) {
    xmlChar *escURL;
 
    escURL=xmlURIEscapeStr(URL, BAD_CAST ":/.?,");
    if (escURL != NULL) {
        filename = xmlBuildURI(escURL, (const xmlChar *) ctxt->outputFile);
        xmlFree(escURL);
    }
    }
 
    if (filename == NULL) {
    xsltTransformError(ctxt, NULL, inst,
                 "xsltDocumentElem: URL computation failed for %s\n",
             URL);
    xmlFree(URL);
    return;
    }
 
    /*
     * Security checking: can we write to this resource
     */
    if (ctxt->sec != NULL) {
    ret = xsltCheckWrite(ctxt->sec, ctxt, filename);
    if (ret <= 0) {
            if (ret == 0)
                xsltTransformError(ctxt, NULL, inst,
                     "xsltDocumentElem: write rights for %s denied\n",
                                 filename);
        xmlFree(URL);
        xmlFree(filename);
        return;
    }
    }
 
    oldOutputFile = ctxt->outputFile;
    oldOutput = ctxt->output;
    oldInsert = ctxt->insert;
    oldType = ctxt->type;
    ctxt->outputFile = (const char *) filename;
 
    style = xsltNewStylesheet();
    if (style == NULL) {
    xsltTransformError(ctxt, NULL, inst,
                         "xsltDocumentElem: out of memory\n");
        goto error;
    }
 
    /*
     * Version described in 1.1 draft allows full parameterization
     * of the output.
     */
    prop = xsltEvalAttrValueTemplate(ctxt, inst,
                     (const xmlChar *) "version",
                     NULL);
    if (prop != NULL) {
    if (style->version != NULL)
        xmlFree(style->version);
    style->version = prop;
    }
    prop = xsltEvalAttrValueTemplate(ctxt, inst,
                     (const xmlChar *) "encoding",
                     NULL);
    if (prop != NULL) {
    if (style->encoding != NULL)
        xmlFree(style->encoding);
    style->encoding = prop;
    }
    prop = xsltEvalAttrValueTemplate(ctxt, inst,
                     (const xmlChar *) "method",
                     NULL);
    if (prop != NULL) {
    const xmlChar *URI;
 
    if (style->method != NULL)
        xmlFree(style->method);
    style->method = NULL;
    if (style->methodURI != NULL)
        xmlFree(style->methodURI);
    style->methodURI = NULL;
 
    URI = xsltGetQNameURI(inst, &prop);
    if (prop == NULL) {
        if (style != NULL) style->errors++;
    } else if (URI == NULL) {
        if ((xmlStrEqual(prop, (const xmlChar *) "xml")) ||
        (xmlStrEqual(prop, (const xmlChar *) "html")) ||
        (xmlStrEqual(prop, (const xmlChar *) "text"))) {
        style->method = prop;
        } else {
        xsltTransformError(ctxt, NULL, inst,
                 "invalid value for method: %s\n", prop);
        if (style != NULL) style->warnings++;
        }
    } else {
        style->method = prop;
        style->methodURI = xmlStrdup(URI);
    }
    }
    prop = xsltEvalAttrValueTemplate(ctxt, inst,
                     (const xmlChar *)
                     "doctype-system", NULL);
    if (prop != NULL) {
    if (style->doctypeSystem != NULL)
        xmlFree(style->doctypeSystem);
    style->doctypeSystem = prop;
    }
    prop = xsltEvalAttrValueTemplate(ctxt, inst,
                     (const xmlChar *)
                     "doctype-public", NULL);
    if (prop != NULL) {
    if (style->doctypePublic != NULL)
        xmlFree(style->doctypePublic);
    style->doctypePublic = prop;
    }
    prop = xsltEvalAttrValueTemplate(ctxt, inst,
                     (const xmlChar *) "standalone",
                     NULL);
    if (prop != NULL) {
    if (xmlStrEqual(prop, (const xmlChar *) "yes")) {
        style->standalone = 1;
    } else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
        style->standalone = 0;
    } else {
        xsltTransformError(ctxt, NULL, inst,
                 "invalid value for standalone: %s\n",
                 prop);
        if (style != NULL) style->warnings++;
    }
    xmlFree(prop);
    }
 
    prop = xsltEvalAttrValueTemplate(ctxt, inst,
                     (const xmlChar *) "indent",
                     NULL);
    if (prop != NULL) {
    if (xmlStrEqual(prop, (const xmlChar *) "yes")) {
        style->indent = 1;
    } else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
        style->indent = 0;
    } else {
        xsltTransformError(ctxt, NULL, inst,
                 "invalid value for indent: %s\n", prop);
        if (style != NULL) style->warnings++;
    }
    xmlFree(prop);
    }
 
    prop = xsltEvalAttrValueTemplate(ctxt, inst,
                     (const xmlChar *)
                     "omit-xml-declaration",
                     NULL);
    if (prop != NULL) {
    if (xmlStrEqual(prop, (const xmlChar *) "yes")) {
        style->omitXmlDeclaration = 1;
    } else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
        style->omitXmlDeclaration = 0;
    } else {
        xsltTransformError(ctxt, NULL, inst,
                 "invalid value for omit-xml-declaration: %s\n",
                 prop);
        if (style != NULL) style->warnings++;
    }
    xmlFree(prop);
    }
 
    elements = xsltEvalAttrValueTemplate(ctxt, inst,
                     (const xmlChar *)
                     "cdata-section-elements",
                     NULL);
    if (elements != NULL) {
    if (style->stripSpaces == NULL)
        style->stripSpaces = xmlHashCreate(10);
    if (style->stripSpaces == NULL) {
        xmlFree(elements);
        return;
    }
 
    element = elements;
    while (*element != 0) {
        while (xmlIsBlank_ch(*element))
        element++;
        if (*element == 0)
        break;
        end = element;
        while ((*end != 0) && (!xmlIsBlank_ch(*end)))
        end++;
        element = xmlStrndup(element, end - element);
        if (element) {
        const xmlChar *URI;
 
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
                 "add cdata section output element %s\n",
                 element);
#endif
                URI = xsltGetQNameURI(inst, &element);
 
        xmlHashAddEntry2(style->stripSpaces, element, URI,
                    (xmlChar *) "cdata");
        xmlFree(element);
        }
        element = end;
    }
    xmlFree(elements);
    }
 
    /*
     * Create a new document tree and process the element template
     */
    XSLT_GET_IMPORT_PTR(method, style, method)
    XSLT_GET_IMPORT_PTR(doctypePublic, style, doctypePublic)
    XSLT_GET_IMPORT_PTR(doctypeSystem, style, doctypeSystem)
    XSLT_GET_IMPORT_PTR(version, style, version)
    XSLT_GET_IMPORT_PTR(encoding, style, encoding)
 
    if ((method != NULL) &&
    (!xmlStrEqual(method, (const xmlChar *) "xml"))) {
    if (xmlStrEqual(method, (const xmlChar *) "html")) {
        ctxt->type = XSLT_OUTPUT_HTML;
        if (((doctypePublic != NULL) || (doctypeSystem != NULL)))
        res = htmlNewDoc(doctypeSystem, doctypePublic);
        else {
        if (version != NULL) {
#ifdef XSLT_GENERATE_HTML_DOCTYPE
            xsltGetHTMLIDs(version, &doctypePublic, &doctypeSystem);
#endif
                }
        res = htmlNewDocNoDtD(doctypeSystem, doctypePublic);
        }
        if (res == NULL)
        goto error;
        res->dict = ctxt->dict;
        xmlDictReference(res->dict);
    } else if (xmlStrEqual(method, (const xmlChar *) "xhtml")) {
        xsltTransformError(ctxt, NULL, inst,
         "xsltDocumentElem: unsupported method xhtml\n");
        ctxt->type = XSLT_OUTPUT_HTML;
        res = htmlNewDocNoDtD(doctypeSystem, doctypePublic);
        if (res == NULL)
        goto error;
        res->dict = ctxt->dict;
        xmlDictReference(res->dict);
    } else if (xmlStrEqual(method, (const xmlChar *) "text")) {
        ctxt->type = XSLT_OUTPUT_TEXT;
        res = xmlNewDoc(style->version);
        if (res == NULL)
        goto error;
        res->dict = ctxt->dict;
        xmlDictReference(res->dict);
#ifdef WITH_XSLT_DEBUG
        xsltGenericDebug(xsltGenericDebugContext,
                     "reusing transformation dict for output\n");
#endif
    } else {
        xsltTransformError(ctxt, NULL, inst,
                 "xsltDocumentElem: unsupported method (%s)\n",
                     method);
        goto error;
    }
    } else {
    ctxt->type = XSLT_OUTPUT_XML;
    res = xmlNewDoc(style->version);
    if (res == NULL)
        goto error;
    res->dict = ctxt->dict;
    xmlDictReference(res->dict);
#ifdef WITH_XSLT_DEBUG
    xsltGenericDebug(xsltGenericDebugContext,
                     "reusing transformation dict for output\n");
#endif
    }
    res->charset = XML_CHAR_ENCODING_UTF8;
    if (encoding != NULL)
    res->encoding = xmlStrdup(encoding);
    ctxt->output = res;
    ctxt->insert = (xmlNodePtr) res;
    xsltApplySequenceConstructor(ctxt, node, inst->children, NULL);
 
    /*
     * Do some post processing work depending on the generated output
     */
    root = xmlDocGetRootElement(res);
    if (root != NULL) {
        const xmlChar *doctype = NULL;
 
        if ((root->ns != NULL) && (root->ns->prefix != NULL))
        doctype = xmlDictQLookup(ctxt->dict, root->ns->prefix, root->name);
    if (doctype == NULL)
        doctype = root->name;
 
        /*
         * Apply the default selection of the method
         */
        if ((method == NULL) &&
            (root->ns == NULL) &&
            (!xmlStrcasecmp(root->name, (const xmlChar *) "html"))) {
            xmlNodePtr tmp;
 
            tmp = res->children;
            while ((tmp != NULL) && (tmp != root)) {
                if (tmp->type == XML_ELEMENT_NODE)
                    break;
                if ((tmp->type == XML_TEXT_NODE) && (!xmlIsBlankNode(tmp)))
                    break;
        tmp = tmp->next;
            }
            if (tmp == root) {
                ctxt->type = XSLT_OUTPUT_HTML;
                res->type = XML_HTML_DOCUMENT_NODE;
                if (((doctypePublic != NULL) || (doctypeSystem != NULL))) {
                    res->intSubset = xmlCreateIntSubset(res, doctype,
                                                        doctypePublic,
                                                        doctypeSystem);
#ifdef XSLT_GENERATE_HTML_DOCTYPE
        } else if (version != NULL) {
                    xsltGetHTMLIDs(version, &doctypePublic,
                                   &doctypeSystem);
                    if (((doctypePublic != NULL) || (doctypeSystem != NULL)))
                        res->intSubset =
                            xmlCreateIntSubset(res, doctype,
                                               doctypePublic,
                                               doctypeSystem);
#endif
                }
            }
 
        }
        if (ctxt->type == XSLT_OUTPUT_XML) {
            XSLT_GET_IMPORT_PTR(doctypePublic, style, doctypePublic)
                XSLT_GET_IMPORT_PTR(doctypeSystem, style, doctypeSystem)
                if (((doctypePublic != NULL) || (doctypeSystem != NULL)))
                res->intSubset = xmlCreateIntSubset(res, doctype,
                                                    doctypePublic,
                                                    doctypeSystem);
        }
    }
 
    /*
     * Calls to redirect:write also take an optional attribute append.
     * Attribute append="true|yes" which will attempt to simply append
     * to an existing file instead of always opening a new file. The
     * default behavior of always overwriting the file still happens
     * if we do not specify append.
     * Note that append use will forbid use of remote URI target.
     */
    prop = xsltEvalAttrValueTemplate(ctxt, inst, (const xmlChar *)"append",
                     NULL);
    if (prop != NULL) {
    if (xmlStrEqual(prop, (const xmlChar *) "true") ||
        xmlStrEqual(prop, (const xmlChar *) "yes")) {
        style->omitXmlDeclaration = 1;
        redirect_write_append = 1;
    } else
        style->omitXmlDeclaration = 0;
    xmlFree(prop);
    }
 
    if (redirect_write_append) {
        FILE *f;
 
    f = fopen((const char *) filename, "ab");
    if (f == NULL) {
        ret = -1;
    } else {
        ret = xsltSaveResultToFile(f, res, style);
        fclose(f);
    }
    } else {
    ret = xsltSaveResultToFilename((const char *) filename, res, style, 0);
    }
    if (ret < 0) {
    xsltTransformError(ctxt, NULL, inst,
                         "xsltDocumentElem: unable to save to %s\n",
                         filename);
#ifdef WITH_XSLT_DEBUG_EXTRA
    } else {
        xsltGenericDebug(xsltGenericDebugContext,
                         "Wrote %d bytes to %s\n", ret, filename);
#endif
    }
 
  error:
    ctxt->output = oldOutput;
    ctxt->insert = oldInsert;
    ctxt->type = oldType;
    ctxt->outputFile = oldOutputFile;
    if (URL != NULL)
        xmlFree(URL);
    if (filename != NULL)
        xmlFree(filename);
    if (style != NULL)
        xsltFreeStylesheet(style);
    if (res != NULL)
        xmlFreeDoc(res);
}

Referenced by xsltNewStylePreComp(), xsltRegisterAllExtras(), and xsltStylePreCompute().

xsltElement()

XSLTPUBFUN void XSLTCALL xsltElement	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltElement: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt element node @castedComp: precomputed information

Process the xslt element node on the source node

Definition at line 4057 of file transform.c.

                                                        {
#ifdef XSLT_REFACTORED
    xsltStyleItemElementPtr comp = (xsltStyleItemElementPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    xmlChar *prop = NULL;
    const xmlChar *name, *prefix = NULL, *nsName = NULL;
    xmlNodePtr copy;
    xmlNodePtr oldInsert;
 
    if (ctxt->insert == NULL)
    return;
 
    /*
    * A comp->has_name == 0 indicates that we need to skip this instruction,
    * since it was evaluated to be invalid already during compilation.
    */
    if (!comp->has_name)
        return;
 
    /*
     * stack and saves
     */
    oldInsert = ctxt->insert;
 
    if (comp->name == NULL) {
    /* TODO: fix attr acquisition wrt to the XSLT namespace */
        prop = xsltEvalAttrValueTemplate(ctxt, inst,
        (const xmlChar *) "name", XSLT_NAMESPACE);
        if (prop == NULL) {
            xsltTransformError(ctxt, NULL, inst,
        "xsl:element: The attribute 'name' is missing.\n");
            goto error;
        }
    if (xmlValidateQName(prop, 0)) {
        xsltTransformError(ctxt, NULL, inst,
        "xsl:element: The effective name '%s' is not a "
        "valid QName.\n", prop);
        /* we fall through to catch any further errors, if possible */
    }
    name = xsltSplitQName(ctxt->dict, prop, &prefix);
    xmlFree(prop);
    } else {
    /*
    * The "name" value was static.
    */
#ifdef XSLT_REFACTORED
    prefix = comp->nsPrefix;
    name = comp->name;
#else
    name = xsltSplitQName(ctxt->dict, comp->name, &prefix);
#endif
    }
 
    /*
     * Create the new element
     */
    if (ctxt->output->dict == ctxt->dict) {
    copy = xmlNewDocNodeEatName(ctxt->output, NULL, (xmlChar *)name, NULL);
    } else {
    copy = xmlNewDocNode(ctxt->output, NULL, (xmlChar *)name, NULL);
    }
    if (copy == NULL) {
    xsltTransformError(ctxt, NULL, inst,
        "xsl:element : creation of %s failed\n", name);
    return;
    }
    copy = xsltAddChild(ctxt->insert, copy);
    if (copy == NULL) {
        xsltTransformError(ctxt, NULL, inst,
            "xsl:element : xsltAddChild failed\n");
        return;
    }
 
    /*
    * Namespace
    * ---------
    */
    if (comp->has_ns) {
    if (comp->ns != NULL) {
        /*
        * No AVT; just plain text for the namespace name.
        */
        if (comp->ns[0] != 0)
        nsName = comp->ns;
    } else {
        xmlChar *tmpNsName;
        /*
        * Eval the AVT.
        */
        /* TODO: check attr acquisition wrt to the XSLT namespace */
        tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
        (const xmlChar *) "namespace", XSLT_NAMESPACE);
        /*
        * SPEC XSLT 1.0:
        *  "If the string is empty, then the expanded-name of the
        *  attribute has a null namespace URI."
        */
        if ((tmpNsName != NULL) && (tmpNsName[0] != 0))
        nsName = xmlDictLookup(ctxt->dict, BAD_CAST tmpNsName, -1);
        xmlFree(tmpNsName);
    }
 
        if (xmlStrEqual(nsName, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
            xsltTransformError(ctxt, NULL, inst,
                "xsl:attribute: Namespace http://www.w3.org/2000/xmlns/ "
                "forbidden.\n");
            goto error;
        }
        if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) {
            prefix = BAD_CAST "xml";
        } else if (xmlStrEqual(prefix, BAD_CAST "xml")) {
            prefix = NULL;
        }
    } else {
    xmlNsPtr ns;
    /*
    * SPEC XSLT 1.0:
    *  "If the namespace attribute is not present, then the QName is
    *  expanded into an expanded-name using the namespace declarations
    *  in effect for the xsl:element element, including any default
    *  namespace declaration.
    */
    ns = xmlSearchNs(inst->doc, inst, prefix);
    if (ns == NULL) {
        /*
        * TODO: Check this in the compilation layer in case it's a
        * static value.
        */
            if (prefix != NULL) {
                xsltTransformError(ctxt, NULL, inst,
                    "xsl:element: The QName '%s:%s' has no "
                    "namespace binding in scope in the stylesheet; "
                    "this is an error, since the namespace was not "
                    "specified by the instruction itself.\n", prefix, name);
            }
    } else
        nsName = ns->href;
    }
    /*
    * Find/create a matching ns-decl in the result tree.
    */
    if (nsName != NULL) {
    if (xmlStrEqual(prefix, BAD_CAST "xmlns")) {
            /* Don't use a prefix of "xmlns" */
        xmlChar *pref = xmlStrdup(BAD_CAST "ns_1");
 
        copy->ns = xsltGetSpecialNamespace(ctxt, inst, nsName, pref, copy);
 
        xmlFree(pref);
    } else {
        copy->ns = xsltGetSpecialNamespace(ctxt, inst, nsName, prefix,
        copy);
    }
    } else if ((copy->parent != NULL) &&
    (copy->parent->type == XML_ELEMENT_NODE) &&
    (copy->parent->ns != NULL))
    {
    /*
    * "Undeclare" the default namespace.
    */
    xsltGetSpecialNamespace(ctxt, inst, NULL, NULL, copy);
    }
 
    ctxt->insert = copy;
 
    if (comp->has_use) {
    if (comp->use != NULL) {
        xsltApplyAttributeSet(ctxt, node, inst, comp->use);
    } else {
        xmlChar *attrSets = NULL;
        /*
        * BUG TODO: use-attribute-sets is not a value template.
        *  use-attribute-sets = qnames
        */
        attrSets = xsltEvalAttrValueTemplate(ctxt, inst,
        (const xmlChar *)"use-attribute-sets", NULL);
        if (attrSets != NULL) {
        xsltApplyAttributeSet(ctxt, node, inst, attrSets);
        xmlFree(attrSets);
        }
    }
    }
    /*
    * Instantiate the sequence constructor.
    */
    if (inst->children != NULL)
    xsltApplySequenceConstructor(ctxt, ctxt->node, inst->children,
        NULL);
 
error:
    ctxt->insert = oldInsert;
    return;
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltForEach()

XSLTPUBFUN void XSLTCALL xsltForEach	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	contextNode,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltForEach: @ctxt: an XSLT transformation context @contextNode: the "current node" in the source tree @inst: the element node of the xsl:for-each instruction @castedComp: the compiled information of the instruction

Process the xslt for-each node on the source node

Definition at line 5401 of file transform.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemForEachPtr comp = (xsltStyleItemForEachPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    int i;
    xmlXPathObjectPtr res = NULL;
    xmlNodePtr cur, curInst;
    xmlNodeSetPtr list = NULL;
    xmlNodeSetPtr oldList;
    int oldXPProximityPosition, oldXPContextSize;
    xmlNodePtr oldContextNode;
    xsltTemplatePtr oldCurTemplRule;
    xmlDocPtr oldXPDoc;
    xsltDocumentPtr oldDocInfo;
    xmlXPathContextPtr xpctxt;
 
    if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL)) {
    xsltGenericError(xsltGenericErrorContext,
        "xsltForEach(): Bad arguments.\n");
    return;
    }
 
    if (comp == NULL) {
        xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltForEach(): "
        "The XSLT 'for-each' instruction was not compiled.\n");
        return;
    }
    if ((comp->select == NULL) || (comp->comp == NULL)) {
    xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltForEach(): "
        "The selecting expression of the XSLT 'for-each' "
        "instruction was not compiled correctly.\n");
    return;
    }
    xpctxt = ctxt->xpathCtxt;
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_FOR_EACH,xsltGenericDebug(xsltGenericDebugContext,
     "xsltForEach: select %s\n", comp->select));
#endif
 
    /*
    * Save context states.
    */
    oldDocInfo = ctxt->document;
    oldList = ctxt->nodeList;
    oldContextNode = ctxt->node;
    /*
    * The "current template rule" is cleared for the instantiation of
    * xsl:for-each.
    */
    oldCurTemplRule = ctxt->currentTemplateRule;
    ctxt->currentTemplateRule = NULL;
 
    oldXPDoc = xpctxt->doc;
    oldXPProximityPosition = xpctxt->proximityPosition;
    oldXPContextSize = xpctxt->contextSize;
 
    /*
    * Evaluate the 'select' expression.
    */
    res = xsltPreCompEval(ctxt, contextNode, comp);
 
    if (res != NULL) {
    if (res->type == XPATH_NODESET)
        list = res->nodesetval;
    else {
        xsltTransformError(ctxt, NULL, inst,
        "The 'select' expression does not evaluate to a node set.\n");
 
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_FOR_EACH,xsltGenericDebug(xsltGenericDebugContext,
        "xsltForEach: select didn't evaluate to a node list\n"));
#endif
        goto error;
    }
    } else {
    xsltTransformError(ctxt, NULL, inst,
        "Failed to evaluate the 'select' expression.\n");
    ctxt->state = XSLT_STATE_STOPPED;
    goto error;
    }
 
    if ((list == NULL) || (list->nodeNr <= 0))
    goto exit;
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_FOR_EACH,xsltGenericDebug(xsltGenericDebugContext,
    "xsltForEach: select evaluates to %d nodes\n", list->nodeNr));
#endif
 
    /*
    * Set the list; this has to be done already here for xsltDoSortFunction().
    */
    ctxt->nodeList = list;
    /*
    * Handle xsl:sort instructions and skip them for further processing.
    * BUG TODO: We are not using namespaced potentially defined on the
    * xsl:sort element; XPath expression might fail.
    */
    curInst = inst->children;
    if (IS_XSLT_ELEM(curInst) && IS_XSLT_NAME(curInst, "sort")) {
    int nbsorts = 0;
    xmlNodePtr sorts[XSLT_MAX_SORT];
 
    sorts[nbsorts++] = curInst;
 
#ifdef WITH_DEBUGGER
    if (xslDebugStatus != XSLT_DEBUG_NONE)
        xslHandleDebugger(curInst, contextNode, NULL, ctxt);
#endif
 
    curInst = curInst->next;
    while (IS_XSLT_ELEM(curInst) && IS_XSLT_NAME(curInst, "sort")) {
        if (nbsorts >= XSLT_MAX_SORT) {
        xsltTransformError(ctxt, NULL, curInst,
            "The number of xsl:sort instructions exceeds the "
            "maximum (%d) allowed by this processor.\n",
            XSLT_MAX_SORT);
        goto error;
        } else {
        sorts[nbsorts++] = curInst;
        }
 
#ifdef WITH_DEBUGGER
        if (xslDebugStatus != XSLT_DEBUG_NONE)
        xslHandleDebugger(curInst, contextNode, NULL, ctxt);
#endif
        curInst = curInst->next;
    }
    xsltDoSortFunction(ctxt, sorts, nbsorts);
    }
    xpctxt->contextSize = list->nodeNr;
    /*
    * Instantiate the sequence constructor for each selected node.
    */
    for (i = 0; i < list->nodeNr; i++) {
    cur = list->nodeTab[i];
    /*
    * The selected node becomes the "current node".
    */
    ctxt->node = cur;
    /*
    * An xsl:for-each can change the current context doc.
    * OPTIMIZE TODO: Get rid of the need to set the context doc.
    */
    if ((cur->type != XML_NAMESPACE_DECL) && (cur->doc != NULL))
        xpctxt->doc = cur->doc;
 
    xpctxt->proximityPosition = i + 1;
 
    xsltApplySequenceConstructor(ctxt, cur, curInst, NULL);
    }
 
exit:
error:
    if (res != NULL)
    xmlXPathFreeObject(res);
    /*
    * Restore old states.
    */
    ctxt->document = oldDocInfo;
    ctxt->nodeList = oldList;
    ctxt->node = oldContextNode;
    ctxt->currentTemplateRule = oldCurTemplRule;
 
    xpctxt->doc = oldXPDoc;
    xpctxt->contextSize = oldXPContextSize;
    xpctxt->proximityPosition = oldXPProximityPosition;
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltFreeTransformContext()

XSLTPUBFUN void XSLTCALL xsltFreeTransformContext

(

xsltTransformContextPtr

ctxt

)

xsltFreeTransformContext: @ctxt: an XSLT transform context

Free up the memory allocated by @ctxt

Definition at line 721 of file transform.c.

                                                       {
    if (ctxt == NULL)
    return;
 
    /*
     * Shutdown the extension modules associated to the stylesheet
     * used if needed.
     */
    xsltShutdownCtxtExts(ctxt);
 
    if (ctxt->xpathCtxt != NULL) {
    ctxt->xpathCtxt->nsHash = NULL;
    xmlXPathFreeContext(ctxt->xpathCtxt);
    }
    if (ctxt->templTab != NULL)
    xmlFree(ctxt->templTab);
    if (ctxt->varsTab != NULL)
    xmlFree(ctxt->varsTab);
    if (ctxt->profTab != NULL)
    xmlFree(ctxt->profTab);
    if ((ctxt->extrasNr > 0) && (ctxt->extras != NULL)) {
    int i;
 
    for (i = 0;i < ctxt->extrasNr;i++) {
        if ((ctxt->extras[i].deallocate != NULL) &&
        (ctxt->extras[i].info != NULL))
        ctxt->extras[i].deallocate(ctxt->extras[i].info);
    }
    xmlFree(ctxt->extras);
    }
    xsltFreeGlobalVariables(ctxt);
    xsltFreeDocuments(ctxt);
    xsltFreeCtxtExts(ctxt);
    xsltFreeRVTs(ctxt);
    xsltTransformCacheFree(ctxt->cache);
    xmlDictFree(ctxt->dict);
#ifdef WITH_XSLT_DEBUG
    xsltGenericDebug(xsltGenericDebugContext,
                     "freeing transformation dictionary\n");
#endif
    memset(ctxt, -1, sizeof(xsltTransformContext));
    xmlFree(ctxt);
}

Referenced by node_transform_node_params(), xsltApplyStylesheetInternal(), and xsltNewTransformContext().

xsltGetXIncludeDefault()

XSLTPUBFUN int XSLTCALL xsltGetXIncludeDefault

(

void

)

xsltGetXIncludeDefault:

Provides the default state for XInclude processing

Returns 0 if there is no processing 1 otherwise

Definition at line 465 of file transform.c.

                             {
    return(xsltDoXIncludeDefault);
}

Referenced by xsltNewTransformContext().

xsltIf()

XSLTPUBFUN void XSLTCALL xsltIf	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	contextNode,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltIf: @ctxt: a XSLT process context @contextNode: the current node in the source tree @inst: the xsl:if instruction @castedComp: compiled information of the instruction

Processes the xsl:if instruction on the source node.

Definition at line 5295 of file transform.c.

{
    int res = 0;
 
#ifdef XSLT_REFACTORED
    xsltStyleItemIfPtr comp = (xsltStyleItemIfPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
 
    if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL))
    return;
    if ((comp == NULL) || (comp->test == NULL) || (comp->comp == NULL)) {
    xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltIf(): "
        "The XSLT 'if' instruction was not compiled.\n");
    return;
    }
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_IF,xsltGenericDebug(xsltGenericDebugContext,
     "xsltIf: test %s\n", comp->test));
#endif
 
#ifdef XSLT_FAST_IF
    {
    xmlDocPtr oldLocalFragmentTop = ctxt->localRVT;
 
    res = xsltPreCompEvalToBoolean(ctxt, contextNode, comp);
 
    /*
    * Cleanup fragments created during evaluation of the
    * "select" expression.
    */
    if (oldLocalFragmentTop != ctxt->localRVT)
        xsltReleaseLocalRVTs(ctxt, oldLocalFragmentTop);
    }
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_IF,xsltGenericDebug(xsltGenericDebugContext,
    "xsltIf: test evaluate to %d\n", res));
#endif
 
    if (res == -1) {
    ctxt->state = XSLT_STATE_STOPPED;
    goto error;
    }
    if (res == 1) {
    /*
    * Instantiate the sequence constructor of xsl:if.
    */
    xsltApplySequenceConstructor(ctxt,
        contextNode, inst->children, NULL);
    }
 
#else /* XSLT_FAST_IF */
    {
    /*
    * OLD CODE:
    */
    xmlXPathObjectPtr xpobj = xsltPreCompEval(ctxt, contextNode, comp);
    if (xpobj != NULL) {
        if (xpobj->type != XPATH_BOOLEAN)
        xpobj = xmlXPathConvertBoolean(xpobj);
        if (xpobj->type == XPATH_BOOLEAN) {
        res = xpobj->boolval;
 
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt,XSLT_TRACE_IF,xsltGenericDebug(xsltGenericDebugContext,
            "xsltIf: test evaluate to %d\n", res));
#endif
        if (res) {
            xsltApplySequenceConstructor(ctxt,
            contextNode, inst->children, NULL);
        }
        } else {
 
#ifdef WITH_XSLT_DEBUG_PROCESS
        XSLT_TRACE(ctxt, XSLT_TRACE_IF,
            xsltGenericDebug(xsltGenericDebugContext,
            "xsltIf: test didn't evaluate to a boolean\n"));
#endif
        ctxt->state = XSLT_STATE_STOPPED;
        }
        xmlXPathFreeObject(xpobj);
    } else {
        ctxt->state = XSLT_STATE_STOPPED;
    }
    }
#endif /* else of XSLT_FAST_IF */
 
error:
    return;
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltLocalVariablePop()

XSLTPUBFUN void XSLTCALL xsltLocalVariablePop	(	xsltTransformContextPtr	ctxt,
		int	limitNr,
		int	level
	)

xsltLocalVariablePop: @ctxt: the transformation context @limitNr: number of variables which should remain @level: the depth in the xsl:template's tree

Pops all variable values at the given @depth from the stack.

Returns the stored variable value NOTE: This is an internal routine and should not be called by users!

Definition at line 178 of file transform.c.

{
    xsltStackElemPtr variable;
 
    if (ctxt->varsNr <= 0)
        return;
 
    do {
    if (ctxt->varsNr <= limitNr)
        break;
    variable = ctxt->varsTab[ctxt->varsNr - 1];
    if (variable->level <= level)
        break;
    if (variable->level >= 0)
        xsltFreeStackElemList(variable);
    ctxt->varsNr--;
    } while (ctxt->varsNr != 0);
    if (ctxt->varsNr > 0)
        ctxt->vars = ctxt->varsTab[ctxt->varsNr - 1];
    else
        ctxt->vars = NULL;
}

Referenced by xsltApplyOneTemplate(), xsltApplySequenceConstructor(), and xsltApplyStylesheetInternal().

xsltLocalVariablePush()

XSLTPUBFUN int XSLTCALL xsltLocalVariablePush	(	xsltTransformContextPtr	ctxt,
		xsltStackElemPtr	variable,
		int	level
	)

xsltLocalVariablePush: @ctxt: the transformation context @variable: variable to be pushed to the variable stack @level: new value for variable's level

Places the variable onto the local variable stack

Returns: 0 for success, -1 for any error NOTE: This is an internal routine and should not be called by users!

Definition at line 2236 of file transform.c.

{
    if (ctxt->varsNr >= ctxt->varsMax) {
        xsltStackElemPtr *tmp;
        int newMax = ctxt->varsMax == 0 ? 10 : 2 * ctxt->varsMax;
 
    tmp = (xsltStackElemPtr *) xmlRealloc(ctxt->varsTab,
                newMax * sizeof(*tmp));
    if (tmp == NULL) {
        xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
        return (-1);
    }
        ctxt->varsTab = tmp;
        ctxt->varsMax = newMax;
    }
    ctxt->varsTab[ctxt->varsNr++] = variable;
    ctxt->vars = variable;
    variable->level = level;
    return(0);
}

Referenced by xsltApplyOneTemplate(), and xsltApplyXSLTTemplate().

xsltNewTransformContext()

XSLTPUBFUN xsltTransformContextPtr XSLTCALL xsltNewTransformContext	(	xsltStylesheetPtr	style,
		xmlDocPtr	doc
	)

Export context to users.

xsltNewTransformContext: @style: a parsed XSLT stylesheet @doc: the input document

Create a new XSLT TransformContext

Returns the newly allocated xsltTransformContextPtr or NULL in case of error

Definition at line 564 of file transform.c.

                                                                {
    xsltTransformContextPtr cur;
    xsltDocumentPtr docu;
    int i;
 
    xsltInitGlobals();
 
    cur = (xsltTransformContextPtr) xmlMalloc(sizeof(xsltTransformContext));
    if (cur == NULL) {
    xsltTransformError(NULL, NULL, (xmlNodePtr)doc,
        "xsltNewTransformContext : malloc failed\n");
    return(NULL);
    }
    memset(cur, 0, sizeof(xsltTransformContext));
 
    cur->cache = xsltTransformCacheCreate();
    if (cur->cache == NULL)
    goto internal_err;
    /*
     * setup of the dictionary must be done early as some of the
     * processing later like key handling may need it.
     */
    cur->dict = xmlDictCreateSub(style->dict);
    cur->internalized = ((style->internalized) && (cur->dict != NULL));
#ifdef WITH_XSLT_DEBUG
    xsltGenericDebug(xsltGenericDebugContext,
         "Creating sub-dictionary from stylesheet for transformation\n");
#endif
 
    /*
     * initialize the template stack
     */
    cur->templTab = (xsltTemplatePtr *)
            xmlMalloc(10 * sizeof(xsltTemplatePtr));
    if (cur->templTab == NULL) {
    xsltTransformError(NULL, NULL, (xmlNodePtr) doc,
        "xsltNewTransformContext: out of memory\n");
    goto internal_err;
    }
    cur->templNr = 0;
    cur->templMax = 5;
    cur->templ = NULL;
    cur->maxTemplateDepth = xsltMaxDepth;
 
    /*
     * initialize the variables stack
     */
    cur->varsTab = (xsltStackElemPtr *)
            xmlMalloc(10 * sizeof(xsltStackElemPtr));
    if (cur->varsTab == NULL) {
        xmlGenericError(xmlGenericErrorContext,
        "xsltNewTransformContext: out of memory\n");
    goto internal_err;
    }
    cur->varsNr = 0;
    cur->varsMax = 10;
    cur->vars = NULL;
    cur->varsBase = 0;
    cur->maxTemplateVars = xsltMaxVars;
 
    /*
     * the profiling stack is not initialized by default
     */
    cur->profTab = NULL;
    cur->profNr = 0;
    cur->profMax = 0;
    cur->prof = 0;
 
    cur->style = style;
    cur->xpathCtxt = xmlXPathNewContext(doc);
    if (cur->xpathCtxt == NULL) {
    xsltTransformError(NULL, NULL, (xmlNodePtr) doc,
        "xsltNewTransformContext : xmlXPathNewContext failed\n");
    goto internal_err;
    }
    /*
    * Create an XPath cache.
    */
    if (xmlXPathContextSetCache(cur->xpathCtxt, 1, -1, 0) == -1)
    goto internal_err;
    /*
     * Initialize the extras array
     */
    if (style->extrasNr != 0) {
    cur->extrasMax = style->extrasNr + 20;
    cur->extras = (xsltRuntimeExtraPtr)
        xmlMalloc(cur->extrasMax * sizeof(xsltRuntimeExtra));
    if (cur->extras == NULL) {
        xmlGenericError(xmlGenericErrorContext,
            "xsltNewTransformContext: out of memory\n");
        goto internal_err;
    }
    cur->extrasNr = style->extrasNr;
    for (i = 0;i < cur->extrasMax;i++) {
        cur->extras[i].info = NULL;
        cur->extras[i].deallocate = NULL;
        cur->extras[i].val.ptr = NULL;
    }
    } else {
    cur->extras = NULL;
    cur->extrasNr = 0;
    cur->extrasMax = 0;
    }
 
    XSLT_REGISTER_VARIABLE_LOOKUP(cur);
    XSLT_REGISTER_FUNCTION_LOOKUP(cur);
    cur->xpathCtxt->nsHash = style->nsHash;
    /*
     * Initialize the registered external modules
     */
    xsltInitCtxtExts(cur);
    /*
     * Setup document element ordering for later efficiencies
     * (bug 133289)
     */
    if (xslDebugStatus == XSLT_DEBUG_NONE)
        xmlXPathOrderDocElems(doc);
    /*
     * Must set parserOptions before calling xsltNewDocument
     * (bug 164530)
     */
    cur->parserOptions = XSLT_PARSE_OPTIONS;
    docu = xsltNewDocument(cur, doc);
    if (docu == NULL) {
    xsltTransformError(cur, NULL, (xmlNodePtr)doc,
        "xsltNewTransformContext : xsltNewDocument failed\n");
    goto internal_err;
    }
    docu->main = 1;
    cur->document = docu;
    cur->inst = NULL;
    cur->outputFile = NULL;
    cur->sec = xsltGetDefaultSecurityPrefs();
    cur->debugStatus = xslDebugStatus;
    cur->traceCode = (unsigned long*) &xsltDefaultTrace;
    cur->xinclude = xsltGetXIncludeDefault();
    cur->keyInitLevel = 0;
 
    cur->newLocale = xsltNewLocale;
    cur->freeLocale = xsltFreeLocale;
    cur->genSortKey = xsltStrxfrm;
 
    return(cur);
 
internal_err:
    if (cur != NULL)
    xsltFreeTransformContext(cur);
    return(NULL);
}

Referenced by node_transform_node_params(), and xsltApplyStylesheetInternal().

xsltNumber()

XSLTPUBFUN void XSLTCALL xsltNumber	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltNumber: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt number node @castedComp: precomputed information

Process the xslt number node on the source node

Definition at line 4593 of file transform.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemNumberPtr comp = (xsltStyleItemNumberPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    xmlXPathContextPtr xpctxt;
    xmlNsPtr *oldXPNamespaces;
    int oldXPNsNr;
 
    if (comp == NULL) {
    xsltTransformError(ctxt, NULL, inst,
         "xsl:number : compilation failed\n");
    return;
    }
 
    if ((ctxt == NULL) || (node == NULL) || (inst == NULL) || (comp == NULL))
    return;
 
    comp->numdata.doc = inst->doc;
    comp->numdata.node = inst;
 
    xpctxt = ctxt->xpathCtxt;
    oldXPNsNr = xpctxt->nsNr;
    oldXPNamespaces = xpctxt->namespaces;
 
#ifdef XSLT_REFACTORED
    if (comp->inScopeNs != NULL) {
        xpctxt->namespaces = comp->inScopeNs->list;
        xpctxt->nsNr = comp->inScopeNs->xpathNumber;
    } else {
        xpctxt->namespaces = NULL;
        xpctxt->nsNr = 0;
    }
#else
    xpctxt->namespaces = comp->nsList;
    xpctxt->nsNr = comp->nsNr;
#endif
 
    xsltNumberFormat(ctxt, &comp->numdata, node);
 
    xpctxt->nsNr = oldXPNsNr;
    xpctxt->namespaces = oldXPNamespaces;
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltProcessingInstruction()

XSLTPUBFUN void XSLTCALL xsltProcessingInstruction	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltProcessingInstruction: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt processing-instruction node @castedComp: precomputed information

Process the xslt processing-instruction node on the source node

Definition at line 4309 of file transform.c.

                                                               {
#ifdef XSLT_REFACTORED
    xsltStyleItemPIPtr comp = (xsltStyleItemPIPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    const xmlChar *name;
    xmlChar *value = NULL;
    xmlNodePtr pi;
 
 
    if (ctxt->insert == NULL)
    return;
    if (comp->has_name == 0)
    return;
    if (comp->name == NULL) {
    name = xsltEvalAttrValueTemplate(ctxt, inst,
                (const xmlChar *)"name", NULL);
    if (name == NULL) {
        xsltTransformError(ctxt, NULL, inst,
         "xsl:processing-instruction : name is missing\n");
        goto error;
    }
    } else {
    name = comp->name;
    }
    /* TODO: check that it's both an an NCName and a PITarget. */
 
 
    value = xsltEvalTemplateString(ctxt, node, inst);
    if (xmlStrstr(value, BAD_CAST "?>") != NULL) {
    xsltTransformError(ctxt, NULL, inst,
         "xsl:processing-instruction: '?>' not allowed within PI content\n");
    goto error;
    }
#ifdef WITH_XSLT_DEBUG_PROCESS
    if (value == NULL) {
    XSLT_TRACE(ctxt,XSLT_TRACE_PI,xsltGenericDebug(xsltGenericDebugContext,
         "xsltProcessingInstruction: %s empty\n", name));
    } else {
    XSLT_TRACE(ctxt,XSLT_TRACE_PI,xsltGenericDebug(xsltGenericDebugContext,
         "xsltProcessingInstruction: %s content %s\n", name, value));
    }
#endif
 
    pi = xmlNewDocPI(ctxt->insert->doc, name, value);
    pi = xsltAddChild(ctxt->insert, pi);
 
error:
    if ((name != NULL) && (name != comp->name))
        xmlFree((xmlChar *) name);
    if (value != NULL)
    xmlFree(value);
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltProcessOneNode()

XSLTPUBFUN void XSLTCALL xsltProcessOneNode	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	contextNode,
		xsltStackElemPtr	withParams
	)

xsltProcessOneNode: @ctxt: a XSLT process context @contextNode: the "current node" in the source tree @withParams: extra parameters (e.g. xsl:with-param) passed to the template if any

Process the source node.

Definition at line 2112 of file transform.c.

{
    xsltTemplatePtr templ;
    xmlNodePtr oldNode;
 
    templ = xsltGetTemplate(ctxt, contextNode, NULL);
    /*
     * If no template is found, apply the default rule.
     */
    if (templ == NULL) {
#ifdef WITH_XSLT_DEBUG_PROCESS
    if (contextNode->type == XML_DOCUMENT_NODE) {
        XSLT_TRACE(ctxt,XSLT_TRACE_PROCESS_NODE,xsltGenericDebug(xsltGenericDebugContext,
         "xsltProcessOneNode: no template found for /\n"));
    } else if (contextNode->type == XML_CDATA_SECTION_NODE) {
        XSLT_TRACE(ctxt,XSLT_TRACE_PROCESS_NODE,xsltGenericDebug(xsltGenericDebugContext,
         "xsltProcessOneNode: no template found for CDATA\n"));
    } else if (contextNode->type == XML_ATTRIBUTE_NODE) {
        XSLT_TRACE(ctxt,XSLT_TRACE_PROCESS_NODE,xsltGenericDebug(xsltGenericDebugContext,
         "xsltProcessOneNode: no template found for attribute %s\n",
                         ((xmlAttrPtr) contextNode)->name));
    } else  {
        XSLT_TRACE(ctxt,XSLT_TRACE_PROCESS_NODE,xsltGenericDebug(xsltGenericDebugContext,
         "xsltProcessOneNode: no template found for %s\n", contextNode->name));
        }
#endif
    oldNode = ctxt->node;
    ctxt->node = contextNode;
    xsltDefaultProcessOneNode(ctxt, contextNode, withParams);
    ctxt->node = oldNode;
    return;
    }
 
    if (contextNode->type == XML_ATTRIBUTE_NODE) {
    xsltTemplatePtr oldCurTempRule = ctxt->currentTemplateRule;
    /*
    * Set the "current template rule".
    */
    ctxt->currentTemplateRule = templ;
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_PROCESS_NODE,xsltGenericDebug(xsltGenericDebugContext,
         "xsltProcessOneNode: applying template '%s' for attribute %s\n",
                     templ->match, contextNode->name));
#endif
    xsltApplyXSLTTemplate(ctxt, contextNode, templ->content, templ, withParams);
 
    ctxt->currentTemplateRule = oldCurTempRule;
    } else {
    xsltTemplatePtr oldCurTempRule = ctxt->currentTemplateRule;
    /*
    * Set the "current template rule".
    */
    ctxt->currentTemplateRule = templ;
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    if (contextNode->type == XML_DOCUMENT_NODE) {
        XSLT_TRACE(ctxt,XSLT_TRACE_PROCESS_NODE,xsltGenericDebug(xsltGenericDebugContext,
         "xsltProcessOneNode: applying template '%s' for /\n",
                         templ->match));
    } else {
        XSLT_TRACE(ctxt,XSLT_TRACE_PROCESS_NODE,xsltGenericDebug(xsltGenericDebugContext,
         "xsltProcessOneNode: applying template '%s' for %s\n",
                         templ->match, contextNode->name));
        }
#endif
    xsltApplyXSLTTemplate(ctxt, contextNode, templ->content, templ, withParams);
 
    ctxt->currentTemplateRule = oldCurTempRule;
    }
}

Referenced by xsltApplyStylesheetInternal(), xsltApplyTemplates(), and xsltDefaultProcessOneNode().

xsltProfileStylesheet()

XSLTPUBFUN xmlDocPtr XSLTCALL xsltProfileStylesheet	(	xsltStylesheetPtr	style,
		xmlDocPtr	doc,
		const char **	params,
		FILE *	output
	)

xsltProfileStylesheet: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated arry of parameters names/values tuples @output: a FILE * for the profiling output

Apply the stylesheet to the document and dump the profiling to the given output.

Returns the result document or NULL in case of error

Definition at line 6249 of file transform.c.

{
    xmlDocPtr res;
 
    res = xsltApplyStylesheetInternal(style, doc, params, NULL, output, NULL);
    return (res);
}

xsltRegisterAllElement()

XSLTPUBFUN void XSLTCALL xsltRegisterAllElement

(

xsltTransformContextPtr

ctxt

)

xsltRegisterAllElement: @ctxt: the XPath context

Registers all default XSLT elements in this context

Definition at line 6393 of file transform.c.

{
    xsltRegisterExtElement(ctxt, (const xmlChar *) "apply-templates",
                           XSLT_NAMESPACE,
               xsltApplyTemplates);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "apply-imports",
                           XSLT_NAMESPACE,
               xsltApplyImports);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "call-template",
                           XSLT_NAMESPACE,
               xsltCallTemplate);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "element",
                           XSLT_NAMESPACE,
               xsltElement);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "attribute",
                           XSLT_NAMESPACE,
               xsltAttribute);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "text",
                           XSLT_NAMESPACE,
               xsltText);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "processing-instruction",
                           XSLT_NAMESPACE,
               xsltProcessingInstruction);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "comment",
                           XSLT_NAMESPACE,
               xsltComment);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "copy",
                           XSLT_NAMESPACE,
               xsltCopy);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "value-of",
                           XSLT_NAMESPACE,
               xsltValueOf);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "number",
                           XSLT_NAMESPACE,
               xsltNumber);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "for-each",
                           XSLT_NAMESPACE,
               xsltForEach);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "if",
                           XSLT_NAMESPACE,
               xsltIf);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "choose",
                           XSLT_NAMESPACE,
               xsltChoose);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "sort",
                           XSLT_NAMESPACE,
               xsltSort);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "copy-of",
                           XSLT_NAMESPACE,
               xsltCopyOf);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "message",
                           XSLT_NAMESPACE,
               xsltMessageWrapper);
 
    /*
     * Those don't have callable entry points but are registered anyway
     */
    xsltRegisterExtElement(ctxt, (const xmlChar *) "variable",
                           XSLT_NAMESPACE,
               xsltDebug);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "param",
                           XSLT_NAMESPACE,
               xsltDebug);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "with-param",
                           XSLT_NAMESPACE,
               xsltDebug);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "decimal-format",
                           XSLT_NAMESPACE,
               xsltDebug);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "when",
                           XSLT_NAMESPACE,
               xsltDebug);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "otherwise",
                           XSLT_NAMESPACE,
               xsltDebug);
    xsltRegisterExtElement(ctxt, (const xmlChar *) "fallback",
                           XSLT_NAMESPACE,
               xsltDebug);
 
}

xsltRunStylesheet()

XSLTPUBFUN int XSLTCALL xsltRunStylesheet	(	xsltStylesheetPtr	style,
		xmlDocPtr	doc,
		const char **	params,
		const char *	output,
		xmlSAXHandlerPtr	SAX,
		xmlOutputBufferPtr	IObuf
	)

xsltRunStylesheet: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated array of parameters names/values tuples @output: the URL/filename ot the generated resource if available @SAX: a SAX handler for progressive callback output (not implemented yet) @IObuf: an output buffer for progressive output (not implemented yet)

Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf.

NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8

Returns the number of bytes written to the main resource or -1 in case of error.

Definition at line 6372 of file transform.c.

{
    return(xsltRunStylesheetUser(style, doc, params, output, SAX, IObuf,
                         NULL, NULL));
}

xsltRunStylesheetUser()

XSLTPUBFUN int XSLTCALL xsltRunStylesheetUser	(	xsltStylesheetPtr	style,
		xmlDocPtr	doc,
		const char **	params,
		const char *	output,
		xmlSAXHandlerPtr	SAX,
		xmlOutputBufferPtr	IObuf,
		FILE *	profile,
		xsltTransformContextPtr	userCtxt
	)

xsltRunStylesheetUser: @style: a parsed XSLT stylesheet @doc: a parsed XML document @params: a NULL terminated array of parameters names/values tuples @output: the URL/filename ot the generated resource if available @SAX: a SAX handler for progressive callback output (not implemented yet) @IObuf: an output buffer for progressive output (not implemented yet) @profile: profile FILE * output or NULL @userCtxt: user provided transform context

Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf.

NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8

Returns the number of by written to the main resource or -1 in case of error.

Definition at line 6311 of file transform.c.

{
    xmlDocPtr tmp;
    int ret;
 
    if ((output == NULL) && (SAX == NULL) && (IObuf == NULL))
        return (-1);
    if ((SAX != NULL) && (IObuf != NULL))
        return (-1);
 
    /* unsupported yet */
    if (SAX != NULL) {
        XSLT_TODO   /* xsltRunStylesheet xmlSAXHandlerPtr SAX */
    return (-1);
    }
 
    tmp = xsltApplyStylesheetInternal(style, doc, params, output, profile,
                                  userCtxt);
    if (tmp == NULL) {
    xsltTransformError(NULL, NULL, (xmlNodePtr) doc,
                         "xsltRunStylesheet : run failed\n");
        return (-1);
    }
    if (IObuf != NULL) {
        /* TODO: incomplete, IObuf output not progressive */
        ret = xsltSaveResultTo(IObuf, tmp, style);
    } else {
        ret = xsltSaveResultToFilename(output, tmp, style, 0);
    }
    xmlFreeDoc(tmp);
    return (ret);
}

Referenced by xsltRunStylesheet().

xsltSetXIncludeDefault()

XSLTPUBFUN void XSLTCALL xsltSetXIncludeDefault

(

int

xinclude

)

XInclude default processing.

xsltSetXIncludeDefault: @xinclude: whether to do XInclude processing

Set whether XInclude should be processed on document being loaded by default

Definition at line 453 of file transform.c.

                                     {
    xsltDoXIncludeDefault = (xinclude != 0);
}

xsltSort()

XSLTPUBFUN void XSLTCALL xsltSort	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr node	ATTRIBUTE_UNUSED,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	comp
	)

xsltSort: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt sort node @comp: precomputed information

function attached to xsl:sort nodes, but this should not be called directly

Definition at line 3879 of file transform.c.

                             {
    if (comp == NULL) {
    xsltTransformError(ctxt, NULL, inst,
         "xsl:sort : compilation failed\n");
    return;
    }
    xsltTransformError(ctxt, NULL, inst,
     "xsl:sort : improper use this should not be reached\n");
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltText()

XSLTPUBFUN void XSLTCALL xsltText	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr node	ATTRIBUTE_UNUSED,
		xmlNodePtr	inst,
		xsltElemPreCompPtr comp	ATTRIBUTE_UNUSED
	)

xsltText: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt text node @comp: precomputed information

Process the xslt text node on the source node

Definition at line 4020 of file transform.c.

                                                                   {
    if ((inst->children != NULL) && (comp != NULL)) {
    xmlNodePtr text = inst->children;
    xmlNodePtr copy;
 
    while (text != NULL) {
        if ((text->type != XML_TEXT_NODE) &&
             (text->type != XML_CDATA_SECTION_NODE)) {
        xsltTransformError(ctxt, NULL, inst,
                 "xsl:text content problem\n");
        break;
        }
        copy = xmlNewDocText(ctxt->output, text->content);
        if (text->type != XML_CDATA_SECTION_NODE) {
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
             "Disable escaping: %s\n", text->content);
#endif
        copy->name = xmlStringTextNoenc;
        }
        copy = xsltAddChild(ctxt->insert, copy);
        text = text->next;
    }
    }
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltValueOf()

XSLTPUBFUN void XSLTCALL xsltValueOf	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltValueOf: @ctxt: a XSLT process context @node: the node in the source tree. @inst: the xslt value-of node @castedComp: precomputed information

Process the xslt value-of node on the source node

Definition at line 4519 of file transform.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemValueOfPtr comp = (xsltStyleItemValueOfPtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    xmlXPathObjectPtr res = NULL;
    xmlChar *value = NULL;
 
    if ((ctxt == NULL) || (node == NULL) || (inst == NULL))
    return;
 
    if ((comp == NULL) || (comp->select == NULL) || (comp->comp == NULL)) {
    xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltValueOf(): "
        "The XSLT 'value-of' instruction was not compiled.\n");
    return;
    }
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    XSLT_TRACE(ctxt,XSLT_TRACE_VALUE_OF,xsltGenericDebug(xsltGenericDebugContext,
     "xsltValueOf: select %s\n", comp->select));
#endif
 
    res = xsltPreCompEval(ctxt, node, comp);
 
    /*
    * Cast the XPath object to string.
    */
    if (res != NULL) {
    value = xmlXPathCastToString(res);
    if (value == NULL) {
        xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltValueOf(): "
        "failed to cast an XPath object to string.\n");
        ctxt->state = XSLT_STATE_STOPPED;
        goto error;
    }
    if (value[0] != 0) {
        xsltCopyTextString(ctxt, ctxt->insert, value, comp->noescape);
    }
    } else {
    xsltTransformError(ctxt, NULL, inst,
        "XPath evaluation returned no result.\n");
    ctxt->state = XSLT_STATE_STOPPED;
    goto error;
    }
 
#ifdef WITH_XSLT_DEBUG_PROCESS
    if (value) {
    XSLT_TRACE(ctxt,XSLT_TRACE_VALUE_OF,xsltGenericDebug(xsltGenericDebugContext,
         "xsltValueOf: result '%s'\n", value));
    }
#endif
 
error:
    if (value != NULL)
    xmlFree(value);
    if (res != NULL)
    xmlXPathFreeObject(res);
}

Referenced by xsltNewStylePreComp(), and xsltRegisterAllElement().