xsltutils.h File Reference

#include <libxslt/xsltconfig.h>
#include <libxml/xpath.h>
#include <libxml/dict.h>
#include <libxml/xmlerror.h>
#include "xsltexports.h"
#include "xsltInternals.h"

Include dependency graph for xsltutils.h:

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

Go to the source code of this file.

Macros
#define	XSLT_TODO
#define	XSLT_STRANGE
#define	IS_XSLT_ELEM(n)
#define	IS_XSLT_NAME(n, val)    (xmlStrEqual((n)->name, (const xmlChar *) (val)))
#define	IS_XSLT_REAL_NODE(n)
#define	XSLT_TRACE(ctxt, code, call)
#define	XSLT_TIMESTAMP_TICS_PER_SEC   100000l

Typedefs
typedef void(*	xsltHandleDebuggerCallback) (xmlNodePtr cur, xmlNodePtr node, xsltTemplatePtr templ, xsltTransformContextPtr ctxt)
typedef int(*	xsltAddCallCallback) (xsltTemplatePtr templ, xmlNodePtr source)
typedef void(*	xsltDropCallCallback) (void)

Enumerations
enum	xsltDebugTraceCodes {   XSLT_TRACE_ALL = -1 , XSLT_TRACE_NONE = 0 , XSLT_TRACE_COPY_TEXT = 1<<0 , XSLT_TRACE_PROCESS_NODE = 1<<1 ,   XSLT_TRACE_APPLY_TEMPLATE = 1<<2 , XSLT_TRACE_COPY = 1<<3 , XSLT_TRACE_COMMENT = 1<<4 , XSLT_TRACE_PI = 1<<5 ,   XSLT_TRACE_COPY_OF = 1<<6 , XSLT_TRACE_VALUE_OF = 1<<7 , XSLT_TRACE_CALL_TEMPLATE = 1<<8 , XSLT_TRACE_APPLY_TEMPLATES = 1<<9 ,   XSLT_TRACE_CHOOSE = 1<<10 , XSLT_TRACE_IF = 1<<11 , XSLT_TRACE_FOR_EACH = 1<<12 , XSLT_TRACE_STRIP_SPACES = 1<<13 ,   XSLT_TRACE_TEMPLATES = 1<<14 , XSLT_TRACE_KEYS = 1<<15 , XSLT_TRACE_VARIABLES = 1<<16 }
enum	xsltDebugStatusCodes {   XSLT_DEBUG_NONE = 0 , XSLT_DEBUG_INIT , XSLT_DEBUG_STEP , XSLT_DEBUG_STEPOUT ,   XSLT_DEBUG_NEXT , XSLT_DEBUG_STOP , XSLT_DEBUG_CONT , XSLT_DEBUG_RUN ,   XSLT_DEBUG_RUN_RESTART , XSLT_DEBUG_QUIT }

