#include "libxslt.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <time.h>
#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/HTMLtree.h>
#include <libxml/xmlerror.h>
#include <libxml/xmlIO.h>
#include "xsltutils.h"
#include "templates.h"
#include "xsltInternals.h"
#include "imports.h"
#include "transform.h"

Include dependency graph for xsltutils.c:

Macros
#define	IN_LIBXSLT

Functions
: the full QName
xsltSplitQName: @dict: a dictionary @prefix: the return value Split QNames into prefix and local names, both allocated from a dictionary. Returns: the localname or NULL in case of error.
const xmlChar *	xsltSplitQName (xmlDictPtr dict, const xmlChar name, const xmlChar *prefix)

: the attribute name
xsltGetNsProp: @node: the node @nameSpace: the URI of the namespace Similar to xmlGetNsProp() but with a slightly different semantic Search and get the value of an attribute associated to a node This attribute has to be anchored in the namespace specified, or has no namespace and the element is in that namespace. This does the entity substitution. This function looks in DTD attribute declaration for FIXED or default declaration values unless DTD use has been turned off. Returns the attribute value or NULL if not found. It's up to the caller to free the memory.
#define	XSLT_GET_VAR_STR(msg, str)

xmlGenericErrorFunc	xsltGenericError = xsltGenericErrorDefaultFunc

void *	xsltGenericErrorContext = NULL

xmlGenericErrorFunc	xsltGenericDebug = xsltGenericDebugDefaultFunc

void *	xsltGenericDebugContext = NULL

const xmlChar *	xsltGetCNsProp (xsltStylesheetPtr style, xmlNodePtr node, const xmlChar name, const xmlChar nameSpace)

xmlChar *	xsltGetNsProp (xmlNodePtr node, const xmlChar name, const xmlChar nameSpace)

int	xsltGetUTF8Char (const unsigned char utf, int len)

int	xsltGetUTF8CharZ (const unsigned char utf, int len)

void	xsltMessage (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst)

static void	LIBXSLT_ATTR_FORMAT (2, 3)

void	xsltSetGenericErrorFunc (void *ctx, xmlGenericErrorFunc handler)

void	xsltSetGenericDebugFunc (void *ctx, xmlGenericErrorFunc handler)

void	xsltPrintErrorContext (xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node)

void	xsltSetTransformErrorFunc (xsltTransformContextPtr ctxt, void *ctx, xmlGenericErrorFunc handler)

void	xsltTransformError (xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)

is
not prefixed.
static xsltSortFunc	xsltSortFunction = xsltDefaultSortFunction

int	xslDebugStatus

const xmlChar *	xsltGetQNameURI (xmlNodePtr node, xmlChar **name)

const xmlChar *	xsltGetQNameURI2 (xsltStylesheetPtr style, xmlNodePtr node, const xmlChar **name)

void	xsltDocumentSortFunction (xmlNodeSetPtr list)

static xmlXPathObjectPtr *	xsltComputeSortResultInternal (xsltTransformContextPtr ctxt, xmlNodePtr sort, int number, void *locale)

xmlXPathObjectPtr *	xsltComputeSortResult (xsltTransformContextPtr ctxt, xmlNodePtr sort)

void	xsltDefaultSortFunction (xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)

void	xsltDoSortFunction (xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)

void	xsltSetSortFunc (xsltSortFunc handler)

void	xsltSetCtxtSortFunc (xsltTransformContextPtr ctxt, xsltSortFunc handler)

void	xsltSetCtxtLocaleHandlers (xsltTransformContextPtr ctxt, xsltNewLocaleFunc newLocale, xsltFreeLocaleFunc freeLocale, xsltGenSortKeyFunc genSortKey)

int	xsltSetCtxtParseOptions (xsltTransformContextPtr ctxt, int options)

int	xsltSaveResultTo (xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style)

int	xsltSaveResultToFilename (const char *URL, xmlDocPtr result, xsltStylesheetPtr style, int compression)

int	xsltSaveResultToFile (FILE *file, xmlDocPtr result, xsltStylesheetPtr style)

int	xsltSaveResultToFd (int fd, xmlDocPtr result, xsltStylesheetPtr style)

int	xsltSaveResultToString (xmlChar *doc_txt_ptr, int doc_txt_len, xmlDocPtr result, xsltStylesheetPtr style)

int	xsltGetSourceNodeFlags (xmlNodePtr node)

int	xsltSetSourceNodeFlags (xsltTransformContextPtr ctxt, xmlNodePtr node, int flags)

int	xsltClearSourceNodeFlags (xmlNodePtr node, int flags)

void **	xsltGetPSVIPtr (xmlNodePtr cur)

xmlXPathCompExprPtr	xsltXPathCompileFlags (xsltStylesheetPtr style, const xmlChar *str, int flags)

xmlXPathCompExprPtr	xsltXPathCompile (xsltStylesheetPtr style, const xmlChar *str)

int	xsltGetDebuggerStatus (void)

Detailed Description

Returns the number of bytes written or -1 in case of failure.

Definition in file xsltutils.c.

Macro Definition Documentation

◆ IN_LIBXSLT

#define IN_LIBXSLT

Definition at line 12 of file xsltutils.c.

◆ XSLT_GET_VAR_STR

#define XSLT_GET_VAR_STR	(	msg,
		str
	)

Value:

    {               \
    int       size;                     \
    int       chars;                        \
    char      *larger;                      \
    va_list   ap;                       \
                                \
    str = (char *) xmlMalloc(150);              \
    if (str == NULL)                        \
    return;                         \
                                \
    size = 150;                         \
                                \
    while (size < 64000) {                  \
    va_start(ap, msg);                  \
    chars = vsnprintf(str, size, msg, ap);          \
    va_end(ap);                     \
    if ((chars > -1) && (chars < size))         \
        break;                      \
    if (chars > -1)                     \
        size += chars + 1;                  \
    else                            \
        size += 100;                    \
    if ((larger = (char *) xmlRealloc(str, size)) == NULL) {\
        xmlFree(str);                   \
        return;                     \
    }                           \
    str = larger;                       \
    }                               \
}

Definition at line 537 of file xsltutils.c.

Function Documentation

◆ LIBXSLT_ATTR_FORMAT()

static void LIBXSLT_ATTR_FORMAT	(	2	,
		3
	)

static

xsltGenericErrorDefaultFunc: @ctx: an error context @msg: the message to display/transmit ...: extra parameters for the message display

Default handler for out of context error messages.

xsltGenericDebugDefaultFunc: @ctx: an error context @msg: the message to display/transmit ...: extra parameters for the message display

Default handler for out of context error messages.

Definition at line 574 of file xsltutils.c.

                                                                              {
    va_list args;
 
    if (xsltGenericErrorContext == NULL)
    xsltGenericErrorContext = (void *) stderr;
 
    va_start(args, msg);
    vfprintf((FILE *)xsltGenericErrorContext, msg, args);
    va_end(args);
}

◆ xsltClearSourceNodeFlags()

int xsltClearSourceNodeFlags	(	xmlNodePtr	node,
		int	flags
	)

xsltClearSourceNodeFlags: @node: Node from source document @flags: Flags

Sets the specified flags to 0.

Returns 0 on success, -1 on error.

Definition at line 1999 of file xsltutils.c.

                                                     {
    switch (node->type) {
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE:
            ((xmlDocPtr) node)->properties &= ~(flags << 27);
            return 0;
 
        case XML_ATTRIBUTE_NODE:
            ((xmlAttrPtr) node)->atype &= ~(flags << 27);
            return 0;
 
        case XML_ELEMENT_NODE:
        case XML_TEXT_NODE:
        case XML_CDATA_SECTION_NODE:
        case XML_PI_NODE:
        case XML_COMMENT_NODE:
            node->extra &= ~(flags << 12);
            return 0;
 
        default:
            return -1;
    }
}

Referenced by xsltCleanupSourceDoc().

◆ xsltComputeSortResult()

xmlXPathObjectPtr * xsltComputeSortResult	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	sort
	)

xsltComputeSortResult: @ctxt: a XSLT process context @sort: node list

reorder the current node list accordingly to the set of sorting requirement provided by the array of nodes.

Returns a ordered XPath nodeset or NULL in case of error.

Definition at line 1161 of file xsltutils.c.

                                                                     {
    const xsltStylePreComp *comp = sort->psvi;
    int number = 0;
 
    if (comp != NULL)
        number = comp->number;
    return xsltComputeSortResultInternal(ctxt, sort, number,
                                         /* locale */ NULL);
}

◆ xsltComputeSortResultInternal()