Functions
XSLTPUBFUN xmlChar *XSLTCALL	xsltGetNsProp (xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace)
XSLTPUBFUN const xmlChar *XSLTCALL	xsltGetCNsProp (xsltStylesheetPtr style, xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace)
XSLTPUBFUN int XSLTCALL	xsltGetUTF8Char (const unsigned char *utf, int *len)
XSLTPUBFUN void XSLTCALL	xsltDebugSetDefaultTrace (xsltDebugTraceCodes val)
XSLTPUBFUN xsltDebugTraceCodes XSLTCALL	xsltDebugGetDefaultTrace (void)
XSLTPUBFUN void XSLTCALL	xsltPrintErrorContext (xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node)
XSLTPUBFUN void XSLTCALL	xsltMessage (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst)
XSLTPUBFUN void XSLTCALL	xsltSetGenericErrorFunc (void *ctx, xmlGenericErrorFunc handler)
XSLTPUBFUN void XSLTCALL	xsltSetGenericDebugFunc (void *ctx, xmlGenericErrorFunc handler)
XSLTPUBFUN void XSLTCALL	xsltSetTransformErrorFunc (xsltTransformContextPtr ctxt, void *ctx, xmlGenericErrorFunc handler)
XSLTPUBFUN void XSLTCALL	xsltTransformError (xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...) LIBXSLT_ATTR_FORMAT(4
XSLTPUBFUN void XSLTCALL XSLTPUBFUN int XSLTCALL	xsltSetCtxtParseOptions (xsltTransformContextPtr ctxt, int options)
XSLTPUBFUN void XSLTCALL	xsltDocumentSortFunction (xmlNodeSetPtr list)
XSLTPUBFUN void XSLTCALL	xsltSetSortFunc (xsltSortFunc handler)
XSLTPUBFUN void XSLTCALL	xsltSetCtxtSortFunc (xsltTransformContextPtr ctxt, xsltSortFunc handler)
XSLTPUBFUN void XSLTCALL	xsltDefaultSortFunction (xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)
XSLTPUBFUN void XSLTCALL	xsltDoSortFunction (xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)
XSLTPUBFUN xmlXPathObjectPtr *XSLTCALL	xsltComputeSortResult (xsltTransformContextPtr ctxt, xmlNodePtr sort)
XSLTPUBFUN const xmlChar *XSLTCALL	xsltSplitQName (xmlDictPtr dict, const xmlChar *name, const xmlChar **prefix)
XSLTPUBFUN const xmlChar *XSLTCALL	xsltGetQNameURI (xmlNodePtr node, xmlChar **name)
XSLTPUBFUN const xmlChar *XSLTCALL	xsltGetQNameURI2 (xsltStylesheetPtr style, xmlNodePtr node, const xmlChar **name)
XSLTPUBFUN int XSLTCALL	xsltSaveResultTo (xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style)
XSLTPUBFUN int XSLTCALL	xsltSaveResultToFilename (const char *URI, xmlDocPtr result, xsltStylesheetPtr style, int compression)
XSLTPUBFUN int XSLTCALL	xsltSaveResultToFile (FILE *file, xmlDocPtr result, xsltStylesheetPtr style)
XSLTPUBFUN int XSLTCALL	xsltSaveResultToFd (int fd, xmlDocPtr result, xsltStylesheetPtr style)
XSLTPUBFUN int XSLTCALL	xsltSaveResultToString (xmlChar **doc_txt_ptr, int *doc_txt_len, xmlDocPtr result, xsltStylesheetPtr style)
XSLTPUBFUN xmlXPathCompExprPtr XSLTCALL	xsltXPathCompile (xsltStylesheetPtr style, const xmlChar *str)
XSLTPUBFUN xmlXPathCompExprPtr XSLTCALL	xsltXPathCompileFlags (xsltStylesheetPtr style, const xmlChar *str, int flags)
XSLTPUBFUN void XSLTCALL	xsltSaveProfiling (xsltTransformContextPtr ctxt, FILE *output)
XSLTPUBFUN xmlDocPtr XSLTCALL	xsltGetProfileInformation (xsltTransformContextPtr ctxt)
XSLTPUBFUN long XSLTCALL	xsltTimestamp (void)
XSLTPUBFUN void XSLTCALL	xsltCalibrateAdjust (long delta)
XSLTPUBFUN void XSLTCALL	xsltSetDebuggerStatus (int value)
XSLTPUBFUN int XSLTCALL	xsltGetDebuggerStatus (void)
XSLTPUBFUN int XSLTCALL	xsltSetDebuggerCallbacks (int no, void *block)
XSLTPUBFUN int XSLTCALL	xslAddCall (xsltTemplatePtr templ, xmlNodePtr source)
XSLTPUBFUN void XSLTCALL	xslDropCall (void)

Variables
XSLTPUBVAR xmlGenericErrorFunc	xsltGenericError
XSLTPUBVAR void *	xsltGenericErrorContext
XSLTPUBVAR xmlGenericErrorFunc	xsltGenericDebug
XSLTPUBVAR void *	xsltGenericDebugContext
XSLTPUBVAR int	xslDebugStatus

Macro Definition Documentation

IS_XSLT_ELEM

#define IS_XSLT_ELEM

(

n

)

Value:

    (((n) != NULL) && ((n)->type == XML_ELEMENT_NODE) &&                \
     ((n)->ns != NULL) && (xmlStrEqual((n)->ns->href, XSLT_NAMESPACE)))

IS_XSLT_ELEM:

Checks that the element pertains to XSLT namespace.

Definition at line 51 of file xsltutils.h.

IS_XSLT_NAME

#define IS_XSLT_NAME	(		n,
			val
	)		(xmlStrEqual((n)->name, (const xmlChar *) (val)))

IS_XSLT_NAME:

Checks the value of an element in XSLT namespace.

Definition at line 60 of file xsltutils.h.

IS_XSLT_REAL_NODE

#define IS_XSLT_REAL_NODE

(

n

)