static xmlXPathObjectPtr * xsltComputeSortResultInternal	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	sort,
		int	number,
		void *	locale
	)

static

xsltComputeSortResultInternal: @ctxt: a XSLT process context @sort: xsl:sort node @number: data-type is number @locale: transform strings according to locale

reorder the current node list accordingly to the set of sorting requirement provided by the array of nodes.

Returns a ordered XPath nodeset or NULL in case of error.

Definition at line 1023 of file xsltutils.c.

                                                        {
#ifdef XSLT_REFACTORED
    xsltStyleItemSortPtr comp;
#else
    const xsltStylePreComp *comp;
#endif
    xmlXPathObjectPtr *results = NULL;
    xmlNodeSetPtr list = NULL;
    xmlXPathObjectPtr res;
    int len = 0;
    int i;
    xmlNodePtr oldNode;
    xmlNodePtr oldInst;
    int oldPos, oldSize ;
    int oldNsNr;
    xmlNsPtr *oldNamespaces;
 
    comp = sort->psvi;
    if (comp == NULL) {
    xsltGenericError(xsltGenericErrorContext,
         "xsl:sort : compilation failed\n");
    return(NULL);
    }
 
    if ((comp->select == NULL) || (comp->comp == NULL))
    return(NULL);
 
    list = ctxt->nodeList;
    if ((list == NULL) || (list->nodeNr <= 1))
    return(NULL);
 
    len = list->nodeNr;
 
    /* TODO: xsl:sort lang attribute */
    /* TODO: xsl:sort case-order attribute */
 
 
    results = xmlMalloc(len * sizeof(xmlXPathObjectPtr));
    if (results == NULL) {
    xsltGenericError(xsltGenericErrorContext,
         "xsltComputeSortResult: memory allocation failure\n");
    return(NULL);
    }
 
    oldNode = ctxt->node;
    oldInst = ctxt->inst;
    oldPos = ctxt->xpathCtxt->proximityPosition;
    oldSize = ctxt->xpathCtxt->contextSize;
    oldNsNr = ctxt->xpathCtxt->nsNr;
    oldNamespaces = ctxt->xpathCtxt->namespaces;
    for (i = 0;i < len;i++) {
    ctxt->inst = sort;
    ctxt->xpathCtxt->contextSize = len;
    ctxt->xpathCtxt->proximityPosition = i + 1;
    ctxt->node = list->nodeTab[i];
    ctxt->xpathCtxt->node = ctxt->node;
#ifdef XSLT_REFACTORED
    if (comp->inScopeNs != NULL) {
        ctxt->xpathCtxt->namespaces = comp->inScopeNs->list;
        ctxt->xpathCtxt->nsNr = comp->inScopeNs->xpathNumber;
    } else {
        ctxt->xpathCtxt->namespaces = NULL;
        ctxt->xpathCtxt->nsNr = 0;
    }
#else
    ctxt->xpathCtxt->namespaces = comp->nsList;
    ctxt->xpathCtxt->nsNr = comp->nsNr;
#endif
    res = xmlXPathCompiledEval(comp->comp, ctxt->xpathCtxt);
    if (res != NULL) {
        if (res->type != XPATH_STRING)
        res = xmlXPathConvertString(res);
        if (number)
        res = xmlXPathConvertNumber(res);
        }
        if (res != NULL) {
        res->index = i; /* Save original pos for dupl resolv */
        if (number) {
        if (res->type == XPATH_NUMBER) {
            results[i] = res;
        } else {
#ifdef WITH_XSLT_DEBUG_PROCESS
            xsltGenericDebug(xsltGenericDebugContext,
            "xsltComputeSortResult: select didn't evaluate to a number\n");
#endif
            results[i] = NULL;
        }
        } else {
        if (res->type == XPATH_STRING) {
            if (locale != NULL) {
            xmlChar *str = res->stringval;
                        xmlChar *sortKey = ctxt->genSortKey(locale, str);
 
                        if (sortKey == NULL) {
                            xsltTransformError(ctxt, NULL, sort,
                                "xsltComputeSortResult: sort key is null\n");
                        } else {
                            res->stringval = sortKey;
                            xmlFree(str);
                        }
            }
 
            results[i] = res;
        } else {
#ifdef WITH_XSLT_DEBUG_PROCESS
            xsltGenericDebug(xsltGenericDebugContext,
            "xsltComputeSortResult: select didn't evaluate to a string\n");
#endif
            results[i] = NULL;
        }
        }
    } else {
        ctxt->state = XSLT_STATE_STOPPED;
        results[i] = NULL;
    }
    }
    ctxt->node = oldNode;
    ctxt->inst = oldInst;
    ctxt->xpathCtxt->contextSize = oldSize;
    ctxt->xpathCtxt->proximityPosition = oldPos;
    ctxt->xpathCtxt->nsNr = oldNsNr;
    ctxt->xpathCtxt->namespaces = oldNamespaces;
 
    return(results);
}

Referenced by xsltComputeSortResult(), and xsltDefaultSortFunction().

◆ xsltDefaultSortFunction()

void xsltDefaultSortFunction	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr *	sorts,
		int	nbsorts
	)

xsltDefaultSortFunction: @ctxt: a XSLT process context @sorts: array of sort nodes @nbsorts: the number of sorts in the array

reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes.