Value:

    (((n) != NULL) &&                           \
     (((n)->type == XML_ELEMENT_NODE) ||                \
      ((n)->type == XML_TEXT_NODE) ||                   \
      ((n)->type == XML_CDATA_SECTION_NODE) ||              \
      ((n)->type == XML_ATTRIBUTE_NODE) ||              \
      ((n)->type == XML_DOCUMENT_NODE) ||               \
      ((n)->type == XML_HTML_DOCUMENT_NODE) ||              \
      ((n)->type == XML_COMMENT_NODE) ||                \
      ((n)->type == XML_PI_NODE)))

IS_XSLT_REAL_NODE:

Check that a node is a 'real' one: document, element, text or attribute.

Definition at line 68 of file xsltutils.h.

XSLT_STRANGE

#define XSLT_STRANGE

Value:

    xsltGenericError(xsltGenericErrorContext,               \
        "Internal error at %s:%d\n",                \
            __FILE__, __LINE__);

XSLT_STRANGE:

Macro to flag that a problem was detected internally.

Definition at line 41 of file xsltutils.h.

XSLT_TIMESTAMP_TICS_PER_SEC

#define XSLT_TIMESTAMP_TICS_PER_SEC   100000l

XSLT_TIMESTAMP_TICS_PER_SEC:

Sampling precision for profiling

Definition at line 266 of file xsltutils.h.

XSLT_TODO

#define XSLT_TODO

Value:

    xsltGenericError(xsltGenericErrorContext,               \
        "Unimplemented block at %s:%d\n",               \
            __FILE__, __LINE__);

XSLT_TODO:

Macro to flag unimplemented blocks.

Definition at line 31 of file xsltutils.h.

XSLT_TRACE

#define XSLT_TRACE	(		ctxt,
			code,
			call
	)

Value:

    if (ctxt->traceCode && (*(ctxt->traceCode) & code)) \
        call

XSLT_TRACE:

Control the type of xsl debugtrace messages emitted.

Definition at line 125 of file xsltutils.h.

Typedef Documentation

xsltAddCallCallback

typedef int(* xsltAddCallCallback) (xsltTemplatePtr templ, xmlNodePtr source)

Definition at line 289 of file xsltutils.h.

xsltDropCallCallback

typedef void(* xsltDropCallCallback) (void)

Definition at line 290 of file xsltutils.h.

xsltHandleDebuggerCallback

typedef void(* xsltHandleDebuggerCallback) (xmlNodePtr cur, xmlNodePtr node, xsltTemplatePtr templ, xsltTransformContextPtr ctxt)

Definition at line 287 of file xsltutils.h.

Enumeration Type Documentation

xsltDebugStatusCodes

enum xsltDebugStatusCodes

Enumerator
XSLT_DEBUG_NONE
XSLT_DEBUG_INIT
XSLT_DEBUG_STEP
XSLT_DEBUG_STEPOUT
XSLT_DEBUG_NEXT
XSLT_DEBUG_STOP
XSLT_DEBUG_CONT
XSLT_DEBUG_RUN
XSLT_DEBUG_RUN_RESTART
XSLT_DEBUG_QUIT

Definition at line 272 of file xsltutils.h.

             {
    XSLT_DEBUG_NONE = 0, /* no debugging allowed */
    XSLT_DEBUG_INIT,
    XSLT_DEBUG_STEP,
    XSLT_DEBUG_STEPOUT,
    XSLT_DEBUG_NEXT,
    XSLT_DEBUG_STOP,
    XSLT_DEBUG_CONT,
    XSLT_DEBUG_RUN,
    XSLT_DEBUG_RUN_RESTART,
    XSLT_DEBUG_QUIT
} xsltDebugStatusCodes;

xsltDebugTraceCodes

enum xsltDebugTraceCodes

Enumerator
XSLT_TRACE_ALL
XSLT_TRACE_NONE
XSLT_TRACE_COPY_TEXT
XSLT_TRACE_PROCESS_NODE
XSLT_TRACE_APPLY_TEMPLATE
XSLT_TRACE_COPY
XSLT_TRACE_COMMENT
XSLT_TRACE_PI
XSLT_TRACE_COPY_OF
XSLT_TRACE_VALUE_OF
XSLT_TRACE_CALL_TEMPLATE
XSLT_TRACE_APPLY_TEMPLATES
XSLT_TRACE_CHOOSE
XSLT_TRACE_IF
XSLT_TRACE_FOR_EACH
XSLT_TRACE_STRIP_SPACES
XSLT_TRACE_TEMPLATES
XSLT_TRACE_KEYS
XSLT_TRACE_VARIABLES