Definition at line 1181 of file xsltutils.c.

                            {
#ifdef XSLT_REFACTORED
    xsltStyleItemSortPtr comp;
#else
    const xsltStylePreComp *comp;
#endif
    xmlXPathObjectPtr *resultsTab[XSLT_MAX_SORT];
    xmlXPathObjectPtr *results = NULL, *res;
    xmlNodeSetPtr list = NULL;
    int len = 0;
    int i, j, incr;
    int tst;
    int depth;
    xmlNodePtr node;
    xmlXPathObjectPtr tmp;
    int number[XSLT_MAX_SORT], desc[XSLT_MAX_SORT];
    void *locale[XSLT_MAX_SORT];
 
    if ((ctxt == NULL) || (sorts == NULL) || (nbsorts <= 0) ||
    (nbsorts >= XSLT_MAX_SORT))
    return;
    if (sorts[0] == NULL)
    return;
    comp = sorts[0]->psvi;
    if (comp == NULL)
    return;
 
    list = ctxt->nodeList;
    if ((list == NULL) || (list->nodeNr <= 1))
    return; /* nothing to do */
 
    for (j = 0; j < nbsorts; j++) {
        xmlChar *lang;
 
    comp = sorts[j]->psvi;
    if ((comp->stype == NULL) && (comp->has_stype != 0)) {
        xmlChar *stype =
        xsltEvalAttrValueTemplate(ctxt, sorts[j],
                      BAD_CAST "data-type", NULL);
        number[j] = 0;
        if (stype != NULL) {
        if (xmlStrEqual(stype, (const xmlChar *) "text"))
            ;
        else if (xmlStrEqual(stype, (const xmlChar *) "number"))
            number[j] = 1;
        else {
            xsltTransformError(ctxt, NULL, sorts[j],
              "xsltDoSortFunction: no support for data-type = %s\n",
              stype);
        }
                xmlFree(stype);
        }
    } else {
        number[j] = comp->number;
        }
    if ((comp->order == NULL) && (comp->has_order != 0)) {
        xmlChar *order = xsltEvalAttrValueTemplate(ctxt, sorts[j],
                                                       BAD_CAST "order", NULL);
        desc[j] = 0;
        if (order != NULL) {
        if (xmlStrEqual(order, (const xmlChar *) "ascending"))
            ;
        else if (xmlStrEqual(order, (const xmlChar *) "descending"))
            desc[j] = 1;
        else {
            xsltTransformError(ctxt, NULL, sorts[j],
                 "xsltDoSortFunction: invalid value %s for order\n",
                 order);
        }
                xmlFree(order);
        }
    } else {
        desc[j] = comp->descending;
    }
    if ((comp->lang == NULL) && (comp->has_lang != 0)) {
            lang = xsltEvalAttrValueTemplate(ctxt, sorts[j],
                              (xmlChar *) "lang",
                              NULL);
    } else {
            lang = (xmlChar *) comp->lang;
        }
        if (lang != NULL) {
            locale[j] = ctxt->newLocale(lang, comp->lower_first);
            if (lang != comp->lang)
                xmlFree(lang);
        } else {
            locale[j] = NULL;
        }
    }
 
    len = list->nodeNr;
 
    resultsTab[0] = xsltComputeSortResultInternal(ctxt, sorts[0], number[0],
                                                  locale[0]);
    for (i = 1;i < XSLT_MAX_SORT;i++)
    resultsTab[i] = NULL;
 
    results = resultsTab[0];
 
    comp = sorts[0]->psvi;
    if (results == NULL)
    goto cleanup;
 
    /* Shell's sort of node-set */
    for (incr = len / 2; incr > 0; incr /= 2) {
    for (i = incr; i < len; i++) {
        j = i - incr;
        if (results[i] == NULL)
        continue;
 
        while (j >= 0) {
        if (results[j] == NULL)
            tst = 1;
        else {
            if (number[0]) {
            /* We make NaN smaller than number in accordance
               with XSLT spec */
            if (xmlXPathIsNaN(results[j]->floatval)) {
                if (xmlXPathIsNaN(results[j + incr]->floatval))
                tst = 0;
                else
                tst = -1;
            } else if (xmlXPathIsNaN(results[j + incr]->floatval))
                tst = 1;
            else if (results[j]->floatval ==
                results[j + incr]->floatval)
                tst = 0;
            else if (results[j]->floatval >
                results[j + incr]->floatval)
                tst = 1;
            else tst = -1;
            } else {
            tst = xmlStrcmp(results[j]->stringval,
                     results[j + incr]->stringval);
            }
            if (desc[0])
            tst = -tst;
        }
        if (tst == 0) {
            /*
             * Okay we need to use multi level sorts
             */
            depth = 1;
            while (depth < nbsorts) {
            if (sorts[depth] == NULL)
                break;
            comp = sorts[depth]->psvi;
            if (comp == NULL)
                break;
 
            /*
             * Compute the result of the next level for the
             * full set, this might be optimized ... or not
             */
            if (resultsTab[depth] == NULL)
                resultsTab[depth] =
                                xsltComputeSortResultInternal(ctxt,
                                                              sorts[depth],
                                                              number[depth],
                                                              locale[depth]);
            res = resultsTab[depth];
            if (res == NULL)
                break;
            if (res[j] == NULL) {
                if (res[j+incr] != NULL)
                tst = 1;
            } else if (res[j+incr] == NULL) {
                tst = -1;
            } else {
                if (number[depth]) {
                /* We make NaN smaller than number in
                   accordance with XSLT spec */
                if (xmlXPathIsNaN(res[j]->floatval)) {
                    if (xmlXPathIsNaN(res[j +
                        incr]->floatval))
                    tst = 0;
                    else
                        tst = -1;
                } else if (xmlXPathIsNaN(res[j + incr]->
                        floatval))
                    tst = 1;
                else if (res[j]->floatval == res[j + incr]->
                        floatval)
                    tst = 0;
                else if (res[j]->floatval >
                    res[j + incr]->floatval)
                    tst = 1;
                else tst = -1;
                } else {
                tst = xmlStrcmp(res[j]->stringval,
                         res[j + incr]->stringval);
                }
                if (desc[depth])
                tst = -tst;
            }
 
            /*
             * if we still can't differenciate at this level
             * try one level deeper.
             */
            if (tst != 0)
                break;
            depth++;
            }
        }
        if (tst == 0) {
            tst = results[j]->index > results[j + incr]->index;
        }
        if (tst > 0) {
            tmp = results[j];
            results[j] = results[j + incr];
            results[j + incr] = tmp;
            node = list->nodeTab[j];
            list->nodeTab[j] = list->nodeTab[j + incr];
            list->nodeTab[j + incr] = node;
            depth = 1;
            while (depth < nbsorts) {
            if (sorts[depth] == NULL)
                break;
            if (resultsTab[depth] == NULL)
                break;
            res = resultsTab[depth];
            tmp = res[j];
            res[j] = res[j + incr];
            res[j + incr] = tmp;
            depth++;
            }
            j -= incr;
        } else
            break;
        }
    }
    }
 
cleanup:
    for (j = 0; j < nbsorts; j++) {
        if (locale[j] != NULL) {
            ctxt->freeLocale(locale[j]);
        }
    if (resultsTab[j] != NULL) {
        for (i = 0;i < len;i++)
        xmlXPathFreeObject(resultsTab[j][i]);
        xmlFree(resultsTab[j]);
    }
    }
}

Referenced by xsltSetSortFunc().

◆ xsltDocumentSortFunction()

void xsltDocumentSortFunction ( xmlNodeSetPtr list )

xsltDocumentSortFunction: @list: the node set

reorder the current node list @list accordingly to the document order This function is slow, obsolete and should not be used anymore.

Definition at line 987 of file xsltutils.c.

                                             {
    int i, j;
    int len, tst;
    xmlNodePtr node;
 
    if (list == NULL)
    return;
    len = list->nodeNr;
    if (len <= 1)
    return;
    /* TODO: sort is really not optimized, does it needs to ? */
    for (i = 0;i < len -1;i++) {
    for (j = i + 1; j < len; j++) {
        tst = xmlXPathCmpNodes(list->nodeTab[i], list->nodeTab[j]);
        if (tst == -1) {
        node = list->nodeTab[i];
        list->nodeTab[i] = list->nodeTab[j];
        list->nodeTab[j] = node;
        }
    }
    }
}

◆ xsltDoSortFunction()

void xsltDoSortFunction	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr *	sorts,
		int	nbsorts
	)

xsltDoSortFunction: @ctxt: a XSLT process context @sorts: array of sort nodes @nbsorts: the number of sorts in the array

reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes. This is a wrapper function, the actual function used is specified using xsltSetCtxtSortFunc() to set the context specific sort function, or xsltSetSortFunc() to set the global sort function. If a sort function is set on the context, this will get called. Otherwise the global sort function is called.

Definition at line 1447 of file xsltutils.c.

{
    if (ctxt->sortfunc != NULL)
    (ctxt->sortfunc)(ctxt, sorts, nbsorts);
    else if (xsltSortFunction != NULL)
        xsltSortFunction(ctxt, sorts, nbsorts);
}

Referenced by xsltApplyTemplates(), and xsltForEach().

◆ xsltGetCNsProp()

const xmlChar * xsltGetCNsProp	(	xsltStylesheetPtr	style,
		xmlNodePtr	node,
		const xmlChar *	name,
		const xmlChar *	nameSpace
	)

Definition at line 76 of file xsltutils.c.

                                                             {
    xmlAttrPtr prop;
    xmlDocPtr doc;
    xmlNsPtr ns;
    xmlChar *tmp;
    const xmlChar *ret;
 
    if ((node == NULL) || (style == NULL) || (style->dict == NULL))
    return(NULL);
 
    if (nameSpace == NULL)
        return xmlGetProp(node, name);
 
    if (node->type == XML_NAMESPACE_DECL)
        return(NULL);
    if (node->type == XML_ELEMENT_NODE)
    prop = node->properties;
    else
    prop = NULL;
    while (prop != NULL) {
    /*
     * One need to have
     *   - same attribute names
     *   - and the attribute carrying that namespace
     */
        if ((xmlStrEqual(prop->name, name)) &&
        (((prop->ns == NULL) && (node->ns != NULL) &&
          (xmlStrEqual(node->ns->href, nameSpace))) ||
         ((prop->ns != NULL) &&
          (xmlStrEqual(prop->ns->href, nameSpace))))) {
 
        tmp = xmlNodeListGetString(node->doc, prop->children, 1);
        if (tmp == NULL)
            ret = xmlDictLookup(style->dict, BAD_CAST "", 0);
        else {
            ret = xmlDictLookup(style->dict, tmp, -1);
        xmlFree(tmp);
        }
        return ret;
        }
    prop = prop->next;
    }
    tmp = NULL;
    /*
     * Check if there is a default declaration in the internal
     * or external subsets
     */
    doc =  node->doc;
    if (doc != NULL) {
        if (doc->intSubset != NULL) {
        xmlAttributePtr attrDecl;
 
        attrDecl = xmlGetDtdAttrDesc(doc->intSubset, node->name, name);
        if ((attrDecl == NULL) && (doc->extSubset != NULL))
        attrDecl = xmlGetDtdAttrDesc(doc->extSubset, node->name, name);
 
        if ((attrDecl != NULL) && (attrDecl->prefix != NULL)) {
            /*
         * The DTD declaration only allows a prefix search
         */
        ns = xmlSearchNs(doc, node, attrDecl->prefix);
        if ((ns != NULL) && (xmlStrEqual(ns->href, nameSpace)))
            return(xmlDictLookup(style->dict,
                                 attrDecl->defaultValue, -1));
        }
    }
    }
    return(NULL);
}