Definition at line 98 of file xsltutils.h.

             {
    XSLT_TRACE_ALL =        -1,
    XSLT_TRACE_NONE =       0,
    XSLT_TRACE_COPY_TEXT =      1<<0,
    XSLT_TRACE_PROCESS_NODE =   1<<1,
    XSLT_TRACE_APPLY_TEMPLATE = 1<<2,
    XSLT_TRACE_COPY =       1<<3,
    XSLT_TRACE_COMMENT =        1<<4,
    XSLT_TRACE_PI =         1<<5,
    XSLT_TRACE_COPY_OF =        1<<6,
    XSLT_TRACE_VALUE_OF =       1<<7,
    XSLT_TRACE_CALL_TEMPLATE =  1<<8,
    XSLT_TRACE_APPLY_TEMPLATES =    1<<9,
    XSLT_TRACE_CHOOSE =     1<<10,
    XSLT_TRACE_IF =         1<<11,
    XSLT_TRACE_FOR_EACH =       1<<12,
    XSLT_TRACE_STRIP_SPACES =   1<<13,
    XSLT_TRACE_TEMPLATES =      1<<14,
    XSLT_TRACE_KEYS =       1<<15,
    XSLT_TRACE_VARIABLES =      1<<16
} xsltDebugTraceCodes;

Function Documentation

xslAddCall()

XSLTPUBFUN int XSLTCALL xslAddCall	(	xsltTemplatePtr	templ,
		xmlNodePtr	source
	)

xslDropCall()

XSLTPUBFUN void XSLTCALL xslDropCall

(

void

)

Referenced by xsltApplySequenceConstructor(), and xsltApplyXSLTTemplate().

xsltCalibrateAdjust()

XSLTPUBFUN void XSLTCALL xsltCalibrateAdjust

(

long

delta

)

Referenced by xsltApplyXSLTTemplate().

xsltComputeSortResult()

XSLTPUBFUN xmlXPathObjectPtr *XSLTCALL 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 1067 of file xsltutils.c.

                                                                     {
    return xsltComputeSortResultInternal(ctxt, sort, /* xfrm */ 0);
}

xsltDebugGetDefaultTrace()

XSLTPUBFUN xsltDebugTraceCodes XSLTCALL xsltDebugGetDefaultTrace

(

void

)

xsltDebugGetDefaultTrace:

Get the current default debug tracing level mask

Returns the current default debug tracing level mask

Definition at line 460 of file transform.c.

                                               {
    return xsltDefaultTrace;
}

xsltDebugSetDefaultTrace()

XSLTPUBFUN void XSLTCALL xsltDebugSetDefaultTrace

(

xsltDebugTraceCodes

val

)

xsltDebugSetDefaultTrace: @val: tracing level mask

Set the default debug tracing level mask

Definition at line 449 of file transform.c.

                                                       {
    xsltDefaultTrace = val;
}

xsltDefaultSortFunction()