Referenced by xsltApplyTemplatesComp(), xsltCopyComp(), xsltCopyOfComp(), xsltForEachComp(), xsltGetQNameProperty(), xsltIfComp(), xsltNumberComp(), xsltParamComp(), xsltSortComp(), xsltTextComp(), xsltValueOfComp(), xsltVariableComp(), xsltWhenComp(), and xsltWithParamComp().

◆ xsltGetDebuggerStatus()

int xsltGetDebuggerStatus ( void )

xsltGetDebuggerStatus:

Get xslDebugStatus.

Returns the value of xslDebugStatus.

Definition at line 2613 of file xsltutils.c.

{
    return(xslDebugStatus);
}

◆ xsltGetNsProp()

xmlChar * xsltGetNsProp	(	xmlNodePtr	node,
		const xmlChar *	name,
		const xmlChar *	nameSpace
	)

Definition at line 166 of file xsltutils.c.

                                                                              {
    xmlAttrPtr prop;
    xmlDocPtr doc;
    xmlNsPtr ns;
 
    if (node == NULL)
    return(NULL);
 
    if (nameSpace == NULL)
        return xmlGetProp(node, name);
 
    if (node->type == XML_NAMESPACE_DECL)
        return(NULL);
    if (node->type == XML_ELEMENT_NODE)
    prop = node->properties;
    else
    prop = NULL;
    /*
    * TODO: Substitute xmlGetProp() for xmlGetNsProp(), since the former
    * is not namespace-aware and will return an attribute with equal
    * name regardless of its namespace.
    * Example:
    *   <xsl:element foo:name="myName"/>
    *   So this would return "myName" even if an attribute @name
    *   in the XSLT was requested.
    */
    while (prop != NULL) {
    /*
     * One need to have
     *   - same attribute names
     *   - and the attribute carrying that namespace
     */
        if ((xmlStrEqual(prop->name, name)) &&
        (((prop->ns == NULL) && (node->ns != NULL) &&
          (xmlStrEqual(node->ns->href, nameSpace))) ||
         ((prop->ns != NULL) &&
          (xmlStrEqual(prop->ns->href, nameSpace))))) {
        xmlChar *ret;
 
        ret = xmlNodeListGetString(node->doc, prop->children, 1);
        if (ret == NULL) return(xmlStrdup((xmlChar *)""));
        return(ret);
        }
    prop = prop->next;
    }
 
    /*
     * Check if there is a default declaration in the internal
     * or external subsets
     */
    doc =  node->doc;
    if (doc != NULL) {
        if (doc->intSubset != NULL) {
        xmlAttributePtr attrDecl;
 
        attrDecl = xmlGetDtdAttrDesc(doc->intSubset, node->name, name);
        if ((attrDecl == NULL) && (doc->extSubset != NULL))
        attrDecl = xmlGetDtdAttrDesc(doc->extSubset, node->name, name);
 
        if ((attrDecl != NULL) && (attrDecl->prefix != NULL)) {
            /*
         * The DTD declaration only allows a prefix search
         */
        ns = xmlSearchNs(doc, node, attrDecl->prefix);
        if ((ns != NULL) && (xmlStrEqual(ns->href, nameSpace)))
            return(xmlStrdup(attrDecl->defaultValue));
        }
    }
    }
    return(NULL);
}

Referenced by xsltEvalAttrValueTemplate(), and xsltEvalStaticAttrValueTemplate().

◆ xsltGetPSVIPtr()

void ** xsltGetPSVIPtr ( xmlNodePtr cur )

xsltGetPSVIPtr: @cur: Node

Returns a pointer to the psvi member of a node or NULL on error.

Definition at line 2030 of file xsltutils.c.

                               {
    switch (cur->type) {
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE:
            return &((xmlDocPtr) cur)->psvi;
 
        case XML_ATTRIBUTE_NODE:
            return &((xmlAttrPtr) cur)->psvi;
 
        case XML_ELEMENT_NODE:
        case XML_TEXT_NODE:
        case XML_CDATA_SECTION_NODE:
        case XML_PI_NODE:
        case XML_COMMENT_NODE:
            return &cur->psvi;
 
        default:
            return NULL;
    }
}

Referenced by xsltCleanupSourceDoc(), and xsltGenerateIdFunction().

◆ xsltGetQNameURI()

const xmlChar * xsltGetQNameURI	(	xmlNodePtr	node,
		xmlChar **	name
	)

Definition at line 837 of file xsltutils.c.

{
    int len = 0;
    xmlChar *qname;
    xmlNsPtr ns;
 
    if (name == NULL)
    return(NULL);
    qname = *name;
    if ((qname == NULL) || (*qname == 0))
    return(NULL);
    if (node == NULL) {
    xsltGenericError(xsltGenericErrorContext,
                 "QName: no element for namespace lookup %s\n",
             qname);
    xmlFree(qname);
    *name = NULL;
    return(NULL);
    }
 
    /* nasty but valid */
    if (qname[0] == ':')
    return(NULL);
 
    /*
     * we are not trying to validate but just to cut, and yes it will
     * work even if this is a set of UTF-8 encoded chars
     */
    while ((qname[len] != 0) && (qname[len] != ':'))
    len++;
 
    if (qname[len] == 0)
    return(NULL);
 
    /*
     * handle xml: separately, this one is magical
     */
    if ((qname[0] == 'x') && (qname[1] == 'm') &&
        (qname[2] == 'l') && (qname[3] == ':')) {
    if (qname[4] == 0)
        return(NULL);
        *name = xmlStrdup(&qname[4]);
    xmlFree(qname);
    return(XML_XML_NAMESPACE);
    }
 
    qname[len] = 0;
    ns = xmlSearchNs(node->doc, node, qname);
    if (ns == NULL) {
    xsltGenericError(xsltGenericErrorContext,
        "%s:%s : no namespace bound to prefix %s\n",
                 qname, &qname[len + 1], qname);
    *name = NULL;
    xmlFree(qname);
    return(NULL);
    }
    *name = xmlStrdup(&qname[len + 1]);
    xmlFree(qname);
    return(ns->href);
}

Referenced by xsltCompileStepPattern(), xsltDocumentElem(), xsltParseStylesheetDecimalFormat(), xsltParseStylesheetKey(), xsltParseStylesheetOutput(), xsltParseStylesheetPreserveSpace(), xsltParseStylesheetStripSpace(), and xsltParseStylesheetTemplate().

◆ xsltGetQNameURI2()

const xmlChar * xsltGetQNameURI2	(	xsltStylesheetPtr	style,
		xmlNodePtr	node,
		const xmlChar **	name
	)

Definition at line 911 of file xsltutils.c.

                               {
    int len = 0;
    xmlChar *qname;
    xmlNsPtr ns;
 
    if (name == NULL)
        return(NULL);
    qname = (xmlChar *)*name;
    if ((qname == NULL) || (*qname == 0))
        return(NULL);
    if (node == NULL) {
        xsltGenericError(xsltGenericErrorContext,
                         "QName: no element for namespace lookup %s\n",
                          qname);
    *name = NULL;
    return(NULL);
    }
 
    /*
     * we are not trying to validate but just to cut, and yes it will
     * work even if this is a set of UTF-8 encoded chars
     */
    while ((qname[len] != 0) && (qname[len] != ':'))
        len++;
 
    if (qname[len] == 0)
        return(NULL);
 
    /*
     * handle xml: separately, this one is magical
     */
    if ((qname[0] == 'x') && (qname[1] == 'm') &&
        (qname[2] == 'l') && (qname[3] == ':')) {
        if (qname[4] == 0)
            return(NULL);
        *name = xmlDictLookup(style->dict, &qname[4], -1);
        return(XML_XML_NAMESPACE);
    }
 
    qname = xmlStrndup(*name, len);
    ns = xmlSearchNs(node->doc, node, qname);
    if (ns == NULL) {
    if (style) {
        xsltTransformError(NULL, style, node,
        "No namespace bound to prefix '%s'.\n",
        qname);
        style->errors++;
    } else {
        xsltGenericError(xsltGenericErrorContext,
                "%s : no namespace bound to prefix %s\n",
        *name, qname);
    }
        *name = NULL;
        xmlFree(qname);
        return(NULL);
    }
    *name = xmlDictLookup(style->dict, (*name)+len+1, -1);
    xmlFree(qname);
    return(ns->href);
}

Referenced by xsltGetQNameProperty().

◆ xsltGetSourceNodeFlags()

int xsltGetSourceNodeFlags ( xmlNodePtr node )

xsltGetSourceNodeFlags: @node: Node from source document

Returns the flags for a source node.