XSLTPUBFUN void XSLTCALL 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 1081 of file xsltutils.c.

                            {
#ifdef XSLT_REFACTORED
    xsltStyleItemSortPtr comp;
#else
    xsltStylePreCompPtr comp;
#endif
    xmlXPathObjectPtr *resultsTab[XSLT_MAX_SORT];
    xmlXPathObjectPtr *results = NULL, *res;
    xmlNodeSetPtr list = NULL;
    int descending, number, desc, numb;
    int len = 0;
    int i, j, incr;
    int tst;
    int depth;
    xmlNodePtr node;
    xmlXPathObjectPtr tmp;
    int tempstype[XSLT_MAX_SORT], temporder[XSLT_MAX_SORT],
        templang[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++) {
    comp = sorts[j]->psvi;
    tempstype[j] = 0;
    if ((comp->stype == NULL) && (comp->has_stype != 0)) {
        comp->stype =
        xsltEvalAttrValueTemplate(ctxt, sorts[j],
                      (const xmlChar *) "data-type",
                      NULL);
        if (comp->stype != NULL) {
        tempstype[j] = 1;
        if (xmlStrEqual(comp->stype, (const xmlChar *) "text"))
            comp->number = 0;
        else if (xmlStrEqual(comp->stype, (const xmlChar *) "number"))
            comp->number = 1;
        else {
            xsltTransformError(ctxt, NULL, sorts[j],
              "xsltDoSortFunction: no support for data-type = %s\n",
                     comp->stype);
            comp->number = 0; /* use default */
        }
        }
    }
    temporder[j] = 0;
    if ((comp->order == NULL) && (comp->has_order != 0)) {
        comp->order = xsltEvalAttrValueTemplate(ctxt, sorts[j],
                            (const xmlChar *) "order",
                            NULL);
        if (comp->order != NULL) {
        temporder[j] = 1;
        if (xmlStrEqual(comp->order, (const xmlChar *) "ascending"))
            comp->descending = 0;
        else if (xmlStrEqual(comp->order,
                     (const xmlChar *) "descending"))
            comp->descending = 1;
        else {
            xsltTransformError(ctxt, NULL, sorts[j],
                 "xsltDoSortFunction: invalid value %s for order\n",
                     comp->order);
            comp->descending = 0; /* use default */
        }
        }
    }
    templang[j] = 0;
    if ((comp->lang == NULL) && (comp->has_lang != 0)) {
            xmlChar *lang = xsltEvalAttrValueTemplate(ctxt, sorts[j],
                              (xmlChar *) "lang",
                              NULL);
        if (lang != NULL) {
        templang[j] = 1;
                comp->locale = xsltNewLocale(lang);
                xmlFree(lang);
            }
    }
    }
 
    len = list->nodeNr;
 
    resultsTab[0] = xsltComputeSortResultInternal(ctxt, sorts[0],
                                                  /* xfrm */ 1);
    for (i = 1;i < XSLT_MAX_SORT;i++)
    resultsTab[i] = NULL;
 
    results = resultsTab[0];
 
    comp = sorts[0]->psvi;
    descending = comp->descending;
    number = comp->number;
    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) {
            /* 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 if(comp->locale != (xsltLocale)0) {
            tst = xsltLocaleStrcmp(
                comp->locale,
                (xsltLocaleChar *) results[j]->stringval,
                (xsltLocaleChar *) results[j + incr]->stringval);
            } else {
            tst = xmlStrcmp(results[j]->stringval,
                     results[j + incr]->stringval);
            }
            if (descending)
            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;
            desc = comp->descending;
            numb = comp->number;
 
            /*
             * 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],
                                                              /* xfrm */ 1);
            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 (numb) {
                /* 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 if(comp->locale != (xsltLocale)0) {
                tst = xsltLocaleStrcmp(
                    comp->locale,
                    (xsltLocaleChar *) res[j]->stringval,
                    (xsltLocaleChar *) res[j + incr]->stringval);
                } else {
                tst = xmlStrcmp(res[j]->stringval,
                         res[j + incr]->stringval);
                }
                if (desc)
                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++) {
    comp = sorts[j]->psvi;
    if (tempstype[j] == 1) {
        /* The data-type needs to be recomputed each time */
        xmlFree((void *)(comp->stype));
        comp->stype = NULL;
    }
    if (temporder[j] == 1) {
        /* The order needs to be recomputed each time */
        xmlFree((void *)(comp->order));
        comp->order = NULL;
    }
    if (templang[j] == 1) {
        xsltFreeLocale(comp->locale);
        comp->locale = (xsltLocale)0;
    }
    if (resultsTab[j] != NULL) {
        for (i = 0;i < len;i++)
        xmlXPathFreeObject(resultsTab[j][i]);
        xmlFree(resultsTab[j]);
    }
    }
}

Referenced by xsltSetSortFunc().

xsltDocumentSortFunction()

XSLTPUBFUN void XSLTCALL 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 903 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()

XSLTPUBFUN void XSLTCALL 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 1369 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()

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

Definition at line 52 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()

XSLTPUBFUN int XSLTCALL xsltGetDebuggerStatus

(

void

)

xsltGetDebuggerStatus:

Get xslDebugStatus.

Returns the value of xslDebugStatus.

Definition at line 2376 of file xsltutils.c.

{
    return(xslDebugStatus);
}

xsltGetNsProp()

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

Definition at line 142 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().

xsltGetProfileInformation()

XSLTPUBFUN xmlDocPtr XSLTCALL xsltGetProfileInformation

(

xsltTransformContextPtr

ctxt

)

xsltGetQNameURI()

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

Definition at line 753 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()

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

Definition at line 827 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().

xsltGetUTF8Char()

XSLTPUBFUN int XSLTCALL 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 227 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().

xsltMessage()

XSLTPUBFUN void XSLTCALL 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 408 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()

XSLTPUBFUN void XSLTCALL 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 583 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().

xsltSaveProfiling()