Definition at line 1923 of file xsltutils.c.

                                        {
    /*
     * Squeeze the bit flags into the upper bits of
     *
     * - 'int properties' member in struct _xmlDoc
     * - 'xmlAttributeType atype' member in struct _xmlAttr
     * - 'unsigned short extra' member in struct _xmlNode
     */
    switch (node->type) {
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE:
            return ((xmlDocPtr) node)->properties >> 27;
 
        case XML_ATTRIBUTE_NODE:
            return ((xmlAttrPtr) node)->atype >> 27;
 
        case XML_ELEMENT_NODE:
        case XML_TEXT_NODE:
        case XML_CDATA_SECTION_NODE:
        case XML_PI_NODE:
        case XML_COMMENT_NODE:
            return node->extra >> 12;
 
        default:
            return 0;
    }
}

Referenced by xsltGenerateIdFunction(), and xsltGetTemplate().

◆ xsltGetUTF8Char()

int xsltGetUTF8Char	(	const unsigned char *	utf,
		int *	len
	)

xsltGetUTF8Char: @utf: a sequence of UTF-8 encoded bytes @len: a pointer to @bytes len

Read one UTF8 Char from @utf Function copied from libxml2 xmlGetUTF8Char() ... to discard ultimately and use the original API

Returns the char value or -1 in case of error and update @len with the number of bytes used

Definition at line 251 of file xsltutils.c.

                                                    {
    unsigned int c;
 
    if (utf == NULL)
    goto error;
    if (len == NULL)
    goto error;
    if (*len < 1)
    goto error;
 
    c = utf[0];
    if (c & 0x80) {
    if (*len < 2)
        goto error;
    if ((utf[1] & 0xc0) != 0x80)
        goto error;
    if ((c & 0xe0) == 0xe0) {
        if (*len < 3)
        goto error;
        if ((utf[2] & 0xc0) != 0x80)
        goto error;
        if ((c & 0xf0) == 0xf0) {
        if (*len < 4)
            goto error;
        if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
            goto error;
        *len = 4;
        /* 4-byte code */
        c = (utf[0] & 0x7) << 18;
        c |= (utf[1] & 0x3f) << 12;
        c |= (utf[2] & 0x3f) << 6;
        c |= utf[3] & 0x3f;
        } else {
          /* 3-byte code */
        *len = 3;
        c = (utf[0] & 0xf) << 12;
        c |= (utf[1] & 0x3f) << 6;
        c |= utf[2] & 0x3f;
        }
    } else {
      /* 2-byte code */
        *len = 2;
        c = (utf[0] & 0x1f) << 6;
        c |= utf[1] & 0x3f;
    }
    } else {
    /* 1-byte code */
    *len = 1;
    }
    return(c);
 
error:
    if (len != NULL)
    *len = 0;
    return(-1);
}

Referenced by xsltFormatNumberConversion(), and xsltNumberComp().

◆ xsltGetUTF8CharZ()

int xsltGetUTF8CharZ	(	const unsigned char *	utf,
		int *	len
	)

xsltGetUTF8CharZ: @utf: a sequence of UTF-8 encoded bytes @len: a pointer to @bytes len

Read one UTF8 Char from a null-terminated string.

Returns the char value or -1 in case of error and update @len with the number of bytes used

Definition at line 319 of file xsltutils.c.

                                                     {
    unsigned int c;
 
    if (utf == NULL)
    goto error;
    if (len == NULL)
    goto error;
 
    c = utf[0];
    if (c & 0x80) {
    if ((utf[1] & 0xc0) != 0x80)
        goto error;
    if ((c & 0xe0) == 0xe0) {
        if ((utf[2] & 0xc0) != 0x80)
        goto error;
        if ((c & 0xf0) == 0xf0) {
        if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
            goto error;
        *len = 4;
        /* 4-byte code */
        c = (utf[0] & 0x7) << 18;
        c |= (utf[1] & 0x3f) << 12;
        c |= (utf[2] & 0x3f) << 6;
        c |= utf[3] & 0x3f;
        } else {
          /* 3-byte code */
        *len = 3;
        c = (utf[0] & 0xf) << 12;
        c |= (utf[1] & 0x3f) << 6;
        c |= utf[2] & 0x3f;
        }
    } else {
      /* 2-byte code */
        *len = 2;
        c = (utf[0] & 0x1f) << 6;
        c |= utf[1] & 0x3f;
    }
    } else {
    /* 1-byte code */
    *len = 1;
    }
    return(c);
 
error:
    if (len != NULL)
    *len = 0;
    return(-1);
}

Referenced by xsltNumberFormatTokenize(), xsltScanLiteral(), and xsltScanNCName().

◆ xsltMessage()

void xsltMessage	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst
	)

xsltMessage: @ctxt: an XSLT processing context @node: The current node @inst: The node containing the message instruction

Process and xsl:message construct

Definition at line 492 of file xsltutils.c.

                                                                            {
    xmlGenericErrorFunc error = xsltGenericError;
    void *errctx = xsltGenericErrorContext;
    xmlChar *prop, *message;
    int terminate = 0;
 
    if ((ctxt == NULL) || (inst == NULL))
    return;
 
    if (ctxt->error != NULL) {
    error = ctxt->error;
    errctx = ctxt->errctx;
    }
 
    prop = xmlGetNsProp(inst, (const xmlChar *)"terminate", NULL);
    if (prop != NULL) {
    if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
        terminate = 1;
    } else if (xmlStrEqual(prop, (const xmlChar *)"no")) {
        terminate = 0;
    } else {
        xsltTransformError(ctxt, NULL, inst,
        "xsl:message : terminate expecting 'yes' or 'no'\n");
    }
    xmlFree(prop);
    }
    message = xsltEvalTemplateString(ctxt, node, inst);
    if (message != NULL) {
    int len = xmlStrlen(message);
 
    error(errctx, "%s", (const char *)message);
    if ((len > 0) && (message[len - 1] != '\n'))
        error(errctx, "\n");
    xmlFree(message);
    }
    if (terminate)
    ctxt->state = XSLT_STATE_STOPPED;
}

Referenced by xsltApplySequenceConstructor(), and xsltMessageWrapper().

◆ xsltPrintErrorContext()

void xsltPrintErrorContext	(	xsltTransformContextPtr	ctxt,
		xsltStylesheetPtr	style,
		xmlNodePtr	node
	)

xsltPrintErrorContext: @ctxt: the transformation context @style: the stylesheet @node: the current node being processed

Display the context of an error.

Definition at line 667 of file xsltutils.c.

                                                            {
    int line = 0;
    const xmlChar *file = NULL;
    const xmlChar *name = NULL;
    const char *type = "error";
    xmlGenericErrorFunc error = xsltGenericError;
    void *errctx = xsltGenericErrorContext;
 
    if (ctxt != NULL) {
        if (ctxt->state == XSLT_STATE_OK)
        ctxt->state = XSLT_STATE_ERROR;
    if (ctxt->error != NULL) {
        error = ctxt->error;
        errctx = ctxt->errctx;
    }
    }
    if ((node == NULL) && (ctxt != NULL))
    node = ctxt->inst;
 
    if (node != NULL)  {
    if ((node->type == XML_DOCUMENT_NODE) ||
        (node->type == XML_HTML_DOCUMENT_NODE)) {
        xmlDocPtr doc = (xmlDocPtr) node;
 
        file = doc->URL;
    } else {
        line = xmlGetLineNo(node);
        if ((node->doc != NULL) && (node->doc->URL != NULL))
        file = node->doc->URL;
        if (node->name != NULL)
        name = node->name;
    }
    }
 
    if (ctxt != NULL)
    type = "runtime error";
    else if (style != NULL) {
#ifdef XSLT_REFACTORED
    if (XSLT_CCTXT(style)->errSeverity == XSLT_ERROR_SEVERITY_WARNING)
        type = "compilation warning";
    else
        type = "compilation error";
#else
    type = "compilation error";
#endif
    }
 
    if ((file != NULL) && (line != 0) && (name != NULL))
    error(errctx, "%s: file %s line %d element %s\n",
          type, file, line, name);
    else if ((file != NULL) && (name != NULL))
    error(errctx, "%s: file %s element %s\n", type, file, name);
    else if ((file != NULL) && (line != 0))
    error(errctx, "%s: file %s line %d\n", type, file, line);
    else if (file != NULL)
    error(errctx, "%s: file %s\n", type, file);
    else if (name != NULL)
    error(errctx, "%s: element %s\n", type, name);
    else
    error(errctx, "%s\n", type);
}

Referenced by xsltTransformError().

◆ xsltSaveResultTo()

int xsltSaveResultTo	(	xmlOutputBufferPtr	buf,
		xmlDocPtr	result,
		xsltStylesheetPtr	style
	)