XSLTPUBFUN void XSLTCALL xsltSaveProfiling	(	xsltTransformContextPtr	ctxt,
		FILE *	output
	)

Referenced by xsltApplyStylesheetInternal().

xsltSaveResultTo()

XSLTPUBFUN int XSLTCALL 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 1460 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()

XSLTPUBFUN int XSLTCALL 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 1724 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;
 
    encoder = xmlFindCharEncodingHandler((char *)encoding);
    if ((encoder != NULL) &&
        (xmlStrEqual((const xmlChar *)encoder->name,
             (const xmlChar *) "UTF-8")))
        encoder = NULL;
    buf = xmlOutputBufferCreateFd(fd, encoder);
    } else {
    buf = xmlOutputBufferCreateFd(fd, NULL);
    }
    if (buf == NULL)
    return(-1);
    xsltSaveResultTo(buf, result, style);
    ret = xmlOutputBufferClose(buf);
    return(ret);
}

xsltSaveResultToFile()

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

Definition at line 1680 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;
 
    encoder = xmlFindCharEncodingHandler((char *)encoding);
    if ((encoder != NULL) &&
        (xmlStrEqual((const xmlChar *)encoder->name,
             (const xmlChar *) "UTF-8")))
        encoder = NULL;
    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()

XSLTPUBFUN int XSLTCALL 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 1636 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;
 
    encoder = xmlFindCharEncodingHandler((char *)encoding);
    if ((encoder != NULL) &&
        (xmlStrEqual((const xmlChar *)encoder->name,
             (const xmlChar *) "UTF-8")))
        encoder = NULL;
    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()

XSLTPUBFUN int XSLTCALL 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 1767 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;
 
    encoder = xmlFindCharEncodingHandler((char *)encoding);
    if ((encoder != NULL) &&
        (xmlStrEqual((const xmlChar *)encoder->name,
             (const xmlChar *) "UTF-8")))
        encoder = NULL;
    buf = xmlAllocOutputBuffer(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;
}

xsltSetCtxtParseOptions()

XSLTPUBFUN void XSLTCALL XSLTPUBFUN int XSLTCALL 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 1425 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()

XSLTPUBFUN void XSLTCALL xsltSetCtxtSortFunc	(	xsltTransformContextPtr	ctxt,
		xsltSortFunc	handler
	)

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

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 1404 of file xsltutils.c.

                                                                        {
    ctxt->sortfunc = handler;
}

xsltSetDebuggerCallbacks()

XSLTPUBFUN int XSLTCALL xsltSetDebuggerCallbacks	(	int	no,
		void *	block
	)

xsltSetDebuggerStatus()

XSLTPUBFUN void XSLTCALL xsltSetDebuggerStatus

(

int

value

)

xsltSetGenericDebugFunc()

XSLTPUBFUN void XSLTCALL 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 566 of file xsltutils.c.

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

xsltSetGenericErrorFunc()

XSLTPUBFUN void XSLTCALL 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 520 of file xsltutils.c.

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

xsltSetSortFunc()

XSLTPUBFUN void XSLTCALL xsltSetSortFunc

(

xsltSortFunc

handler

)

xsltSetSortFunc: @handler: the new handler function

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

Definition at line 1386 of file xsltutils.c.

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

xsltSetTransformErrorFunc()

XSLTPUBFUN void XSLTCALL 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 659 of file xsltutils.c.

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

xsltSplitQName()

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

Definition at line 720 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().

xsltTimestamp()

XSLTPUBFUN long XSLTCALL xsltTimestamp

(

void

)

Referenced by xsltApplyXSLTTemplate().

xsltTransformError()

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

xsltXPathCompile()

XSLTPUBFUN xmlXPathCompExprPtr XSLTCALL 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 2356 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()

XSLTPUBFUN xmlXPathCompExprPtr XSLTCALL 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 2313 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

XSLTPUBVAR int xslDebugStatus

Definition at line 285 of file xsltutils.h.

xsltGenericDebug

XSLTPUBVAR xmlGenericErrorFunc xsltGenericDebug

Definition at line 139 of file xsltutils.h.

xsltGenericDebugContext

XSLTPUBVAR void* xsltGenericDebugContext

Definition at line 140 of file xsltutils.h.

xsltGenericError

XSLTPUBVAR xmlGenericErrorFunc xsltGenericError

Definition at line 137 of file xsltutils.h.

xsltGenericErrorContext

XSLTPUBVAR void* xsltGenericErrorContext

Definition at line 138 of file xsltutils.h.