xsltSaveResultTo: @buf: an output buffer

Returns: : the result xmlDocPtr @style: the stylesheet

Save the result

Returns: obtained by applying the @style stylesheet to an I/O output channel @buf

Returns the number of byte written or -1 in case of failure.

Definition at line 1564 of file xsltutils.c.

                                    {
    const xmlChar *encoding;
    int base;
    const xmlChar *method;
    int indent;
 
    if ((buf == NULL) || (result == NULL) || (style == NULL))
    return(-1);
    if ((result->children == NULL) ||
    ((result->children->type == XML_DTD_NODE) &&
     (result->children->next == NULL)))
    return(0);
 
    if ((style->methodURI != NULL) &&
    ((style->method == NULL) ||
     (!xmlStrEqual(style->method, (const xmlChar *) "xhtml")))) {
        xsltGenericError(xsltGenericErrorContext,
        "xsltSaveResultTo : unknown output method\n");
        return(-1);
    }
 
    base = buf->written;
 
    XSLT_GET_IMPORT_PTR(method, style, method)
    XSLT_GET_IMPORT_PTR(encoding, style, encoding)
    XSLT_GET_IMPORT_INT(indent, style, indent);
 
    if ((method == NULL) && (result->type == XML_HTML_DOCUMENT_NODE))
    method = (const xmlChar *) "html";
 
    if ((method != NULL) &&
    (xmlStrEqual(method, (const xmlChar *) "html"))) {
    if (encoding != NULL) {
        htmlSetMetaEncoding(result, (const xmlChar *) encoding);
    } else {
        htmlSetMetaEncoding(result, (const xmlChar *) "UTF-8");
    }
    if (indent == -1)
        indent = 1;
    htmlDocContentDumpFormatOutput(buf, result, (const char *) encoding,
                               indent);
    xmlOutputBufferFlush(buf);
    } else if ((method != NULL) &&
    (xmlStrEqual(method, (const xmlChar *) "xhtml"))) {
    if (encoding != NULL) {
        htmlSetMetaEncoding(result, (const xmlChar *) encoding);
    } else {
        htmlSetMetaEncoding(result, (const xmlChar *) "UTF-8");
    }
    htmlDocContentDumpOutput(buf, result, (const char *) encoding);
    xmlOutputBufferFlush(buf);
    } else if ((method != NULL) &&
           (xmlStrEqual(method, (const xmlChar *) "text"))) {
    xmlNodePtr cur;
 
    cur = result->children;
    while (cur != NULL) {
        if (cur->type == XML_TEXT_NODE)
        xmlOutputBufferWriteString(buf, (const char *) cur->content);
 
        /*
         * Skip to next node
         */
        if (cur->children != NULL) {
        if ((cur->children->type != XML_ENTITY_DECL) &&
            (cur->children->type != XML_ENTITY_REF_NODE) &&
            (cur->children->type != XML_ENTITY_NODE)) {
            cur = cur->children;
            continue;
        }
        }
        if (cur->next != NULL) {
        cur = cur->next;
        continue;
        }
 
        do {
        cur = cur->parent;
        if (cur == NULL)
            break;
        if (cur == (xmlNodePtr) style->doc) {
            cur = NULL;
            break;
        }
        if (cur->next != NULL) {
            cur = cur->next;
            break;
        }
        } while (cur != NULL);
    }
    xmlOutputBufferFlush(buf);
    } else {
    int omitXmlDecl;
    int standalone;
 
    XSLT_GET_IMPORT_INT(omitXmlDecl, style, omitXmlDeclaration);
    XSLT_GET_IMPORT_INT(standalone, style, standalone);
 
    if (omitXmlDecl != 1) {
        xmlOutputBufferWriteString(buf, "<?xml version=");
        if (result->version != NULL) {
        xmlOutputBufferWriteString(buf, "\"");
        xmlOutputBufferWriteString(buf, (const char *)result->version);
        xmlOutputBufferWriteString(buf, "\"");
        } else
        xmlOutputBufferWriteString(buf, "\"1.0\"");
        if (encoding == NULL) {
        if (result->encoding != NULL)
            encoding = result->encoding;
        else if (result->charset != XML_CHAR_ENCODING_UTF8)
            encoding = (const xmlChar *)
                   xmlGetCharEncodingName((xmlCharEncoding)
                                          result->charset);
        }
        if (encoding != NULL) {
        xmlOutputBufferWriteString(buf, " encoding=");
        xmlOutputBufferWriteString(buf, "\"");
        xmlOutputBufferWriteString(buf, (const char *) encoding);
        xmlOutputBufferWriteString(buf, "\"");
        }
        switch (standalone) {
        case 0:
            xmlOutputBufferWriteString(buf, " standalone=\"no\"");
            break;
        case 1:
            xmlOutputBufferWriteString(buf, " standalone=\"yes\"");
            break;
        default:
            break;
        }
        xmlOutputBufferWriteString(buf, "?>\n");
    }
    if (result->children != NULL) {
            xmlNodePtr children = result->children;
        xmlNodePtr child = children;
 
            /*
             * Hack to avoid quadratic behavior when scanning
             * result->children in xmlGetIntSubset called by
             * xmlNodeDumpOutput.
             */
            result->children = NULL;
 
        while (child != NULL) {
        xmlNodeDumpOutput(buf, result, child, 0, (indent == 1),
                      (const char *) encoding);
        if (indent && ((child->type == XML_DTD_NODE) ||
            ((child->type == XML_COMMENT_NODE) &&
             (child->next != NULL))))
            xmlOutputBufferWriteString(buf, "\n");
        child = child->next;
        }
        if (indent)
            xmlOutputBufferWriteString(buf, "\n");
 
            result->children = children;
    }
    xmlOutputBufferFlush(buf);
    }
    return(buf->written - base);
}

Referenced by xsltRunStylesheetUser(), xsltSaveResultToFd(), xsltSaveResultToFile(), xsltSaveResultToFilename(), and xsltSaveResultToString().

◆ xsltSaveResultToFd()

int xsltSaveResultToFd	(	int	fd,
		xmlDocPtr	result,
		xsltStylesheetPtr	style
	)

xsltSaveResultToFd: @fd: a file descriptor

Returns: : the result xmlDocPtr @style: the stylesheet

Save the result

Returns: obtained by applying the @style stylesheet to an open file descriptor This does not close the descriptor.

Returns the number of bytes written or -1 in case of failure.

Definition at line 1826 of file xsltutils.c.

                                                                      {
    xmlOutputBufferPtr buf;
    const xmlChar *encoding;
    int ret;
 
    if ((fd < 0) || (result == NULL) || (style == NULL))
    return(-1);
    if (result->children == NULL)
    return(0);
 
    XSLT_GET_IMPORT_PTR(encoding, style, encoding)
    if (encoding != NULL) {
    xmlCharEncodingHandlerPtr encoder = NULL;
 
        /* Don't use UTF-8 dummy encoder */
        if ((xmlStrcasecmp(encoding, BAD_CAST "UTF-8") != 0) &&
            (xmlStrcasecmp(encoding, BAD_CAST "UTF8") != 0))
        encoder = xmlFindCharEncodingHandler((char *) encoding);
    buf = xmlOutputBufferCreateFd(fd, encoder);
    } else {
    buf = xmlOutputBufferCreateFd(fd, NULL);
    }
    if (buf == NULL)
    return(-1);
    xsltSaveResultTo(buf, result, style);
    ret = xmlOutputBufferClose(buf);
    return(ret);
}

◆ xsltSaveResultToFile()

int xsltSaveResultToFile	(	FILE *	file,
		xmlDocPtr	result,
		xsltStylesheetPtr	style
	)

Definition at line 1783 of file xsltutils.c.

                                                                            {
    xmlOutputBufferPtr buf;
    const xmlChar *encoding;
    int ret;
 
    if ((file == NULL) || (result == NULL) || (style == NULL))
    return(-1);
    if (result->children == NULL)
    return(0);
 
    XSLT_GET_IMPORT_PTR(encoding, style, encoding)
    if (encoding != NULL) {
    xmlCharEncodingHandlerPtr encoder = NULL;
 
        /* Don't use UTF-8 dummy encoder */
        if ((xmlStrcasecmp(encoding, BAD_CAST "UTF-8") != 0) &&
            (xmlStrcasecmp(encoding, BAD_CAST "UTF8") != 0))
        encoder = xmlFindCharEncodingHandler((char *) encoding);
    buf = xmlOutputBufferCreateFile(file, encoder);
    } else {
    buf = xmlOutputBufferCreateFile(file, NULL);
    }
 
    if (buf == NULL)
    return(-1);
    xsltSaveResultTo(buf, result, style);
    ret = xmlOutputBufferClose(buf);
    return(ret);
}

Referenced by xsltDocumentElem().

◆ xsltSaveResultToFilename()

int xsltSaveResultToFilename	(	const char *	URL,
		xmlDocPtr	result,
		xsltStylesheetPtr	style,
		int	compression
	)

xsltSaveResultToFilename: @URL: a filename or URL

Returns: : the result xmlDocPtr @style: the stylesheet @compression: the compression factor (0 - 9 included)

Save the result

Returns: obtained by applying the @style stylesheet to a file or @URL

Returns the number of byte written or -1 in case of failure.

Definition at line 1740 of file xsltutils.c.

                                                       {
    xmlOutputBufferPtr buf;
    const xmlChar *encoding;
    int ret;
 
    if ((URL == NULL) || (result == NULL) || (style == NULL))
    return(-1);
    if (result->children == NULL)
    return(0);
 
    XSLT_GET_IMPORT_PTR(encoding, style, encoding)
    if (encoding != NULL) {
    xmlCharEncodingHandlerPtr encoder = NULL;
 
        /* Don't use UTF-8 dummy encoder */
        if ((xmlStrcasecmp(encoding, BAD_CAST "UTF-8") != 0) &&
            (xmlStrcasecmp(encoding, BAD_CAST "UTF8") != 0))
        encoder = xmlFindCharEncodingHandler((char *) encoding);
    buf = xmlOutputBufferCreateFilename(URL, encoder, compression);
    } else {
    buf = xmlOutputBufferCreateFilename(URL, NULL, compression);
    }
    if (buf == NULL)
    return(-1);
    xsltSaveResultTo(buf, result, style);
    ret = xmlOutputBufferClose(buf);
    return(ret);
}

Referenced by xsltDocumentElem(), and xsltRunStylesheetUser().

◆ xsltSaveResultToString()

int xsltSaveResultToString	(	xmlChar **	doc_txt_ptr,
		int *	doc_txt_len,
		xmlDocPtr	result,
		xsltStylesheetPtr	style
	)

xsltSaveResultToString: @doc_txt_ptr: Memory pointer for allocated XML text @doc_txt_len: Length of the generated XML text

Returns: : the result xmlDocPtr @style: the stylesheet

Save the result

Returns: obtained by applying the @style stylesheet to a new allocated string.

Returns 0 in case of success and -1 in case of error

Definition at line 1868 of file xsltutils.c.

                                                          {
    xmlOutputBufferPtr buf;
    const xmlChar *encoding;
 
    *doc_txt_ptr = NULL;
    *doc_txt_len = 0;
    if (result->children == NULL)
    return(0);
 
    XSLT_GET_IMPORT_PTR(encoding, style, encoding)
    if (encoding != NULL) {
    xmlCharEncodingHandlerPtr encoder = NULL;
 
        /* Don't use UTF-8 dummy encoder */
        if ((xmlStrcasecmp(encoding, BAD_CAST "UTF-8") != 0) &&
            (xmlStrcasecmp(encoding, BAD_CAST "UTF8") != 0))
        encoder = xmlFindCharEncodingHandler((char *) encoding);
    buf = xmlAllocOutputBuffer(encoder);
        if (buf == NULL)
            xmlCharEncCloseFunc(encoder);
    } else {
    buf = xmlAllocOutputBuffer(NULL);
    }
    if (buf == NULL)
    return(-1);
    xsltSaveResultTo(buf, result, style);
#ifdef LIBXML2_NEW_BUFFER
    if (buf->conv != NULL) {
    *doc_txt_len = xmlBufUse(buf->conv);
    *doc_txt_ptr = xmlStrndup(xmlBufContent(buf->conv), *doc_txt_len);
    } else {
    *doc_txt_len = xmlBufUse(buf->buffer);
    *doc_txt_ptr = xmlStrndup(xmlBufContent(buf->buffer), *doc_txt_len);
    }
#else
    if (buf->conv != NULL) {
    *doc_txt_len = buf->conv->use;
    *doc_txt_ptr = xmlStrndup(buf->conv->content, *doc_txt_len);
    } else {
    *doc_txt_len = buf->buffer->use;
    *doc_txt_ptr = xmlStrndup(buf->buffer->content, *doc_txt_len);
    }
#endif
    (void)xmlOutputBufferClose(buf);
    return 0;
}

◆ xsltSetCtxtLocaleHandlers()

void xsltSetCtxtLocaleHandlers	(	xsltTransformContextPtr	ctxt,
		xsltNewLocaleFunc	newLocale,
		xsltFreeLocaleFunc	freeLocale,
		xsltGenSortKeyFunc	genSortKey
	)

xsltSetCtxtLocaleHandlers: @ctxt: an XSLT transform context @newLocale: locale constructor @freeLocale: locale destructor @genSortKey: sort key generator

Set the locale handlers.

Definition at line 1500 of file xsltutils.c.

                                                         {
    if (ctxt == NULL)
        return;
 
    ctxt->newLocale = newLocale;
    ctxt->freeLocale = freeLocale;
    ctxt->genSortKey = genSortKey;
}

◆ xsltSetCtxtParseOptions()

int xsltSetCtxtParseOptions	(	xsltTransformContextPtr	ctxt,
		int	options
	)

xsltSetCtxtParseOptions: @ctxt: a XSLT process context @options: a combination of libxml2 xmlParserOption

Change the default parser option passed by the XSLT engine to the parser when using document() loading.

Returns the previous options or -1 in case of error

Definition at line 1529 of file xsltutils.c.

{
    int oldopts;
 
    if (ctxt == NULL)
        return(-1);
    oldopts = ctxt->parserOptions;
    if (ctxt->xinclude)
        oldopts |= XML_PARSE_XINCLUDE;
    ctxt->parserOptions = options;
    if (options & XML_PARSE_XINCLUDE)
        ctxt->xinclude = 1;
    else
        ctxt->xinclude = 0;
    return(oldopts);
}

◆ xsltSetCtxtSortFunc()

void xsltSetCtxtSortFunc	(	xsltTransformContextPtr	ctxt,
		xsltSortFunc	handler
	)

xsltSetCtxtSortFunc: @ctxt: a XSLT process context @handler: the new handler function

DEPRECATED: Use xsltSetCtxtLocaleHandlers.

Function to set the handler for XSLT sorting for the specified context. If the handler is NULL, then the global sort function will be called

Definition at line 1486 of file xsltutils.c.

                                                                        {
    ctxt->sortfunc = handler;
}

◆ xsltSetGenericDebugFunc()

void xsltSetGenericDebugFunc	(	void *	ctx,
		xmlGenericErrorFunc	handler
	)

xsltSetGenericDebugFunc: @ctx: the new error handling context @handler: the new handler function

Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing or validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL.

Definition at line 650 of file xsltutils.c.

                                                                {
    xsltGenericDebugContext = ctx;
    if (handler != NULL)
    xsltGenericDebug = handler;
    else
    xsltGenericDebug = xsltGenericDebugDefaultFunc;
}

◆ xsltSetGenericErrorFunc()

void xsltSetGenericErrorFunc	(	void *	ctx,
		xmlGenericErrorFunc	handler
	)

xsltSetGenericErrorFunc: @ctx: the new error handling context @handler: the new handler function

Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing nor validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL.

Definition at line 604 of file xsltutils.c.

                                                                {
    xsltGenericErrorContext = ctx;
    if (handler != NULL)
    xsltGenericError = handler;
    else
    xsltGenericError = xsltGenericErrorDefaultFunc;
}

◆ xsltSetSortFunc()

void xsltSetSortFunc ( xsltSortFunc handler )

xsltSetSortFunc: @handler: the new handler function

DEPRECATED: Use xsltSetCtxtLocaleHandlers.

Function to reset the global handler for XSLT sorting. If the handler is NULL, the default sort function will be used.

Definition at line 1466 of file xsltutils.c.

                                      {
    if (handler != NULL)
    xsltSortFunction = handler;
    else
    xsltSortFunction = xsltDefaultSortFunction;
}

◆ xsltSetSourceNodeFlags()

int xsltSetSourceNodeFlags	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		int	flags
	)

xsltSetSourceNodeFlags: @node: Node from source document @flags: Flags

Sets the specified flags to 1.

Returns 0 on success, -1 on error.

Definition at line 1961 of file xsltutils.c.

                                  {
    if (node->doc == ctxt->initialContextDoc)
        ctxt->sourceDocDirty = 1;
 
    switch (node->type) {
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE:
            ((xmlDocPtr) node)->properties |= flags << 27;
            return 0;
 
        case XML_ATTRIBUTE_NODE:
            ((xmlAttrPtr) node)->atype |= flags << 27;
            return 0;
 
        case XML_ELEMENT_NODE:
        case XML_TEXT_NODE:
        case XML_CDATA_SECTION_NODE:
        case XML_PI_NODE:
        case XML_COMMENT_NODE:
            node->extra |= flags << 12;
            return 0;
 
        default:
            return -1;
    }
}

Referenced by xsltGenerateIdFunction(), and xsltInitCtxtKey().

◆ xsltSetTransformErrorFunc()

void xsltSetTransformErrorFunc	(	xsltTransformContextPtr	ctxt,
		void *	ctx,
		xmlGenericErrorFunc	handler
	)

xsltSetTransformErrorFunc: @ctxt: the XSLT transformation context @ctx: the new error handling context @handler: the new handler function

Function to reset the handler and the error context for out of context error messages specific to a given XSLT transromation.

This simply means that @handler will be called for subsequent error messages while running the transformation.

Definition at line 743 of file xsltutils.c.

{
    ctxt->error = handler;
    ctxt->errctx = ctx;
}

◆ xsltSplitQName()

const xmlChar * xsltSplitQName	(	xmlDictPtr	dict,
		const xmlChar *	name,
		const xmlChar **	prefix
	)

Definition at line 804 of file xsltutils.c.

                                                                             {
    int len = 0;
    const xmlChar *ret = NULL;
 
    *prefix = NULL;
    if ((name == NULL) || (dict == NULL)) return(NULL);
    if (name[0] == ':')
        return(xmlDictLookup(dict, name, -1));
    while ((name[len] != 0) && (name[len] != ':')) len++;
    if (name[len] == 0) return(xmlDictLookup(dict, name, -1));
    *prefix = xmlDictLookup(dict, name, len);
    ret = xmlDictLookup(dict, &name[len + 1], -1);
    return(ret);
}

Referenced by xsltApplyAttributeSet(), xsltAttribute(), xsltAttributeComp(), xsltElement(), xsltElementComp(), xsltFormatNumberFunction(), xsltParseStylesheetAttributeSet(), and xsltProcessUserParamInternal().

◆ xsltTransformError()

void xsltTransformError	(	xsltTransformContextPtr	ctxt,
		xsltStylesheetPtr	style,
		xmlNodePtr	node,
		const char *	msg,
			...
	)

xsltTransformError: @ctxt: an XSLT transformation context @style: the XSLT stylesheet used @node: the current node in the stylesheet @msg: the message to display/transmit ...: extra parameters for the message display

Display and format an error messages, gives file, line, position and extra parameters, will use the specific transformation context if available

Definition at line 762 of file xsltutils.c.

                                 {
    xmlGenericErrorFunc error = xsltGenericError;
    void *errctx = xsltGenericErrorContext;
    char * str;
 
    if (ctxt != NULL) {
        if (ctxt->state == XSLT_STATE_OK)
        ctxt->state = XSLT_STATE_ERROR;
    if (ctxt->error != NULL) {
        error = ctxt->error;
        errctx = ctxt->errctx;
    }
    }
    if ((node == NULL) && (ctxt != NULL))
    node = ctxt->inst;
    xsltPrintErrorContext(ctxt, style, node);
    XSLT_GET_VAR_STR(msg, str);
    error(errctx, "%s", str);
    if (str != NULL)
    xmlFree(str);
}

◆ xsltXPathCompile()

xmlXPathCompExprPtr xsltXPathCompile	(	xsltStylesheetPtr	style,
		const xmlChar *	str
	)

xsltXPathCompile: @style: the stylesheet @str: the XPath expression

Compile an XPath expression

Returns the xmlXPathCompExprPtr resulting from the compilation or NULL. the caller has to free the object.

Definition at line 2593 of file xsltutils.c.

                                                              {
    return(xsltXPathCompileFlags(style, str, 0));
}

Referenced by xsltAddKey(), xsltApplyTemplatesComp(), xsltCompileAttr(), xsltCopyOfComp(), xsltForEachComp(), xsltIfComp(), xsltParamComp(), xsltSortComp(), xsltValueOfComp(), xsltVariableComp(), xsltWhenComp(), and xsltWithParamComp().

◆ xsltXPathCompileFlags()

xmlXPathCompExprPtr xsltXPathCompileFlags	(	xsltStylesheetPtr	style,
		const xmlChar *	str,
		int	flags
	)

xsltXPathCompileFlags: @style: the stylesheet @str: the XPath expression @flags: extra compilation flags to pass down to libxml2 XPath

Compile an XPath expression

Returns the xmlXPathCompExprPtr resulting from the compilation or NULL. the caller has to free the object.

Definition at line 2550 of file xsltutils.c.

                                                                              {
    xmlXPathContextPtr xpathCtxt;
    xmlXPathCompExprPtr ret;
 
    if (style != NULL) {
        xpathCtxt = style->principal->xpathCtxt;
    if (xpathCtxt == NULL)
        return NULL;
    xpathCtxt->dict = style->dict;
    } else {
    xpathCtxt = xmlXPathNewContext(NULL);
    if (xpathCtxt == NULL)
        return NULL;
    }
    xpathCtxt->flags = flags;
 
    /*
    * Compile the expression.
    */
    ret = xmlXPathCtxtCompile(xpathCtxt, str);
 
    if (style == NULL) {
    xmlXPathFreeContext(xpathCtxt);
    }
    /*
     * TODO: there is a lot of optimizations which should be possible
     *       like variable slot precomputations, function precomputations, etc.
     */
 
    return(ret);
}

Referenced by xsltAddKey(), xsltCompMatchAdd(), and xsltXPathCompile().

Variable Documentation

◆ xslDebugStatus

int xslDebugStatus

Definition at line 2603 of file xsltutils.c.

Referenced by xsltApplyStylesheetInternal(), xsltChoose(), xsltForEach(), xsltGetDebuggerStatus(), and xsltNewTransformContext().

◆ xsltGenericDebug

xmlGenericErrorFunc xsltGenericDebug = xsltGenericDebugDefaultFunc

Definition at line 632 of file xsltutils.c.

◆ xsltGenericDebugContext

void* xsltGenericDebugContext = NULL

Definition at line 633 of file xsltutils.c.

◆ xsltGenericError

xmlGenericErrorFunc xsltGenericError = xsltGenericErrorDefaultFunc

◆ xsltGenericErrorContext

◆ xsltSortFunction

xsltSortFunc xsltSortFunction = xsltDefaultSortFunction

static

Definition at line 1430 of file xsltutils.c.

Referenced by xsltDoSortFunction(), and xsltSetSortFunc().

Macros

Functions

: the attribute name

is

Detailed Description

Macro Definition Documentation

◆ IN_LIBXSLT

◆ XSLT_GET_VAR_STR

Function Documentation

◆ LIBXSLT_ATTR_FORMAT()

◆ xsltClearSourceNodeFlags()

◆ xsltComputeSortResult()

◆ xsltComputeSortResultInternal()

◆ xsltDefaultSortFunction()

◆ xsltDocumentSortFunction()

◆ xsltDoSortFunction()

◆ xsltGetCNsProp()

◆ xsltGetDebuggerStatus()

◆ xsltGetNsProp()

◆ xsltGetPSVIPtr()

◆ xsltGetQNameURI()

◆ xsltGetQNameURI2()

◆ xsltGetSourceNodeFlags()

◆ xsltGetUTF8Char()

◆ xsltGetUTF8CharZ()

◆ xsltMessage()

◆ xsltPrintErrorContext()

◆ xsltSaveResultTo()

◆ xsltSaveResultToFd()

◆ xsltSaveResultToFile()

◆ xsltSaveResultToFilename()

◆ xsltSaveResultToString()

◆ xsltSetCtxtLocaleHandlers()

◆ xsltSetCtxtParseOptions()

◆ xsltSetCtxtSortFunc()

◆ xsltSetGenericDebugFunc()

◆ xsltSetGenericErrorFunc()

◆ xsltSetSortFunc()

◆ xsltSetSourceNodeFlags()

◆ xsltSetTransformErrorFunc()

◆ xsltSplitQName()

◆ xsltTransformError()

◆ xsltXPathCompile()

◆ xsltXPathCompileFlags()

Variable Documentation

◆ xslDebugStatus

◆ xsltGenericDebug

◆ xsltGenericDebugContext

◆ xsltGenericError

◆ xsltGenericErrorContext

◆ xsltSortFunction