xsltInternals.h File Reference

#include <libxml/tree.h>
#include <libxml/hash.h>
#include <libxml/xpath.h>
#include <libxml/xmlerror.h>
#include <libxml/dict.h>
#include <libxml/xmlstring.h>
#include <libxslt/xslt.h>
#include "xsltexports.h"
#include "numbersInternals.h"

Include dependency graph for xsltInternals.h:

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

Go to the source code of this file.

Classes
struct	_xsltRuntimeExtra
struct	_xsltTemplate
struct	_xsltDecimalFormat
struct	_xsltDocument
struct	_xsltKeyDef
struct	_xsltKeyTable
struct	_xsltElemPreComp
struct	_xsltStylePreComp
struct	_xsltStackElem
struct	_xsltStylesheet
struct	_xsltTransformCache
struct	_xsltTransformContext

Macros
#define	XSLT_IS_TEXT_NODE(n)
#define	XSLT_MARK_RES_TREE_FRAG(n)    (n)->name = (char *) xmlStrdup(BAD_CAST " fake node libxslt");
#define	XSLT_IS_RES_TREE_FRAG(n)
#define	XSLT_REFACTORED_KEYCOMP
#define	XSLT_FAST_IF
#define	XSLT_REFACTORED_VARS
#define	XSLT_MAX_SORT   15
#define	XSLT_PAT_NO_PRIORITY   -12345789
#define	XSLT_RUNTIME_EXTRA_LST(ctxt, nr)   (ctxt)->extras[(nr)].info
#define	XSLT_RUNTIME_EXTRA_FREE(ctxt, nr)   (ctxt)->extras[(nr)].deallocate
#define	XSLT_RUNTIME_EXTRA(ctxt, nr, typ)   (ctxt)->extras[(nr)].val.typ
#define	CHECK_STOPPED   if (ctxt->state == XSLT_STATE_STOPPED) return;
#define	CHECK_STOPPEDE   if (ctxt->state == XSLT_STATE_STOPPED) goto error;
#define	CHECK_STOPPED0   if (ctxt->state == XSLT_STATE_STOPPED) return(0);
#define	XML_CAST_FPTR(fptr)   fptr

Typedefs
typedef struct _xsltRuntimeExtra	xsltRuntimeExtra
typedef xsltRuntimeExtra *	xsltRuntimeExtraPtr
typedef struct _xsltTemplate	xsltTemplate
typedef xsltTemplate *	xsltTemplatePtr
typedef struct _xsltDecimalFormat	xsltDecimalFormat
typedef xsltDecimalFormat *	xsltDecimalFormatPtr
typedef struct _xsltDocument	xsltDocument
typedef xsltDocument *	xsltDocumentPtr
typedef struct _xsltKeyDef	xsltKeyDef
typedef xsltKeyDef *	xsltKeyDefPtr
typedef struct _xsltKeyTable	xsltKeyTable
typedef xsltKeyTable *	xsltKeyTablePtr
typedef struct _xsltStylesheet	xsltStylesheet
typedef xsltStylesheet *	xsltStylesheetPtr
typedef struct _xsltTransformContext	xsltTransformContext
typedef xsltTransformContext *	xsltTransformContextPtr
typedef struct _xsltElemPreComp	xsltElemPreComp
typedef xsltElemPreComp *	xsltElemPreCompPtr
typedef void(*	xsltTransformFunction) (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)
typedef void(*	xsltSortFunc) (xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)
typedef void(*	xsltElemPreCompDeallocator) (xsltElemPreCompPtr comp)
typedef struct _xsltStylePreComp	xsltStylePreComp
typedef xsltStylePreComp *	xsltStylePreCompPtr
typedef struct _xsltStackElem	xsltStackElem
typedef xsltStackElem *	xsltStackElemPtr
typedef struct _xsltTransformCache	xsltTransformCache
typedef xsltTransformCache *	xsltTransformCachePtr
typedef void *(*	xsltNewLocaleFunc) (const xmlChar *lang, int lowerFirst)
typedef void(*	xsltFreeLocaleFunc) (void *locale)
typedef xmlChar *(*	xsltGenSortKeyFunc) (void *locale, const xmlChar *lang)

Enumerations
enum	xsltStyleType {   XSLT_FUNC_COPY =1 , XSLT_FUNC_SORT , XSLT_FUNC_TEXT , XSLT_FUNC_ELEMENT ,   XSLT_FUNC_ATTRIBUTE , XSLT_FUNC_COMMENT , XSLT_FUNC_PI , XSLT_FUNC_COPYOF ,   XSLT_FUNC_VALUEOF , XSLT_FUNC_NUMBER , XSLT_FUNC_APPLYIMPORTS , XSLT_FUNC_CALLTEMPLATE ,   XSLT_FUNC_APPLYTEMPLATES , XSLT_FUNC_CHOOSE , XSLT_FUNC_IF , XSLT_FUNC_FOREACH ,   XSLT_FUNC_DOCUMENT , XSLT_FUNC_WITHPARAM , XSLT_FUNC_PARAM , XSLT_FUNC_VARIABLE ,   XSLT_FUNC_WHEN , XSLT_FUNC_EXTENSION }
enum	xsltOutputType { XSLT_OUTPUT_XML = 0 , XSLT_OUTPUT_HTML , XSLT_OUTPUT_TEXT }
enum	xsltTransformState { XSLT_STATE_OK = 0 , XSLT_STATE_ERROR , XSLT_STATE_STOPPED }

Functions
XSLTPUBFUN xsltStylesheetPtr XSLTCALL	xsltNewStylesheet (void)
XSLTPUBFUN xsltStylesheetPtr XSLTCALL	xsltParseStylesheetFile (const xmlChar *filename)
XSLTPUBFUN void XSLTCALL	xsltFreeStylesheet (xsltStylesheetPtr style)
XSLTPUBFUN int XSLTCALL	xsltIsBlank (xmlChar *str)
XSLTPUBFUN void XSLTCALL	xsltFreeStackElemList (xsltStackElemPtr elem)
XSLTPUBFUN xsltDecimalFormatPtr XSLTCALL	xsltDecimalFormatGetByName (xsltStylesheetPtr style, xmlChar *name)
XSLTPUBFUN xsltDecimalFormatPtr XSLTCALL	xsltDecimalFormatGetByQName (xsltStylesheetPtr style, const xmlChar *nsUri, const xmlChar *name)
XSLTPUBFUN xsltStylesheetPtr XSLTCALL	xsltParseStylesheetProcess (xsltStylesheetPtr ret, xmlDocPtr doc)
XSLTPUBFUN void XSLTCALL	xsltParseStylesheetOutput (xsltStylesheetPtr style, xmlNodePtr cur)
XSLTPUBFUN xsltStylesheetPtr XSLTCALL	xsltParseStylesheetDoc (xmlDocPtr doc)
XSLTPUBFUN xsltStylesheetPtr XSLTCALL	xsltParseStylesheetImportedDoc (xmlDocPtr doc, xsltStylesheetPtr style)
XSLTPUBFUN int XSLTCALL	xsltParseStylesheetUser (xsltStylesheetPtr style, xmlDocPtr doc)
XSLTPUBFUN xsltStylesheetPtr XSLTCALL	xsltLoadStylesheetPI (xmlDocPtr doc)
XSLTPUBFUN void XSLTCALL	xsltNumberFormat (xsltTransformContextPtr ctxt, xsltNumberDataPtr data, xmlNodePtr node)
XSLTPUBFUN xmlXPathError XSLTCALL	xsltFormatNumberConversion (xsltDecimalFormatPtr self, xmlChar *format, double number, xmlChar **result)
XSLTPUBFUN void XSLTCALL	xsltParseTemplateContent (xsltStylesheetPtr style, xmlNodePtr templ)
XSLTPUBFUN int XSLTCALL	xsltAllocateExtra (xsltStylesheetPtr style)
XSLTPUBFUN int XSLTCALL	xsltAllocateExtraCtxt (xsltTransformContextPtr ctxt)
XSLTPUBFUN xmlDocPtr XSLTCALL	xsltCreateRVT (xsltTransformContextPtr ctxt)
XSLTPUBFUN int XSLTCALL	xsltRegisterTmpRVT (xsltTransformContextPtr ctxt, xmlDocPtr RVT)
XSLTPUBFUN int XSLTCALL	xsltRegisterLocalRVT (xsltTransformContextPtr ctxt, xmlDocPtr RVT)
XSLTPUBFUN int XSLTCALL	xsltRegisterPersistRVT (xsltTransformContextPtr ctxt, xmlDocPtr RVT)
XSLTPUBFUN int XSLTCALL	xsltExtensionInstructionResultRegister (xsltTransformContextPtr ctxt, xmlXPathObjectPtr obj)
XSLTPUBFUN int XSLTCALL	xsltExtensionInstructionResultFinalize (xsltTransformContextPtr ctxt)
XSLTPUBFUN int XSLTCALL	xsltFlagRVTs (xsltTransformContextPtr ctxt, xmlXPathObjectPtr obj, int val)
XSLTPUBFUN void XSLTCALL	xsltFreeRVTs (xsltTransformContextPtr ctxt)
XSLTPUBFUN void XSLTCALL	xsltReleaseRVT (xsltTransformContextPtr ctxt, xmlDocPtr RVT)
XSLTPUBFUN void XSLTCALL	xsltCompileAttr (xsltStylesheetPtr style, xmlAttrPtr attr)
XSLTPUBFUN xmlChar *XSLTCALL	xsltEvalAVT (xsltTransformContextPtr ctxt, void *avt, xmlNodePtr node)
XSLTPUBFUN void XSLTCALL	xsltFreeAVTList (void *avt)
XSLTPUBFUN void XSLTCALL	xsltUninit (void)
XSLTPUBFUN int XSLTCALL	xsltInitCtxtKey (xsltTransformContextPtr ctxt, xsltDocumentPtr doc, xsltKeyDefPtr keyd)
XSLTPUBFUN int XSLTCALL	xsltInitAllDocKeys (xsltTransformContextPtr ctxt)

Macro Definition Documentation

CHECK_STOPPED

#define CHECK_STOPPED   if (ctxt->state == XSLT_STATE_STOPPED) return;

CHECK_STOPPED:

Macro to check if the XSLT processing should be stopped. Will return from the function.

Definition at line 1810 of file xsltInternals.h.

CHECK_STOPPED0

#define CHECK_STOPPED0   if (ctxt->state == XSLT_STATE_STOPPED) return(0);

CHECK_STOPPED0:

Macro to check if the XSLT processing should be stopped. Will return from the function with a 0 value.

Definition at line 1826 of file xsltInternals.h.

CHECK_STOPPEDE

#define CHECK_STOPPEDE   if (ctxt->state == XSLT_STATE_STOPPED) goto error;

CHECK_STOPPEDE:

Macro to check if the XSLT processing should be stopped. Will goto the error: label.

Definition at line 1818 of file xsltInternals.h.

XML_CAST_FPTR

#define XML_CAST_FPTR

(

fptr

)

fptr

XML_CAST_FPTR: @fptr: pointer to a function

Macro to do a casting from an object pointer to a function pointer without encountering a warning from gcc

define XML_CAST_FPTR(fptr) (*(void **)(&fptr)) This macro violated ISO C aliasing rules (gcc4 on s390 broke) so it is disabled now

Definition at line 1848 of file xsltInternals.h.

XSLT_FAST_IF

#define XSLT_FAST_IF

XSLT_FAST_IF:

Internal define to enable usage of xmlXPathCompiledEvalToBoolean() for XSLT "tests"; e.g. in <xsl:if test="/foo/bar">

Definition at line 73 of file xsltInternals.h.

XSLT_IS_RES_TREE_FRAG

#define XSLT_IS_RES_TREE_FRAG

(

n

)

Value:

    ((n != NULL) && ((n)->type == XML_DOCUMENT_NODE) && \
     ((n)->name != NULL) && ((n)->name[0] == ' '))

XSLT_IS_RES_TREE_FRAG:

internal macro to test tree fragments

Definition at line 55 of file xsltInternals.h.

XSLT_IS_TEXT_NODE

#define XSLT_IS_TEXT_NODE

(

n

)

Value:

    ((n != NULL) && \
    (((n)->type == XML_TEXT_NODE) || \
     ((n)->type == XML_CDATA_SECTION_NODE)))

XSLT_IS_TEXT_NODE:

check if the argument is a text node

Definition at line 37 of file xsltInternals.h.

XSLT_MARK_RES_TREE_FRAG

#define XSLT_MARK_RES_TREE_FRAG

(

n

)

(n)->name = (char *) xmlStrdup(BAD_CAST " fake node libxslt");

XSLT_MARK_RES_TREE_FRAG:

internal macro to set up tree fragments

Definition at line 47 of file xsltInternals.h.

XSLT_MAX_SORT

#define XSLT_MAX_SORT   15

XSLT_REFACTORED_PARSING:

Internal define to enable the refactored parts of Libxslt related to parsing. XSLT_MAX_SORT:

Max number of specified xsl:sort on an element.

Definition at line 208 of file xsltInternals.h.

XSLT_PAT_NO_PRIORITY

#define XSLT_PAT_NO_PRIORITY   -12345789

XSLT_PAT_NO_PRIORITY:

Specific value for pattern without priority expressed.

Definition at line 215 of file xsltInternals.h.

XSLT_REFACTORED_KEYCOMP

#define XSLT_REFACTORED_KEYCOMP

XSLT_REFACTORED_KEYCOMP:

Internal define to enable on-demand xsl:key computation. That's the only mode now but the define is kept for compatibility

Definition at line 65 of file xsltInternals.h.

XSLT_REFACTORED_VARS

#define XSLT_REFACTORED_VARS

XSLT_REFACTORED:

Internal define to enable the refactored parts of Libxslt. XSLT_REFACTORED_VARS:

Internal define to enable the refactored variable part of libxslt

Definition at line 88 of file xsltInternals.h.

XSLT_RUNTIME_EXTRA

#define XSLT_RUNTIME_EXTRA	(		ctxt,
			nr,
			typ
	)		(ctxt)->extras[(nr)].val.typ

XSLT_RUNTIME_EXTRA: @ctxt: the transformation context @nr: the index

Macro used to define extra information stored in the context

Definition at line 256 of file xsltInternals.h.

XSLT_RUNTIME_EXTRA_FREE

#define XSLT_RUNTIME_EXTRA_FREE	(		ctxt,
			nr
	)		(ctxt)->extras[(nr)].deallocate

XSLT_RUNTIME_EXTRA_FREE: @ctxt: the transformation context @nr: the index

Macro used to free extra information stored in the context

Definition at line 248 of file xsltInternals.h.

XSLT_RUNTIME_EXTRA_LST

#define XSLT_RUNTIME_EXTRA_LST	(		ctxt,
			nr
	)		(ctxt)->extras[(nr)].info

XSLT_RUNTIME_EXTRA_LST: @ctxt: the transformation context @nr: the index

Macro used to access extra information stored in the context

Definition at line 240 of file xsltInternals.h.

Typedef Documentation

xsltDecimalFormat

typedef struct _xsltDecimalFormat xsltDecimalFormat

xsltDecimalFormat:

Data structure of decimal-format.

Definition at line 303 of file xsltInternals.h.

xsltDecimalFormatPtr

typedef xsltDecimalFormat* xsltDecimalFormatPtr

Definition at line 304 of file xsltInternals.h.

xsltDocument

typedef struct _xsltDocument xsltDocument

xsltDocument:

Data structure associated to a parsed document.

Definition at line 329 of file xsltInternals.h.

xsltDocumentPtr

typedef xsltDocument* xsltDocumentPtr

Definition at line 330 of file xsltInternals.h.

xsltElemPreComp

typedef struct _xsltElemPreComp xsltElemPreComp

xsltElemPreComp:

The in-memory structure corresponding to element precomputed data, designed to be extended by extension implementors.

Definition at line 393 of file xsltInternals.h.

xsltElemPreCompDeallocator

typedef void(* xsltElemPreCompDeallocator) (xsltElemPreCompPtr comp)

xsltElemPreCompDeallocator: @comp: the xsltElemPreComp to free up

Deallocates an xsltElemPreComp structure.

Definition at line 463 of file xsltInternals.h.

xsltElemPreCompPtr

typedef xsltElemPreComp* xsltElemPreCompPtr

Definition at line 394 of file xsltInternals.h.

xsltFreeLocaleFunc

typedef void(* xsltFreeLocaleFunc) (void *locale)

Definition at line 1668 of file xsltInternals.h.

xsltGenSortKeyFunc

typedef xmlChar *(* xsltGenSortKeyFunc) (void *locale, const xmlChar *lang)

Definition at line 1670 of file xsltInternals.h.

xsltKeyDef

typedef struct _xsltKeyDef xsltKeyDef

xsltKeyDef:

Representation of an xsl:key.

Definition at line 346 of file xsltInternals.h.

xsltKeyDefPtr

typedef xsltKeyDef* xsltKeyDefPtr

Definition at line 347 of file xsltInternals.h.

xsltKeyTable

typedef struct _xsltKeyTable xsltKeyTable

xsltKeyTable:

Holds the computed keys for key definitions of the same QName. Is owned by an xsltDocument.

Definition at line 367 of file xsltInternals.h.

xsltKeyTablePtr

typedef xsltKeyTable* xsltKeyTablePtr

Definition at line 368 of file xsltInternals.h.

xsltNewLocaleFunc

typedef void *(* xsltNewLocaleFunc) (const xmlChar *lang, int lowerFirst)

Definition at line 1666 of file xsltInternals.h.

xsltRuntimeExtra

typedef struct _xsltRuntimeExtra xsltRuntimeExtra

xsltRuntimeExtra:

Extra information added to the transformation context.

Definition at line 222 of file xsltInternals.h.

xsltRuntimeExtraPtr

typedef xsltRuntimeExtra* xsltRuntimeExtraPtr

Definition at line 223 of file xsltInternals.h.

xsltSortFunc

typedef void(* xsltSortFunc) (xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)

xsltSortFunc: @ctxt: a transformation context @sorts: the node-set to sort @nbsorts: the number of sorts

Signature of the function to use during sorting

Definition at line 419 of file xsltInternals.h.

xsltStackElem

typedef struct _xsltStackElem xsltStackElem

Definition at line 1418 of file xsltInternals.h.

xsltStackElemPtr

typedef xsltStackElem* xsltStackElemPtr

Definition at line 1419 of file xsltInternals.h.

xsltStylePreComp

typedef struct _xsltStylePreComp xsltStylePreComp

xsltStylePreComp:

The abstract basic structure for items of the XSLT processor. This includes: 1) compiled forms of XSLT instructions (xsl:if, xsl:attribute, etc.) 2) compiled forms of literal result elements 3) compiled forms of extension elements

Definition at line 494 of file xsltInternals.h.

xsltStylePreCompPtr

typedef xsltStylePreComp* xsltStylePreCompPtr

Definition at line 495 of file xsltInternals.h.

xsltStylesheet

typedef struct _xsltStylesheet xsltStylesheet

Definition at line 381 of file xsltInternals.h.

xsltStylesheetPtr

typedef xsltStylesheet* xsltStylesheetPtr

Definition at line 382 of file xsltInternals.h.

xsltTemplate

typedef struct _xsltTemplate xsltTemplate

xsltTemplate:

The in-memory structure corresponding to an XSLT Template.

Definition at line 263 of file xsltInternals.h.

xsltTemplatePtr

typedef xsltTemplate* xsltTemplatePtr

Definition at line 264 of file xsltInternals.h.

xsltTransformCache

typedef struct _xsltTransformCache xsltTransformCache

Definition at line 1642 of file xsltInternals.h.

xsltTransformCachePtr

typedef xsltTransformCache* xsltTransformCachePtr

Definition at line 1643 of file xsltInternals.h.

xsltTransformContext

typedef struct _xsltTransformContext xsltTransformContext

Definition at line 384 of file xsltInternals.h.

xsltTransformContextPtr

typedef xsltTransformContext* xsltTransformContextPtr

Definition at line 385 of file xsltInternals.h.

xsltTransformFunction

typedef void(* xsltTransformFunction) (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)

xsltTransformFunction: @ctxt: the XSLT transformation context @node: the input node @inst: the stylesheet node @comp: the compiled information from the stylesheet

Signature of the function associated to elements part of the stylesheet language like xsl:if or xsl:apply-templates.

Definition at line 406 of file xsltInternals.h.

Enumeration Type Documentation

xsltOutputType

enum xsltOutputType

Enumerator
XSLT_OUTPUT_XML
XSLT_OUTPUT_HTML
XSLT_OUTPUT_TEXT

Definition at line 1660 of file xsltInternals.h.

             {
    XSLT_OUTPUT_XML = 0,
    XSLT_OUTPUT_HTML,
    XSLT_OUTPUT_TEXT
} xsltOutputType;

xsltStyleType

enum xsltStyleType

Enumerator
XSLT_FUNC_COPY
XSLT_FUNC_SORT
XSLT_FUNC_TEXT
XSLT_FUNC_ELEMENT
XSLT_FUNC_ATTRIBUTE
XSLT_FUNC_COMMENT
XSLT_FUNC_PI
XSLT_FUNC_COPYOF
XSLT_FUNC_VALUEOF
XSLT_FUNC_NUMBER
XSLT_FUNC_APPLYIMPORTS
XSLT_FUNC_CALLTEMPLATE
XSLT_FUNC_APPLYTEMPLATES
XSLT_FUNC_CHOOSE
XSLT_FUNC_IF
XSLT_FUNC_FOREACH
XSLT_FUNC_DOCUMENT
XSLT_FUNC_WITHPARAM
XSLT_FUNC_PARAM
XSLT_FUNC_VARIABLE
XSLT_FUNC_WHEN
XSLT_FUNC_EXTENSION

Definition at line 422 of file xsltInternals.h.

             {
    XSLT_FUNC_COPY=1,
    XSLT_FUNC_SORT,
    XSLT_FUNC_TEXT,
    XSLT_FUNC_ELEMENT,
    XSLT_FUNC_ATTRIBUTE,
    XSLT_FUNC_COMMENT,
    XSLT_FUNC_PI,
    XSLT_FUNC_COPYOF,
    XSLT_FUNC_VALUEOF,
    XSLT_FUNC_NUMBER,
    XSLT_FUNC_APPLYIMPORTS,
    XSLT_FUNC_CALLTEMPLATE,
    XSLT_FUNC_APPLYTEMPLATES,
    XSLT_FUNC_CHOOSE,
    XSLT_FUNC_IF,
    XSLT_FUNC_FOREACH,
    XSLT_FUNC_DOCUMENT,
    XSLT_FUNC_WITHPARAM,
    XSLT_FUNC_PARAM,
    XSLT_FUNC_VARIABLE,
    XSLT_FUNC_WHEN,
    XSLT_FUNC_EXTENSION
#ifdef XSLT_REFACTORED
    ,
    XSLT_FUNC_OTHERWISE,
    XSLT_FUNC_FALLBACK,
    XSLT_FUNC_MESSAGE,
    XSLT_FUNC_INCLUDE,
    XSLT_FUNC_ATTRSET,
    XSLT_FUNC_LITERAL_RESULT_ELEMENT,
    XSLT_FUNC_UNKOWN_FORWARDS_COMPAT
#endif
} xsltStyleType;

xsltTransformState

enum xsltTransformState

Enumerator
XSLT_STATE_OK
XSLT_STATE_ERROR
XSLT_STATE_STOPPED

Definition at line 1673 of file xsltInternals.h.

             {
    XSLT_STATE_OK = 0,
    XSLT_STATE_ERROR,
    XSLT_STATE_STOPPED
} xsltTransformState;

Function Documentation

xsltAllocateExtra()

XSLTPUBFUN int XSLTCALL xsltAllocateExtra

(

xsltStylesheetPtr

style

)

xsltAllocateExtra: @style: an XSLT stylesheet

Allocate an extra runtime information slot statically while compiling the stylesheet and return its number

Returns the number of the slot

Definition at line 824 of file xslt.c.

{
    return(style->extrasNr++);
}

Referenced by xsltCompMatchAdd().

xsltAllocateExtraCtxt()

XSLTPUBFUN int XSLTCALL xsltAllocateExtraCtxt

(

xsltTransformContextPtr

ctxt

)

xsltAllocateExtraCtxt: @ctxt: an XSLT transformation context

Allocate an extra runtime information slot at run-time and return its number This make sure there is a slot ready in the transformation context

Returns the number of the slot

Definition at line 840 of file xslt.c.

{
    if (ctxt->extrasNr >= ctxt->extrasMax) {
    int i;
    if (ctxt->extrasNr == 0) {
        ctxt->extrasMax = 20;
        ctxt->extras = (xsltRuntimeExtraPtr)
        xmlMalloc(ctxt->extrasMax * sizeof(xsltRuntimeExtra));
        if (ctxt->extras == NULL) {
        xsltTransformError(ctxt, NULL, NULL,
            "xsltAllocateExtraCtxt: out of memory\n");
        return(0);
        }
        for (i = 0;i < ctxt->extrasMax;i++) {
        ctxt->extras[i].info = NULL;
        ctxt->extras[i].deallocate = NULL;
        ctxt->extras[i].val.ptr = NULL;
        }
 
    } else {
        xsltRuntimeExtraPtr tmp;
 
        ctxt->extrasMax += 100;
        tmp = (xsltRuntimeExtraPtr) xmlRealloc(ctxt->extras,
                    ctxt->extrasMax * sizeof(xsltRuntimeExtra));
        if (tmp == NULL) {
        xsltTransformError(ctxt, NULL, NULL,
            "xsltAllocateExtraCtxt: out of memory\n");
        return(0);
        }
        ctxt->extras = tmp;
        for (i = ctxt->extrasNr;i < ctxt->extrasMax;i++) {
        ctxt->extras[i].info = NULL;
        ctxt->extras[i].deallocate = NULL;
        ctxt->extras[i].val.ptr = NULL;
        }
    }
    }
    return(ctxt->extrasNr++);
}

Referenced by xsltCompMatchAdd().

xsltCompileAttr()

XSLTPUBFUN void XSLTCALL xsltCompileAttr	(	xsltStylesheetPtr	style,
		xmlAttrPtr	attr
	)

xsltCompileAttr: @style: a XSLT process context @attr: the attribute coming from the stylesheet.

Precompile an attribute in a stylesheet, basically it checks if it is an attribute value template, and if yes, establish some structures needed to process it at transformation time.

Definition at line 177 of file attrvt.c.

                                                          {
    const xmlChar *str;
    const xmlChar *cur;
    xmlChar *ret = NULL;
    xmlChar *expr = NULL;
    xmlXPathCompExprPtr comp = NULL;
    xsltAttrVTPtr avt, tmp;
    int i = 0, lastavt = 0;
 
    if ((style == NULL) || (attr == NULL) || (attr->children == NULL))
        return;
    if ((attr->children->type != XML_TEXT_NODE) ||
        (attr->children->next != NULL)) {
        xsltTransformError(NULL, style, attr->parent,
        "Attribute '%s': The content is expected to be a single text "
        "node when compiling an AVT.\n", attr->name);
    style->errors++;
    return;
    }
    str = attr->children->content;
    if ((xmlStrchr(str, '{') == NULL) &&
        (xmlStrchr(str, '}') == NULL)) return;
 
#ifdef WITH_XSLT_DEBUG_AVT
    xsltGenericDebug(xsltGenericDebugContext,
            "Found AVT %s: %s\n", attr->name, str);
#endif
    if (attr->psvi != NULL) {
#ifdef WITH_XSLT_DEBUG_AVT
    xsltGenericDebug(xsltGenericDebugContext,
            "AVT %s: already compiled\n", attr->name);
#endif
        return;
    }
    /*
    * Create a new AVT object.
    */
    avt = xsltNewAttrVT(style);
    if (avt == NULL)
    return;
    attr->psvi = avt;
 
    avt->nsList = xmlGetNsList(attr->doc, attr->parent);
    if (avt->nsList != NULL) {
    while (avt->nsList[i] != NULL)
        i++;
    }
    avt->nsNr = i;
 
    cur = str;
    while (*cur != 0) {
    if (*cur == '{') {
        if (*(cur+1) == '{') {  /* escaped '{' */
            cur++;
        ret = xmlStrncat(ret, str, cur - str);
        cur++;
        str = cur;
        continue;
        }
        if (*(cur+1) == '}') {  /* skip empty AVT */
        ret = xmlStrncat(ret, str, cur - str);
            cur += 2;
        str = cur;
        continue;
        }
        if ((ret != NULL) || (cur - str > 0)) {
        ret = xmlStrncat(ret, str, cur - str);
        str = cur;
        if (avt->nb_seg == 0)
            avt->strstart = 1;
        if ((tmp = xsltSetAttrVTsegment(avt, (void *) ret)) == NULL)
            goto error;
                avt = tmp;
        ret = NULL;
        lastavt = 0;
        }
 
        cur++;
        while ((*cur != 0) && (*cur != '}')) {
        /* Need to check for literal (bug539741) */
        if ((*cur == '\'') || (*cur == '"')) {
            char delim = *(cur++);
            while ((*cur != 0) && (*cur != delim))
            cur++;
            if (*cur != 0)
            cur++;  /* skip the ending delimiter */
        } else
            cur++;
        }
        if (*cur == 0) {
            xsltTransformError(NULL, style, attr->parent,
             "Attribute '%s': The AVT has an unmatched '{'.\n",
             attr->name);
        style->errors++;
        goto error;
        }
        str++;
        expr = xmlStrndup(str, cur - str);
        if (expr == NULL) {
        /*
        * TODO: What needs to be done here?
        */
            XSLT_TODO
        goto error;
        } else {
        comp = xsltXPathCompile(style, expr);
        if (comp == NULL) {
            xsltTransformError(NULL, style, attr->parent,
             "Attribute '%s': Failed to compile the expression "
             "'%s' in the AVT.\n", attr->name, expr);
            style->errors++;
            goto error;
        }
        if (avt->nb_seg == 0)
            avt->strstart = 0;
        if (lastavt == 1) {
            if ((tmp = xsltSetAttrVTsegment(avt, NULL)) == NULL) {
                        xsltTransformError(NULL, style, attr->parent,
                                           "out of memory\n");
                goto error;
                    }
                    avt = tmp;
        }
        if ((tmp = xsltSetAttrVTsegment(avt, (void *) comp)) == NULL) {
                    xsltTransformError(NULL, style, attr->parent,
                                       "out of memory\n");
            goto error;
                }
                avt = tmp;
        lastavt = 1;
        xmlFree(expr);
        expr = NULL;
                comp = NULL;
        }
        cur++;
        str = cur;
    } else if (*cur == '}') {
        cur++;
        if (*cur == '}') {  /* escaped '}' */
        ret = xmlStrncat(ret, str, cur - str);
        cur++;
        str = cur;
        continue;
        } else {
            xsltTransformError(NULL, style, attr->parent,
             "Attribute '%s': The AVT has an unmatched '}'.\n",
             attr->name);
        goto error;
        }
    } else
        cur++;
    }
    if ((ret != NULL) || (cur - str > 0)) {
    ret = xmlStrncat(ret, str, cur - str);
    str = cur;
    if (avt->nb_seg == 0)
        avt->strstart = 1;
    if ((tmp = xsltSetAttrVTsegment(avt, (void *) ret)) == NULL)
        goto error;
        avt = tmp;
    ret = NULL;
    }
 
error:
    if (avt == NULL) {
        xsltTransformError(NULL, style, attr->parent,
        "xsltCompileAttr: malloc problem\n");
    } else {
        if (attr->psvi != avt) {  /* may have changed from realloc */
            attr->psvi = avt;
        /*
         * This is a "hack", but I can't see any clean method of
         * doing it.  If a re-alloc has taken place, then the pointer
         * for this AVT may have changed.  style->attVTs was set by
         * xsltNewAttrVT, so it needs to be re-set to the new value!
         */
        style->attVTs = avt;
    }
    }
    if (ret != NULL)
    xmlFree(ret);
    if (expr != NULL)
    xmlFree(expr);
    if (comp != NULL)
        xmlXPathFreeCompExpr(comp);
}

Referenced by xsltParseTemplateContent().

xsltCreateRVT()

XSLTPUBFUN xmlDocPtr XSLTCALL xsltCreateRVT

(

xsltTransformContextPtr

ctxt

)

xsltCreateRVT: @ctxt: an XSLT transformation context

Creates a Result Value Tree (the XSLT 1.0 term for this is "Result Tree Fragment")

Returns the result value tree or NULL in case of API or internal errors.

Definition at line 65 of file variables.c.

{
    xmlDocPtr container;
 
    /*
    * Question: Why is this function public?
    * Answer: It is called by the EXSLT module.
    */
    if (ctxt == NULL)
    return(NULL);
 
    /*
    * Reuse a RTF from the cache if available.
    */
    if (ctxt->cache->RVT) {
    container = ctxt->cache->RVT;
    ctxt->cache->RVT = (xmlDocPtr) container->next;
    /* clear the internal pointers */
    container->next = NULL;
    container->prev = NULL;
    if (ctxt->cache->nbRVT > 0)
        ctxt->cache->nbRVT--;
#ifdef XSLT_DEBUG_PROFILE_CACHE
    ctxt->cache->dbgReusedRVTs++;
#endif
    return(container);
    }
 
    container = xmlNewDoc(NULL);
    if (container == NULL)
    return(NULL);
    container->dict = ctxt->dict;
    xmlDictReference(container->dict);
    XSLT_MARK_RES_TREE_FRAG(container);
    container->doc = container;
    container->parent = NULL;
    return(container);
}

Referenced by xsltEvalGlobalVariable(), and xsltEvalVariable().

xsltDecimalFormatGetByName()

XSLTPUBFUN xsltDecimalFormatPtr XSLTCALL xsltDecimalFormatGetByName	(	xsltStylesheetPtr	style,
		xmlChar *	name
	)

Definition at line 349 of file xslt.c.

{
    xsltDecimalFormatPtr result = NULL;
 
    if (name == NULL)
    return style->decimalFormat;
 
    while (style != NULL) {
    for (result = style->decimalFormat->next;
         result != NULL;
         result = result->next) {
        if ((result->nsUri == NULL) && xmlStrEqual(name, result->name))
        return result;
    }
    style = xsltNextImport(style);
    }
    return result;
}

xsltDecimalFormatGetByQName()

XSLTPUBFUN xsltDecimalFormatPtr XSLTCALL xsltDecimalFormatGetByQName	(	xsltStylesheetPtr	style,
		const xmlChar *	nsUri,
		const xmlChar *	name
	)

Definition at line 379 of file xslt.c.

{
    xsltDecimalFormatPtr result = NULL;
 
    if (name == NULL)
    return style->decimalFormat;
 
    while (style != NULL) {
    for (result = style->decimalFormat->next;
         result != NULL;
         result = result->next) {
        if (xmlStrEqual(nsUri, result->nsUri) &&
                xmlStrEqual(name, result->name))
        return result;
    }
    style = xsltNextImport(style);
    }
    return result;
}

Referenced by xsltFormatNumberFunction(), and xsltParseStylesheetDecimalFormat().

xsltEvalAVT()

XSLTPUBFUN xmlChar *XSLTCALL xsltEvalAVT	(	xsltTransformContextPtr	ctxt,
		void *	avt,
		xmlNodePtr	node
	)

xsltEvalAVT: @ctxt: the XSLT transformation context @avt: the prevompiled attribute value template info @node: the node hosting the attribute

Process the given AVT, and return the new string value.

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

Definition at line 377 of file attrvt.c.

                                                                      {
    xmlChar *ret = NULL, *tmp;
    xmlXPathCompExprPtr comp;
    xsltAttrVTPtr cur = (xsltAttrVTPtr) avt;
    int i;
    int str;
 
    if ((ctxt == NULL) || (avt == NULL) || (node == NULL))
        return(NULL);
    str = cur->strstart;
    for (i = 0;i < cur->nb_seg;i++) {
        if (str) {
        ret = xmlStrcat(ret, (const xmlChar *) cur->segments[i]);
    } else {
        comp = (xmlXPathCompExprPtr) cur->segments[i];
        tmp = xsltEvalXPathStringNs(ctxt, comp, cur->nsNr, cur->nsList);
        if (tmp != NULL) {
            if (ret != NULL) {
            ret = xmlStrcat(ret, tmp);
            xmlFree(tmp);
        } else {
            ret = tmp;
        }
        }
    }
    str = !str;
    }
    return(ret);
}

Referenced by xsltAttrListTemplateProcess(), and xsltAttrTemplateProcess().

xsltExtensionInstructionResultFinalize()

XSLTPUBFUN int XSLTCALL xsltExtensionInstructionResultFinalize

(

xsltTransformContextPtr ctxt

ATTRIBUTE_UNUSED

)

xsltExtensionInstructionResultFinalize: @ctxt: an XSLT transformation context

Finalizes the data (e.g. result tree fragments) created within a value-returning process (e.g. EXSLT's function). Tree fragments marked as being returned by a function are set to normal state, which means that the fragment garbage collector will free them after the function-calling process exits.

Returns 0 in case of success and -1 in case of API or internal errors.

This function is unsupported in newer releases of libxslt.

Definition at line 208 of file variables.c.

{
    xmlGenericError(xmlGenericErrorContext,
            "xsltExtensionInstructionResultFinalize is unsupported "
            "in this release of libxslt.\n");
    return(-1);
}

xsltExtensionInstructionResultRegister()

XSLTPUBFUN int XSLTCALL xsltExtensionInstructionResultRegister	(	xsltTransformContextPtr ctxt	ATTRIBUTE_UNUSED,
		xmlXPathObjectPtr obj	ATTRIBUTE_UNUSED
	)

xsltExtensionInstructionResultRegister: @ctxt: an XSLT transformation context @obj: an XPath object to be inspected for result tree fragments

Marks the result of a value-returning extension instruction in order to avoid it being garbage collected before the extension instruction exits. Note that one still has to additionally register any newly created tree fragments (via xsltCreateRVT()) with xsltRegisterLocalRVT().

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

It isn't necessary to call this function in newer releases of libxslt.

Definition at line 234 of file variables.c.

{
    return(0);
}

xsltFlagRVTs()

XSLTPUBFUN int XSLTCALL xsltFlagRVTs	(	xsltTransformContextPtr	ctxt,
		xmlXPathObjectPtr	obj,
		int	val
	)

xsltFlagRVTs: @ctxt: an XSLT transformation context @obj: an XPath object to be inspected for result tree fragments @val: the flag value

Updates ownership information of RVTs in @obj according to @val.

@val = XSLT_RVT_FUNC_RESULT for the result of an extension function, so its RVTs won't be destroyed after leaving the returning scope. @val = XSLT_RVT_LOCAL for the result of an extension function to reset the state of its RVTs after it was returned to a new scope. @val = XSLT_RVT_GLOBAL for parts of global variables.

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

Definition at line 258 of file variables.c.

                                                                           {
    int i;
    xmlNodePtr cur;
    xmlDocPtr doc;
 
    if ((ctxt == NULL) || (obj == NULL))
    return(-1);
 
    /*
    * OPTIMIZE TODO: If no local variables/params and no local tree
    * fragments were created, then we don't need to analyse the XPath
    * objects for tree fragments.
    */
 
    if ((obj->type != XPATH_NODESET) && (obj->type != XPATH_XSLT_TREE))
    return(0);
    if ((obj->nodesetval == NULL) || (obj->nodesetval->nodeNr == 0))
    return(0);
 
    for (i = 0; i < obj->nodesetval->nodeNr; i++) {
    cur = obj->nodesetval->nodeTab[i];
    if (cur->type == XML_NAMESPACE_DECL) {
        /*
        * The XPath module sets the owner element of a ns-node on
        * the ns->next field.
        */
        if ((((xmlNsPtr) cur)->next != NULL) &&
        (((xmlNsPtr) cur)->next->type == XML_ELEMENT_NODE))
        {
        cur = (xmlNodePtr) ((xmlNsPtr) cur)->next;
        doc = cur->doc;
        } else {
        xsltTransformError(ctxt, NULL, ctxt->inst,
            "Internal error in xsltFlagRVTs(): "
            "Cannot retrieve the doc of a namespace node.\n");
        return(-1);
        }
    } else {
        doc = cur->doc;
    }
    if (doc == NULL) {
        xsltTransformError(ctxt, NULL, ctxt->inst,
        "Internal error in xsltFlagRVTs(): "
        "Cannot retrieve the doc of a node.\n");
        return(-1);
    }
    if (doc->name && (doc->name[0] == ' ') &&
            doc->compression != XSLT_RVT_GLOBAL) {
        /*
        * This is a result tree fragment.
        * We store ownership information in the @compression field.
        * TODO: How do we know if this is a doc acquired via the
        *  document() function?
        */
#ifdef WITH_XSLT_DEBUG_VARIABLE
            XSLT_TRACE(ctxt, XSLT_TRACE_VARIABLES,
                       xsltGenericDebug(xsltGenericDebugContext,
                       "Flagging RVT %p: %d -> %d\n",
                       (void *) doc, doc->compression, val));
#endif
 
            if (val == XSLT_RVT_LOCAL) {
                if (doc->compression == XSLT_RVT_FUNC_RESULT)
                    doc->compression = XSLT_RVT_LOCAL;
            } else if (val == XSLT_RVT_GLOBAL) {
                if (doc->compression != XSLT_RVT_LOCAL) {
            xmlGenericError(xmlGenericErrorContext,
                            "xsltFlagRVTs: Invalid transition %d => GLOBAL\n",
                            doc->compression);
                    doc->compression = XSLT_RVT_GLOBAL;
                    return(-1);
                }
 
                /* Will be registered as persistant in xsltReleaseLocalRVTs. */
                doc->compression = XSLT_RVT_GLOBAL;
            } else if (val == XSLT_RVT_FUNC_RESULT) {
            doc->compression = val;
            }
    }
    }
 
    return(0);
}

Referenced by xsltEvalGlobalVariable().

xsltFormatNumberConversion()

XSLTPUBFUN xmlXPathError XSLTCALL xsltFormatNumberConversion	(	xsltDecimalFormatPtr	self,
		xmlChar *	format,
		double	number,
		xmlChar **	result
	)

xsltFormatNumberConversion: @self: the decimal format @format: the format requested @number: the value to format

Returns

: the place to output the result

format-number() uses the JDK 1.1 DecimalFormat class:

http://java.sun.com/products/jdk/1.1/docs/api/java.text.DecimalFormat.html

Structure:

pattern := subpattern{;subpattern} subpattern := {prefix}integer{.fraction}{suffix} prefix := '\u0000'..'\uFFFD' - specialCharacters suffix := '\u0000'..'\uFFFD' - specialCharacters integer := '#'* '0'* '0' fraction := '0'* '#'*

Notation: X* 0 or more instances of X (X | Y) either X or Y. X..Y any character from X up to Y, inclusive. S - T characters in S, except those in T

Special Characters:

Symbol Meaning 0 a digit

a digit, zero shows as absent

. placeholder for decimal separator , placeholder for grouping separator. ; separates formats.

• default negative prefix. % multiply by 100 and show as percentage ? multiply by 1000 and show as per mille X any other characters can be used in the prefix or suffix ' used to quote special characters in a prefix or suffix.

Returns a possible XPath error

Definition at line 957 of file numbers.c.

{
    xmlXPathError status = XPATH_EXPRESSION_OK;
    xmlBufferPtr buffer;
    xmlChar *the_format, *prefix = NULL, *suffix = NULL;
    xmlChar *nprefix, *nsuffix = NULL;
    int     prefix_length, suffix_length = 0, nprefix_length, nsuffix_length;
    int     exp10;
    double  scale;
    int     j, len = 0;
    int     self_grouping_len;
    xsltFormatNumberInfo format_info;
    /*
     * delayed_multiplier allows a 'trailing' percent or
     * permille to be treated as suffix
     */
    int     delayed_multiplier = 0;
    /* flag to show no -ve format present for -ve number */
    char    default_sign = 0;
    /* flag to show error found, should use default format */
    char    found_error = 0;
 
    if (xmlStrlen(format) <= 0) {
    xsltTransformError(NULL, NULL, NULL,
                "xsltFormatNumberConversion : "
        "Invalid format (0-length)\n");
    }
    *result = NULL;
    if (xmlXPathIsNaN(number)) {
        if ((self == NULL) || (self->noNumber == NULL))
            *result = xmlStrdup(BAD_CAST "NaN");
        else
            *result = xmlStrdup(self->noNumber);
        return(status);
    }
 
    format_info.integer_hash = 0;
    format_info.integer_digits = 0;
    format_info.frac_digits = 0;
    format_info.frac_hash = 0;
    format_info.group = -1;
    format_info.multiplier = 1;
    format_info.add_decimal = FALSE;
    format_info.is_multiplier_set = FALSE;
    format_info.is_negative_pattern = FALSE;
 
    the_format = format;
 
    /*
     * First we process the +ve pattern to get percent / permille,
     * as well as main format
     */
    prefix = the_format;
    prefix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
    if (prefix_length < 0) {
    found_error = 1;
    goto OUTPUT_NUMBER;
    }
 
    /*
     * Here we process the "number" part of the format.  It gets
     * a little messy because of the percent/per-mille - if that
     * appears at the end, it may be part of the suffix instead
     * of part of the number, so the variable delayed_multiplier
     * is used to handle it
     */
    self_grouping_len = xmlStrlen(self->grouping);
    while ((*the_format != 0) &&
       (xsltUTF8Charcmp(the_format, self->decimalPoint) != 0) &&
       (xsltUTF8Charcmp(the_format, self->patternSeparator) != 0)) {
 
    if (delayed_multiplier != 0) {
        format_info.multiplier = delayed_multiplier;
        format_info.is_multiplier_set = TRUE;
        delayed_multiplier = 0;
    }
    if (xsltUTF8Charcmp(the_format, self->digit) == 0) {
        if (format_info.integer_digits > 0) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        format_info.integer_hash++;
        if (format_info.group >= 0)
        format_info.group++;
    } else if (xsltUTF8Charcmp(the_format, self->zeroDigit) == 0) {
        format_info.integer_digits++;
        if (format_info.group >= 0)
        format_info.group++;
    } else if ((self_grouping_len > 0) &&
        (!xmlStrncmp(the_format, self->grouping, self_grouping_len))) {
        /* Reset group count */
        format_info.group = 0;
        the_format += self_grouping_len;
        continue;
    } else if (xsltUTF8Charcmp(the_format, self->percent) == 0) {
        if (format_info.is_multiplier_set) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        delayed_multiplier = 100;
    } else  if (xsltUTF8Charcmp(the_format, self->permille) == 0) {
        if (format_info.is_multiplier_set) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        delayed_multiplier = 1000;
    } else
        break; /* while */
 
    if ((len=xmlUTF8Strsize(the_format, 1)) < 1) {
        found_error = 1;
        goto OUTPUT_NUMBER;
    }
    the_format += len;
 
    }
 
    /* We have finished the integer part, now work on fraction */
    if ( (*the_format != 0) &&
         (xsltUTF8Charcmp(the_format, self->decimalPoint) == 0) ) {
        format_info.add_decimal = TRUE;
        if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
            found_error = 1;
            goto OUTPUT_NUMBER;
        }
    the_format += len;  /* Skip over the decimal */
    }
 
    while (*the_format != 0) {
 
    if (xsltUTF8Charcmp(the_format, self->zeroDigit) == 0) {
        if (format_info.frac_hash != 0) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        format_info.frac_digits++;
    } else if (xsltUTF8Charcmp(the_format, self->digit) == 0) {
        format_info.frac_hash++;
    } else if (xsltUTF8Charcmp(the_format, self->percent) == 0) {
        if (format_info.is_multiplier_set) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        delayed_multiplier = 100;
        if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
            found_error = 1;
        goto OUTPUT_NUMBER;
        }
        the_format += len;
        continue; /* while */
    } else if (xsltUTF8Charcmp(the_format, self->permille) == 0) {
        if (format_info.is_multiplier_set) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        delayed_multiplier = 1000;
        if  ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
            found_error = 1;
        goto OUTPUT_NUMBER;
        }
        the_format += len;
        continue; /* while */
    } else if (xsltUTF8Charcmp(the_format, self->grouping) != 0) {
        break; /* while */
    }
    if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
        found_error = 1;
        goto OUTPUT_NUMBER;
    }
    the_format += len;
    if (delayed_multiplier != 0) {
        format_info.multiplier = delayed_multiplier;
        delayed_multiplier = 0;
        format_info.is_multiplier_set = TRUE;
    }
    }
 
    /*
     * If delayed_multiplier is set after processing the
     * "number" part, should be in suffix
     */
    if (delayed_multiplier != 0) {
    the_format -= len;
    delayed_multiplier = 0;
    }
 
    suffix = the_format;
    suffix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
    if ( (suffix_length < 0) ||
     ((*the_format != 0) &&
      (xsltUTF8Charcmp(the_format, self->patternSeparator) != 0)) ) {
    found_error = 1;
    goto OUTPUT_NUMBER;
    }
 
    /*
     * We have processed the +ve prefix, number part and +ve suffix.
     * If the number is -ve, we must substitute the -ve prefix / suffix
     */
    if (number < 0) {
        /*
     * Note that j is the number of UTF8 chars before the separator,
     * not the number of bytes! (bug 151975)
     */
        j =  xmlUTF8Strloc(format, self->patternSeparator);
    if (j < 0) {
    /* No -ve pattern present, so use default signing */
        default_sign = 1;
    }
    else {
        /* Skip over pattern separator (accounting for UTF8) */
        the_format = (xmlChar *)xmlUTF8Strpos(format, j + 1);
        /*
         * Flag changes interpretation of percent/permille
         * in -ve pattern
         */
        format_info.is_negative_pattern = TRUE;
        format_info.is_multiplier_set = FALSE;
 
        /* First do the -ve prefix */
        nprefix = the_format;
        nprefix_length = xsltFormatNumberPreSuffix(self,
                    &the_format, &format_info);
        if (nprefix_length<0) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
 
        while (*the_format != 0) {
        if ( (xsltUTF8Charcmp(the_format, (self)->percent) == 0) ||
             (xsltUTF8Charcmp(the_format, (self)->permille)== 0) ) {
            if (format_info.is_multiplier_set) {
            found_error = 1;
            goto OUTPUT_NUMBER;
            }
            format_info.is_multiplier_set = TRUE;
            delayed_multiplier = 1;
        }
        else if (IS_SPECIAL(self, the_format))
            delayed_multiplier = 0;
        else
            break; /* while */
        if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
            found_error = 1;
            goto OUTPUT_NUMBER;
        }
        the_format += len;
        }
        if (delayed_multiplier != 0) {
        format_info.is_multiplier_set = FALSE;
        the_format -= len;
        }
 
        /* Finally do the -ve suffix */
        if (*the_format != 0) {
        nsuffix = the_format;
        nsuffix_length = xsltFormatNumberPreSuffix(self,
                    &the_format, &format_info);
        if (nsuffix_length < 0) {
            found_error = 1;
            goto OUTPUT_NUMBER;
        }
        }
        else
        nsuffix_length = 0;
        if (*the_format != 0) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        /*
         * Here's another Java peculiarity:
         * if -ve prefix/suffix == +ve ones, discard & use default
         */
        if ((nprefix_length != prefix_length) ||
        (nsuffix_length != suffix_length) ||
        ((nprefix_length > 0) &&
         (xmlStrncmp(nprefix, prefix, prefix_length) !=0 )) ||
        ((nsuffix_length > 0) &&
         (xmlStrncmp(nsuffix, suffix, suffix_length) !=0 ))) {
        prefix = nprefix;
        prefix_length = nprefix_length;
        suffix = nsuffix;
        suffix_length = nsuffix_length;
        } /* else {
        default_sign = 1;
        }
        */
    }
    }
 
OUTPUT_NUMBER:
    if (found_error != 0) {
    xsltTransformError(NULL, NULL, NULL,
                "xsltFormatNumberConversion : "
        "error in format string '%s', using default\n", format);
    default_sign = (number < 0.0) ? 1 : 0;
    prefix_length = suffix_length = 0;
    format_info.integer_hash = 0;
    format_info.integer_digits = 1;
    format_info.frac_digits = 1;
    format_info.frac_hash = 4;
    format_info.group = -1;
    format_info.multiplier = 1;
    format_info.add_decimal = TRUE;
    }
 
    /* Apply multiplier */
    number *= (double)format_info.multiplier;
    switch (xmlXPathIsInf(number)) {
    case -1:
        if (self->minusSign == NULL)
        *result = xmlStrdup(BAD_CAST "-");
        else
        *result = xmlStrdup(self->minusSign);
        /* Intentional fall-through */
    case 1:
        if ((self == NULL) || (self->infinity == NULL))
        *result = xmlStrcat(*result, BAD_CAST "Infinity");
        else
        *result = xmlStrcat(*result, self->infinity);
        return(status);
    default:
            break;
    }
 
    buffer = xmlBufferCreate();
    if (buffer == NULL) {
    return XPATH_MEMORY_ERROR;
    }
 
    /* Ready to output our number.  First see if "default sign" is required */
    if (default_sign != 0)
    xmlBufferAdd(buffer, self->minusSign, xmlUTF8Strsize(self->minusSign, 1));
 
    /* Put the prefix into the buffer */
    for (j = 0; j < prefix_length; ) {
    if (*prefix == SYMBOL_QUOTE)
            prefix++;
        len = xmlUTF8Strsize(prefix, 1);
        xmlBufferAdd(buffer, prefix, len);
        prefix += len;
        j += len;
    }
 
    /* Round to n digits */
    number = fabs(number);
    exp10 = format_info.frac_digits + format_info.frac_hash;
    /* DBL_MAX_10_EXP should be 308 on IEEE platforms. */
    if (exp10 > DBL_MAX_10_EXP) {
        if (format_info.frac_digits > DBL_MAX_10_EXP) {
            format_info.frac_digits = DBL_MAX_10_EXP;
            format_info.frac_hash = 0;
        } else {
            format_info.frac_hash = DBL_MAX_10_EXP - format_info.frac_digits;
        }
        exp10 = DBL_MAX_10_EXP;
    }
    scale = pow(10.0, (double) exp10);
    number += .5 / scale;
    number -= fmod(number, 1 / scale);
 
    /* Next do the integer part of the number */
    if ((self->grouping != NULL) &&
        (self->grouping[0] != 0)) {
        int gchar;
 
    len = xmlStrlen(self->grouping);
    gchar = xsltGetUTF8Char(self->grouping, &len);
    xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
                format_info.integer_digits,
                format_info.group,
                gchar, len);
    } else
    xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
                format_info.integer_digits,
                format_info.group,
                ',', 1);
 
    /* Special case: java treats '.#' like '.0', '.##' like '.0#', etc. */
    if ((format_info.integer_digits + format_info.integer_hash +
     format_info.frac_digits == 0) && (format_info.frac_hash > 0)) {
        ++format_info.frac_digits;
    --format_info.frac_hash;
    }
 
    /* Add leading zero, if required */
    if ((floor(number) == 0) &&
    (format_info.integer_digits + format_info.frac_digits == 0)) {
        xmlBufferAdd(buffer, self->zeroDigit, xmlUTF8Strsize(self->zeroDigit, 1));
    }
 
    /* Next the fractional part, if required */
    if (format_info.frac_digits + format_info.frac_hash == 0) {
        if (format_info.add_decimal)
        xmlBufferAdd(buffer, self->decimalPoint,
             xmlUTF8Strsize(self->decimalPoint, 1));
    }
    else {
      number -= floor(number);
    if ((number != 0) || (format_info.frac_digits != 0)) {
        xmlBufferAdd(buffer, self->decimalPoint,
             xmlUTF8Strsize(self->decimalPoint, 1));
        number = floor(scale * number + 0.5);
        for (j = format_info.frac_hash; j > 0; j--) {
        if (fmod(number, 10.0) >= 1.0)
            break; /* for */
        number /= 10.0;
        }
        xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
                format_info.frac_digits + j,
                0, 0, 0);
    }
    }
    /* Put the suffix into the buffer */
    for (j = 0; j < suffix_length; ) {
    if (*suffix == SYMBOL_QUOTE)
            suffix++;
        len = xmlUTF8Strsize(suffix, 1);
        xmlBufferAdd(buffer, suffix, len);
        suffix += len;
        j += len;
    }
 
    *result = xmlStrdup(xmlBufferContent(buffer));
    xmlBufferFree(buffer);
    return status;
}

Referenced by xsltFormatNumberFunction().

xsltFreeAVTList()

XSLTPUBFUN void XSLTCALL xsltFreeAVTList

(

void *

avt

)

xsltFreeAVTList: @avt: pointer to an list of AVT structures

Free up the memory associated to the attribute value templates

Definition at line 131 of file attrvt.c.

                           {
    xsltAttrVTPtr cur = (xsltAttrVTPtr) avt, next;
 
    while (cur != NULL) {
        next = cur->next;
    xsltFreeAttrVT(cur);
    cur = next;
    }
}

Referenced by xsltFreeStylesheet().

xsltFreeRVTs()

XSLTPUBFUN void XSLTCALL xsltFreeRVTs

(

xsltTransformContextPtr

ctxt

)

xsltFreeRVTs: @ctxt: an XSLT transformation context

Frees all registered result value trees (Result Tree Fragments) of the transformation. Internal function; should not be called by user-code.

Definition at line 439 of file variables.c.

{
    xmlDocPtr cur, next;
 
    if (ctxt == NULL)
    return;
    /*
    * Local fragments.
    */
    cur = ctxt->localRVT;
    while (cur != NULL) {
        next = (xmlDocPtr) cur->next;
    if (cur->_private != NULL) {
        xsltFreeDocumentKeys(cur->_private);
        xmlFree(cur->_private);
    }
    xmlFreeDoc(cur);
    cur = next;
    }
    ctxt->localRVT = NULL;
    /*
    * User-created per-template fragments.
    */
    cur = ctxt->tmpRVT;
    while (cur != NULL) {
        next = (xmlDocPtr) cur->next;
    if (cur->_private != NULL) {
        xsltFreeDocumentKeys(cur->_private);
        xmlFree(cur->_private);
    }
    xmlFreeDoc(cur);
    cur = next;
    }
    ctxt->tmpRVT = NULL;
    /*
    * Global fragments.
    */
    cur = ctxt->persistRVT;
    while (cur != NULL) {
        next = (xmlDocPtr) cur->next;
    if (cur->_private != NULL) {
        xsltFreeDocumentKeys(cur->_private);
        xmlFree(cur->_private);
    }
    xmlFreeDoc(cur);
    cur = next;
    }
    ctxt->persistRVT = NULL;
}

Referenced by xsltApplyStylesheetInternal(), and xsltFreeTransformContext().

xsltFreeStackElemList()

XSLTPUBFUN void XSLTCALL xsltFreeStackElemList

(

xsltStackElemPtr

elem

)

xsltFreeStackElemList: @elem: an XSLT stack element

Free up the memory allocated by @elem

Definition at line 626 of file variables.c.

                                             {
    xsltStackElemPtr next;
 
    while (elem != NULL) {
    next = elem->next;
    xsltFreeStackElem(elem);
    elem = next;
    }
}

Referenced by xsltApplyStylesheetInternal(), xsltApplyTemplates(), xsltCallTemplate(), xsltFreeStylesheet(), xsltLocalVariablePop(), and xsltTemplateParamsCleanup().

xsltFreeStylesheet()

XSLTPUBFUN void XSLTCALL xsltFreeStylesheet

(

xsltStylesheetPtr

style

)

xsltFreeStylesheet: @style: an XSLT stylesheet

Free up the memory allocated by @style

Definition at line 965 of file xslt.c.

{
    if (style == NULL)
        return;
 
#ifdef XSLT_REFACTORED
    /*
    * Start with a cleanup of the main stylesheet's doc.
    */
    if ((style->principal == style) && (style->doc))
    xsltCleanupStylesheetTree(style->doc,
        xmlDocGetRootElement(style->doc));
#ifdef XSLT_REFACTORED_XSLT_NSCOMP
    /*
    * Restore changed ns-decls before freeing the document.
    */
    if ((style->doc != NULL) &&
    XSLT_HAS_INTERNAL_NSMAP(style))
    {
    xsltRestoreDocumentNamespaces(XSLT_GET_INTERNAL_NSMAP(style),
        style->doc);
    }
#endif /* XSLT_REFACTORED_XSLT_NSCOMP */
#else
    /*
    * Start with a cleanup of the main stylesheet's doc.
    */
    if ((style->parent == NULL) && (style->doc))
    xsltCleanupStylesheetTree(style->doc,
        xmlDocGetRootElement(style->doc));
#endif /* XSLT_REFACTORED */
 
    xsltFreeKeys(style);
    xsltFreeExts(style);
    xsltFreeTemplateHashes(style);
    xsltFreeDecimalFormatList(style);
    xsltFreeTemplateList(style->templates);
    xsltFreeAttributeSetsHashes(style);
    xsltFreeNamespaceAliasHashes(style);
    xsltFreeStylePreComps(style);
    /*
    * Free documents of all included stylsheet modules of this
    * stylesheet level.
    */
    xsltFreeStyleDocuments(style);
    /*
    * TODO: Best time to shutdown extension stuff?
    */
    xsltShutdownExts(style);
 
    if (style->variables != NULL)
        xsltFreeStackElemList(style->variables);
    if (style->cdataSection != NULL)
        xmlHashFree(style->cdataSection, NULL);
    if (style->stripSpaces != NULL)
        xmlHashFree(style->stripSpaces, NULL);
    if (style->nsHash != NULL)
        xmlHashFree(style->nsHash, NULL);
    if (style->exclPrefixTab != NULL)
        xmlFree(style->exclPrefixTab);
    if (style->method != NULL)
        xmlFree(style->method);
    if (style->methodURI != NULL)
        xmlFree(style->methodURI);
    if (style->version != NULL)
        xmlFree(style->version);
    if (style->encoding != NULL)
        xmlFree(style->encoding);
    if (style->doctypePublic != NULL)
        xmlFree(style->doctypePublic);
    if (style->doctypeSystem != NULL)
        xmlFree(style->doctypeSystem);
    if (style->mediaType != NULL)
        xmlFree(style->mediaType);
    if (style->attVTs)
        xsltFreeAVTList(style->attVTs);
    if (style->imports != NULL)
        xsltFreeStylesheetList(style->imports);
 
#ifdef XSLT_REFACTORED
    /*
    * If this is the principal stylesheet, then
    * free its internal data.
    */
    if (style->principal == style) {
    if (style->principalData) {
        xsltFreePrincipalStylesheetData(style->principalData);
        style->principalData = NULL;
    }
    }
#endif
    /*
    * Better to free the main document of this stylesheet level
    * at the end - so here.
    */
    if (style->doc != NULL) {
        xmlFreeDoc(style->doc);
    }
 
#ifdef WITH_XSLT_DEBUG
    xsltGenericDebug(xsltGenericDebugContext,
                     "freeing dictionary from stylesheet\n");
#endif
    xmlDictFree(style->dict);
 
    if (style->xpathCtxt != NULL)
    xmlXPathFreeContext(style->xpathCtxt);
 
    memset(style, -1, sizeof(xsltStylesheet));
    xmlFree(style);
}

Referenced by node_transform_node_params(), xsltDocumentElem(), xsltFreeStylesheetList(), xsltNewStylesheetInternal(), and xsltParseStylesheetImportedDoc().

xsltInitAllDocKeys()

XSLTPUBFUN int XSLTCALL xsltInitAllDocKeys

(

xsltTransformContextPtr

ctxt

)

xsltInitAllDocKeys: @ctxt: transformation context

INTERNAL ROUTINE ONLY

Check if any keys on the current document need to be computed

Returns 0 in case of success, -1 in case of failure

Definition at line 555 of file keys.c.

{
    xsltStylesheetPtr style;
    xsltKeyDefPtr keyd;
    xsltKeyTablePtr table;
 
    if (ctxt == NULL)
    return(-1);
 
#ifdef KEY_INIT_DEBUG
fprintf(stderr, "xsltInitAllDocKeys %d %d\n",
        ctxt->document->nbKeysComputed, ctxt->nbKeys);
#endif
 
    if (ctxt->document->nbKeysComputed == ctxt->nbKeys)
    return(0);
 
 
    /*
    * TODO: This could be further optimized
    */
    style = ctxt->style;
    while (style) {
    keyd = (xsltKeyDefPtr) style->keys;
    while (keyd != NULL) {
#ifdef KEY_INIT_DEBUG
fprintf(stderr, "Init key %s\n", keyd->name);
#endif
        /*
        * Check if keys with this QName have been already
        * computed.
        */
        table = (xsltKeyTablePtr) ctxt->document->keys;
        while (table) {
        if (((keyd->nameURI != NULL) == (table->nameURI != NULL)) &&
            xmlStrEqual(keyd->name, table->name) &&
            xmlStrEqual(keyd->nameURI, table->nameURI))
        {
            break;
        }
        table = table->next;
        }
        if (table == NULL) {
        /*
        * Keys with this QName have not been yet computed.
        */
        xsltInitDocKeyTable(ctxt, keyd->name, keyd->nameURI);
        }
        keyd = keyd->next;
    }
    style = xsltNextImport(style);
    }
#ifdef KEY_INIT_DEBUG
fprintf(stderr, "xsltInitAllDocKeys: done\n");
#endif
    return(0);
}

Referenced by xsltComputeAllKeys(), and xsltGetKey().

xsltInitCtxtKey()

XSLTPUBFUN int XSLTCALL xsltInitCtxtKey	(	xsltTransformContextPtr	ctxt,
		xsltDocumentPtr	idoc,
		xsltKeyDefPtr	keyDef
	)

xsltInitCtxtKey: @ctxt: an XSLT transformation context @idoc: the document information (holds key values) @keyDef: the key definition

Computes the key tables this key and for the current input document.

Returns: 0 on success, -1 on error

Multiple key definitions for the same name are allowed, so we must check if the key is already present for this doc

If the key was not previously defined, create it now and chain it to the list of keys for the doc

Definition at line 624 of file keys.c.

{
    int i, len, k;
    xmlNodeSetPtr matchList = NULL, keylist;
    xmlXPathObjectPtr matchRes = NULL, useRes = NULL;
    xmlChar *str = NULL;
    xsltKeyTablePtr table;
    xmlNodePtr oldInst, cur;
    xmlNodePtr oldContextNode;
    xsltDocumentPtr oldDocInfo;
    int oldXPPos, oldXPSize;
    xmlNodePtr oldXPNode;
    xmlDocPtr oldXPDoc;
    int oldXPNsNr;
    xmlNsPtr *oldXPNamespaces;
    xmlXPathContextPtr xpctxt;
 
#ifdef KEY_INIT_DEBUG
fprintf(stderr, "xsltInitCtxtKey %s : %d\n", keyDef->name, ctxt->keyInitLevel);
#endif
 
    if ((keyDef->comp == NULL) || (keyDef->usecomp == NULL))
    return(-1);
 
    /*
     * Detect recursive keys
     */
    if (ctxt->keyInitLevel > ctxt->nbKeys) {
#ifdef WITH_XSLT_DEBUG_KEYS
    XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,
               xsltGenericDebug(xsltGenericDebugContext,
               "xsltInitCtxtKey: key definition of %s is recursive\n",
               keyDef->name));
#endif
    xsltTransformError(ctxt, NULL, keyDef->inst,
        "Key definition for %s is recursive\n", keyDef->name);
    ctxt->state = XSLT_STATE_STOPPED;
        return(-1);
    }
    ctxt->keyInitLevel++;
 
    xpctxt = ctxt->xpathCtxt;
    idoc->nbKeysComputed++;
    /*
    * Save context state.
    */
    oldInst = ctxt->inst;
    oldDocInfo = ctxt->document;
    oldContextNode = ctxt->node;
 
    oldXPNode = xpctxt->node;
    oldXPDoc = xpctxt->doc;
    oldXPPos = xpctxt->proximityPosition;
    oldXPSize = xpctxt->contextSize;
    oldXPNsNr = xpctxt->nsNr;
    oldXPNamespaces = xpctxt->namespaces;
 
    /*
    * Set up contexts.
    */
    ctxt->document = idoc;
    ctxt->node = (xmlNodePtr) idoc->doc;
    ctxt->inst = keyDef->inst;
 
    xpctxt->doc = idoc->doc;
    xpctxt->node = (xmlNodePtr) idoc->doc;
    /* TODO : clarify the use of namespaces in keys evaluation */
    xpctxt->namespaces = keyDef->nsList;
    xpctxt->nsNr = keyDef->nsNr;
 
    /*
    * Evaluate the 'match' expression of the xsl:key.
    * TODO: The 'match' is a *pattern*.
    */
    matchRes = xmlXPathCompiledEval(keyDef->comp, xpctxt);
    if (matchRes == NULL) {
 
#ifdef WITH_XSLT_DEBUG_KEYS
    XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
         "xsltInitCtxtKey: %s evaluation failed\n", keyDef->match));
#endif
    xsltTransformError(ctxt, NULL, keyDef->inst,
        "Failed to evaluate the 'match' expression.\n");
    ctxt->state = XSLT_STATE_STOPPED;
    goto error;
    } else {
    if (matchRes->type == XPATH_NODESET) {
        matchList = matchRes->nodesetval;
 
#ifdef WITH_XSLT_DEBUG_KEYS
        if (matchList != NULL)
        XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
             "xsltInitCtxtKey: %s evaluates to %d nodes\n",
                 keyDef->match, matchList->nodeNr));
#endif
    } else {
        /*
        * Is not a node set, but must be.
        */
#ifdef WITH_XSLT_DEBUG_KEYS
        XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
         "xsltInitCtxtKey: %s is not a node set\n", keyDef->match));
#endif
        xsltTransformError(ctxt, NULL, keyDef->inst,
        "The 'match' expression did not evaluate to a node set.\n");
        ctxt->state = XSLT_STATE_STOPPED;
        goto error;
    }
    }
    if ((matchList == NULL) || (matchList->nodeNr <= 0))
    goto exit;
 
    table = (xsltKeyTablePtr) idoc->keys;
    while (table != NULL) {
        if (xmlStrEqual(table->name, keyDef->name) &&
        (((keyDef->nameURI == NULL) && (table->nameURI == NULL)) ||
         ((keyDef->nameURI != NULL) && (table->nameURI != NULL) &&
          (xmlStrEqual(table->nameURI, keyDef->nameURI)))))
        break;
    table = table->next;
    }
    if (table == NULL) {
        table = xsltNewKeyTable(keyDef->name, keyDef->nameURI);
        if (table == NULL)
        goto error;
        table->next = idoc->keys;
        idoc->keys = table;
    }
 
    /*
    * SPEC XSLT 1.0 (XSLT 2.0 does not clarify the context size!)
    * "...the use attribute of the xsl:key element is evaluated with x as
    "  the current node and with a node list containing just x as the
    *  current node list"
    */
    xpctxt->contextSize = 1;
    xpctxt->proximityPosition = 1;
 
    for (i = 0; i < matchList->nodeNr; i++) {
    cur = matchList->nodeTab[i];
    if (! IS_XSLT_REAL_NODE(cur))
        continue;
        ctxt->node = cur;
    xpctxt->node = cur;
    /*
    * Process the 'use' of the xsl:key.
    * SPEC XSLT 1.0:
    * "The use attribute is an expression specifying the values of
    *  the key; the expression is evaluated once for each node that
    *  matches the pattern."
    */
    if (useRes != NULL)
        xmlXPathFreeObject(useRes);
    useRes = xmlXPathCompiledEval(keyDef->usecomp, xpctxt);
    if (useRes == NULL) {
        xsltTransformError(ctxt, NULL, keyDef->inst,
        "Failed to evaluate the 'use' expression.\n");
        ctxt->state = XSLT_STATE_STOPPED;
        break;
    }
    if (useRes->type == XPATH_NODESET) {
        if ((useRes->nodesetval != NULL) &&
        (useRes->nodesetval->nodeNr != 0))
        {
        len = useRes->nodesetval->nodeNr;
        str = xmlXPathCastNodeToString(useRes->nodesetval->nodeTab[0]);
        } else {
        continue;
        }
    } else {
        len = 1;
        if (useRes->type == XPATH_STRING) {
        /*
        * Consume the string value.
        */
        str = useRes->stringval;
        useRes->stringval = NULL;
        } else {
        str = xmlXPathCastToString(useRes);
        }
    }
    /*
    * Process all strings.
    */
    k = 0;
    while (1) {
        if (str == NULL)
        goto next_string;
 
#ifdef WITH_XSLT_DEBUG_KEYS
        XSLT_TRACE(ctxt,XSLT_TRACE_KEYS,xsltGenericDebug(xsltGenericDebugContext,
        "xsl:key : node associated to ('%s', '%s')\n", keyDef->name, str));
#endif
 
        keylist = xmlHashLookup(table->keys, str);
        if (keylist == NULL) {
        keylist = xmlXPathNodeSetCreate(cur);
        if (keylist == NULL)
            goto error;
        if (xmlHashAddEntry(table->keys, str, keylist) < 0) {
                    xmlXPathFreeNodeSet(keylist);
                    goto error;
                }
        } else {
        /*
        * TODO: How do we know if this function failed?
        */
        xmlXPathNodeSetAdd(keylist, cur);
        }
            xsltSetSourceNodeFlags(ctxt, cur, XSLT_SOURCE_NODE_HAS_KEY);
        xmlFree(str);
        str = NULL;
 
next_string:
        k++;
        if (k >= len)
        break;
        str = xmlXPathCastNodeToString(useRes->nodesetval->nodeTab[k]);
    }
    }
 
exit:
error:
    ctxt->keyInitLevel--;
    /*
    * Restore context state.
    */
    xpctxt->node = oldXPNode;
    xpctxt->doc = oldXPDoc;
    xpctxt->nsNr = oldXPNsNr;
    xpctxt->namespaces = oldXPNamespaces;
    xpctxt->proximityPosition = oldXPPos;
    xpctxt->contextSize = oldXPSize;
 
    ctxt->node = oldContextNode;
    ctxt->document = oldDocInfo;
    ctxt->inst = oldInst;
 
    if (str)
    xmlFree(str);
    if (useRes != NULL)
    xmlXPathFreeObject(useRes);
    if (matchRes != NULL)
    xmlXPathFreeObject(matchRes);
    return(0);
}

Referenced by xsltInitCtxtKeys(), and xsltInitDocKeyTable().

xsltIsBlank()

XSLTPUBFUN int XSLTCALL xsltIsBlank

(

xmlChar *

str

)

xsltIsBlank: @str: a string

Check if a string is ignorable

Returns 1 if the string is NULL or made of blanks chars, 0 otherwise

Definition at line 249 of file xslt.c.

                          {
    if (str == NULL)
    return(1);
    while (*str != 0) {
    if (!(IS_BLANK(*str))) return(0);
    str++;
    }
    return(1);
}

Referenced by xsltVariableComp().

xsltLoadStylesheetPI()

XSLTPUBFUN xsltStylesheetPtr XSLTCALL xsltLoadStylesheetPI

(

xmlDocPtr

doc

)

xsltLoadStylesheetPI: @doc: a document to process

This function tries to locate the stylesheet PI in the given document If found, and if contained within the document, it will extract that subtree to build the stylesheet to process @doc (doc itself will be modified). If found but referencing an external document it will attempt to load it and generate a stylesheet from it. In both cases, the resulting stylesheet and the document need to be freed once the transformation is done.

Returns a new XSLT stylesheet structure or NULL if not found.

Definition at line 6915 of file xslt.c.

                                    {
    xmlNodePtr child;
    xsltStylesheetPtr ret = NULL;
    xmlChar *href = NULL;
    xmlURIPtr URI;
 
    xsltInitGlobals();
 
    if (doc == NULL)
    return(NULL);
 
    /*
     * Find the text/xml stylesheet PI id any before the root
     */
    child = doc->children;
    while ((child != NULL) && (child->type != XML_ELEMENT_NODE)) {
    if ((child->type == XML_PI_NODE) &&
        (xmlStrEqual(child->name, BAD_CAST "xml-stylesheet"))) {
        href = xsltParseStylesheetPI(child->content);
        if (href != NULL)
        break;
    }
    child = child->next;
    }
 
    /*
     * If found check the href to select processing
     */
    if (href != NULL) {
#ifdef WITH_XSLT_DEBUG_PARSING
    xsltGenericDebug(xsltGenericDebugContext,
        "xsltLoadStylesheetPI : found PI href=%s\n", href);
#endif
    URI = xmlParseURI((const char *) href);
    if (URI == NULL) {
        xsltTransformError(NULL, NULL, child,
            "xml-stylesheet : href %s is not valid\n", href);
        xmlFree(href);
        return(NULL);
    }
    if ((URI->fragment != NULL) && (URI->scheme == NULL) &&
            (URI->opaque == NULL) && (URI->authority == NULL) &&
            (URI->server == NULL) && (URI->user == NULL) &&
            (URI->path == NULL) && (URI->query == NULL)) {
        xmlAttrPtr ID;
 
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
            "xsltLoadStylesheetPI : Reference to ID %s\n", href);
#endif
        if (URI->fragment[0] == '#')
        ID = xmlGetID(doc, (const xmlChar *) &(URI->fragment[1]));
        else
        ID = xmlGetID(doc, (const xmlChar *) URI->fragment);
        if (ID == NULL) {
        xsltTransformError(NULL, NULL, child,
            "xml-stylesheet : no ID %s found\n", URI->fragment);
        } else {
        xmlDocPtr fake;
        xmlNodePtr subtree, newtree;
        xmlNsPtr ns;
 
#ifdef WITH_XSLT_DEBUG
        xsltGenericDebug(xsltGenericDebugContext,
            "creating new document from %s for embedded stylesheet\n",
            doc->URL);
#endif
        /*
         * move the subtree in a new document passed to
         * the stylesheet analyzer
         */
        subtree = ID->parent;
        fake = xmlNewDoc(NULL);
        if (fake != NULL) {
            /*
            * Should the dictionary still be shared even though
            * the nodes are being copied rather than moved?
            */
            fake->dict = doc->dict;
            xmlDictReference(doc->dict);
#ifdef WITH_XSLT_DEBUG
            xsltGenericDebug(xsltGenericDebugContext,
            "reusing dictionary from %s for embedded stylesheet\n",
            doc->URL);
#endif
 
            newtree = xmlDocCopyNode(subtree, fake, 1);
 
            fake->URL = xmlNodeGetBase(doc, subtree->parent);
#ifdef WITH_XSLT_DEBUG
            xsltGenericDebug(xsltGenericDebugContext,
            "set base URI for embedded stylesheet as %s\n",
            fake->URL);
#endif
 
            /*
            * Add all namespaces in scope of embedded stylesheet to
            * root element of newly created stylesheet document
            */
            while ((subtree = subtree->parent) != (xmlNodePtr)doc) {
            for (ns = subtree->ns; ns; ns = ns->next) {
                xmlNewNs(newtree,  ns->href, ns->prefix);
            }
            }
 
            xmlAddChild((xmlNodePtr)fake, newtree);
            ret = xsltParseStylesheetDoc(fake);
            if (ret == NULL)
            xmlFreeDoc(fake);
        }
        }
    } else {
        xmlChar *URL, *base;
 
        /*
         * Reference to an external stylesheet
         */
 
        base = xmlNodeGetBase(doc, (xmlNodePtr) doc);
        URL = xmlBuildURI(href, base);
        if (URL != NULL) {
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
            "xsltLoadStylesheetPI : fetching %s\n", URL);
#endif
        ret = xsltParseStylesheetFile(URL);
        xmlFree(URL);
        } else {
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
            "xsltLoadStylesheetPI : fetching %s\n", href);
#endif
        ret = xsltParseStylesheetFile(href);
        }
        if (base != NULL)
        xmlFree(base);
    }
    xmlFreeURI(URI);
    xmlFree(href);
    }
    return(ret);
}

xsltNewStylesheet()

XSLTPUBFUN xsltStylesheetPtr XSLTCALL xsltNewStylesheet

(

void

)

xsltNewStylesheet:

Create a new XSLT Stylesheet

Returns the newly allocated xsltStylesheetPtr or NULL in case of error

Definition at line 810 of file xslt.c.

                        {
    return xsltNewStylesheetInternal(NULL);
}

Referenced by xsltDocumentElem().

xsltNumberFormat()

XSLTPUBFUN void XSLTCALL xsltNumberFormat	(	xsltTransformContextPtr	ctxt,
		xsltNumberDataPtr	data,
		xmlNodePtr	node
	)

xsltNumberFormat: @ctxt: the XSLT transformation context @data: the formatting information @node: the data to format

Convert one number.

Definition at line 744 of file numbers.c.

{
    xmlBufferPtr output = NULL;
    int amount, i;
    double number;
    xsltFormat tokens;
 
    if (data->format != NULL) {
        xsltNumberFormatTokenize(data->format, &tokens);
    }
    else {
        xmlChar *format;
 
    /* The format needs to be recomputed each time */
        if (data->has_format == 0)
            return;
    format = xsltEvalAttrValueTemplate(ctxt, data->node,
                         (const xmlChar *) "format",
                         XSLT_NAMESPACE);
        if (format == NULL)
            return;
        xsltNumberFormatTokenize(format, &tokens);
    xmlFree(format);
    }
 
    output = xmlBufferCreate();
    if (output == NULL)
    goto XSLT_NUMBER_FORMAT_END;
 
    /*
     * Evaluate the XPath expression to find the value(s)
     */
    if (data->value) {
    amount = xsltNumberFormatGetValue(ctxt->xpathCtxt,
                      node,
                      data->value,
                      &number);
    if (amount == 1) {
        xsltNumberFormatInsertNumbers(data,
                      &number,
                      1,
                      &tokens,
                      output);
    }
 
    } else if (data->level) {
 
    if (xmlStrEqual(data->level, (const xmlChar *) "single")) {
        amount = xsltNumberFormatGetMultipleLevel(ctxt,
                              node,
                              data->countPat,
                              data->fromPat,
                              &number,
                              1);
        if (amount == 1) {
        xsltNumberFormatInsertNumbers(data,
                          &number,
                          1,
                          &tokens,
                          output);
        }
    } else if (xmlStrEqual(data->level, (const xmlChar *) "multiple")) {
        double numarray[1024];
        int max = sizeof(numarray)/sizeof(numarray[0]);
        amount = xsltNumberFormatGetMultipleLevel(ctxt,
                              node,
                              data->countPat,
                              data->fromPat,
                              numarray,
                              max);
        if (amount > 0) {
        xsltNumberFormatInsertNumbers(data,
                          numarray,
                          amount,
                          &tokens,
                          output);
        }
    } else if (xmlStrEqual(data->level, (const xmlChar *) "any")) {
        amount = xsltNumberFormatGetAnyLevel(ctxt,
                         node,
                         data->countPat,
                         data->fromPat,
                         &number);
        if (amount > 0) {
        xsltNumberFormatInsertNumbers(data,
                          &number,
                          1,
                          &tokens,
                          output);
        }
    }
 
        /*
         * Unlike `match` patterns, `count` and `from` patterns can contain
         * variable references, so we have to clear the pattern match
         * cache if the "direct" matching algorithm was used.
         */
        if (data->countPat != NULL)
            xsltCompMatchClearCache(ctxt, data->countPat);
        if (data->fromPat != NULL)
            xsltCompMatchClearCache(ctxt, data->fromPat);
    }
    /* Insert number as text node */
    xsltCopyTextString(ctxt, ctxt->insert, xmlBufferContent(output), 0);
 
    xmlBufferFree(output);
 
XSLT_NUMBER_FORMAT_END:
    if (tokens.start != NULL)
    xmlFree(tokens.start);
    if (tokens.end != NULL)
    xmlFree(tokens.end);
    for (i = 0;i < tokens.nTokens;i++) {
    if (tokens.tokens[i].separator != NULL)
        xmlFree(tokens.tokens[i].separator);
    }
}

Referenced by xsltNumber().

xsltParseStylesheetDoc()

XSLTPUBFUN xsltStylesheetPtr XSLTCALL xsltParseStylesheetDoc

(

xmlDocPtr

doc

)

xsltParseStylesheetDoc: @doc: an xmlDoc parsed XML

parse an XSLT stylesheet, building the associated structures. doc is kept as a reference within the returned stylesheet, so changes to doc after the parsing will be reflected when the stylesheet is applied, and the doc is automatically freed when the stylesheet is closed.

Returns a new XSLT stylesheet structure.

Definition at line 6736 of file xslt.c.

                                      {
    xsltInitGlobals();
 
    return(xsltParseStylesheetImportedDoc(doc, NULL));
}

Referenced by node_transform_node_params(), xsltLoadStylesheetPI(), and xsltParseStylesheetFile().

xsltParseStylesheetFile()

XSLTPUBFUN xsltStylesheetPtr XSLTCALL xsltParseStylesheetFile

(

const xmlChar *

filename

)

xsltParseStylesheetFile: @filename: the filename/URL to the stylesheet

Load and parse an XSLT stylesheet

Returns a new XSLT stylesheet structure.

Definition at line 6752 of file xslt.c.

                                                 {
    xsltSecurityPrefsPtr sec;
    xsltStylesheetPtr ret;
    xmlDocPtr doc;
 
    xsltInitGlobals();
 
    if (filename == NULL)
    return(NULL);
 
#ifdef WITH_XSLT_DEBUG_PARSING
    xsltGenericDebug(xsltGenericDebugContext,
        "xsltParseStylesheetFile : parse %s\n", filename);
#endif
 
    /*
     * Security framework check
     */
    sec = xsltGetDefaultSecurityPrefs();
    if (sec != NULL) {
    int res;
 
    res = xsltCheckRead(sec, NULL, filename);
    if (res <= 0) {
            if (res == 0)
                xsltTransformError(NULL, NULL, NULL,
                     "xsltParseStylesheetFile: read rights for %s denied\n",
                                 filename);
        return(NULL);
    }
    }
 
    doc = xsltDocDefaultLoader(filename, NULL, XSLT_PARSE_OPTIONS,
                               NULL, XSLT_LOAD_START);
    if (doc == NULL) {
    xsltTransformError(NULL, NULL, NULL,
        "xsltParseStylesheetFile : cannot parse %s\n", filename);
    return(NULL);
    }
    ret = xsltParseStylesheetDoc(doc);
    if (ret == NULL) {
    xmlFreeDoc(doc);
    return(NULL);
    }
 
    return(ret);
}

Referenced by xsltLoadStylesheetPI().

xsltParseStylesheetImportedDoc()

XSLTPUBFUN xsltStylesheetPtr XSLTCALL xsltParseStylesheetImportedDoc	(	xmlDocPtr	doc,
		xsltStylesheetPtr	parentStyle
	)

xsltParseStylesheetImportedDoc: @doc: an xmlDoc parsed XML @parentStyle: pointer to the parent stylesheet (if it exists)

parse an XSLT stylesheet building the associated structures except the processing not needed for imported documents.

Returns a new XSLT stylesheet structure.

Definition at line 6555 of file xslt.c.

                                                  {
    xsltStylesheetPtr retStyle;
 
    if (doc == NULL)
    return(NULL);
 
    retStyle = xsltNewStylesheetInternal(parentStyle);
    if (retStyle == NULL)
    return(NULL);
 
    if (xsltParseStylesheetUser(retStyle, doc) != 0) {
        xsltFreeStylesheet(retStyle);
        return(NULL);
    }
 
    return(retStyle);
}

Referenced by xsltParseStylesheetDoc(), and xsltParseStylesheetImport().

xsltParseStylesheetOutput()

XSLTPUBFUN void XSLTCALL xsltParseStylesheetOutput	(	xsltStylesheetPtr	style,
		xmlNodePtr	cur
	)

xsltParseStylesheetOutput: @style: the XSLT stylesheet @cur: the "output" element

parse an XSLT stylesheet output element and record information related to the stylesheet output

Definition at line 1185 of file xslt.c.

{
    xmlChar *elements,
     *prop;
    xmlChar *element,
     *end;
 
    if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
        return;
 
    prop = xmlGetNsProp(cur, (const xmlChar *) "version", NULL);
    if (prop != NULL) {
        if (style->version != NULL)
            xmlFree(style->version);
        style->version = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *) "encoding", NULL);
    if (prop != NULL) {
        if (style->encoding != NULL)
            xmlFree(style->encoding);
        style->encoding = prop;
    }
 
    /* relaxed to support xt:document
    * TODO KB: What does "relaxed to support xt:document" mean?
    */
    prop = xmlGetNsProp(cur, (const xmlChar *) "method", NULL);
    if (prop != NULL) {
        const xmlChar *URI;
 
        if (style->method != NULL)
            xmlFree(style->method);
        style->method = NULL;
        if (style->methodURI != NULL)
            xmlFree(style->methodURI);
        style->methodURI = NULL;
 
    /*
    * TODO: Don't use xsltGetQNameURI().
    */
    URI = xsltGetQNameURI(cur, &prop);
    if (prop == NULL) {
        if (style != NULL) style->errors++;
    } else if (URI == NULL) {
            if ((xmlStrEqual(prop, (const xmlChar *) "xml")) ||
                (xmlStrEqual(prop, (const xmlChar *) "html")) ||
                (xmlStrEqual(prop, (const xmlChar *) "text"))) {
                style->method = prop;
            } else {
        xsltTransformError(NULL, style, cur,
                                 "invalid value for method: %s\n", prop);
                if (style != NULL) style->warnings++;
                xmlFree(prop);
            }
    } else {
        style->method = prop;
        style->methodURI = xmlStrdup(URI);
    }
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *) "doctype-system", NULL);
    if (prop != NULL) {
        if (style->doctypeSystem != NULL)
            xmlFree(style->doctypeSystem);
        style->doctypeSystem = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *) "doctype-public", NULL);
    if (prop != NULL) {
        if (style->doctypePublic != NULL)
            xmlFree(style->doctypePublic);
        style->doctypePublic = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *) "standalone", NULL);
    if (prop != NULL) {
        if (xmlStrEqual(prop, (const xmlChar *) "yes")) {
            style->standalone = 1;
        } else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
            style->standalone = 0;
        } else {
        xsltTransformError(NULL, style, cur,
                             "invalid value for standalone: %s\n", prop);
            style->errors++;
        }
        xmlFree(prop);
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *) "indent", NULL);
    if (prop != NULL) {
        if (xmlStrEqual(prop, (const xmlChar *) "yes")) {
            style->indent = 1;
        } else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
            style->indent = 0;
        } else {
        xsltTransformError(NULL, style, cur,
                             "invalid value for indent: %s\n", prop);
            style->errors++;
        }
        xmlFree(prop);
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *) "omit-xml-declaration", NULL);
    if (prop != NULL) {
        if (xmlStrEqual(prop, (const xmlChar *) "yes")) {
            style->omitXmlDeclaration = 1;
        } else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
            style->omitXmlDeclaration = 0;
        } else {
        xsltTransformError(NULL, style, cur,
                             "invalid value for omit-xml-declaration: %s\n",
                             prop);
            style->errors++;
        }
        xmlFree(prop);
    }
 
    elements = xmlGetNsProp(cur, (const xmlChar *) "cdata-section-elements",
    NULL);
    if (elements != NULL) {
        if (style->cdataSection == NULL)
            style->cdataSection = xmlHashCreate(10);
        if (style->cdataSection == NULL) {
            xmlFree(elements);
            return;
        }
 
        element = elements;
        while (*element != 0) {
            while (IS_BLANK(*element))
                element++;
            if (*element == 0)
                break;
            end = element;
            while ((*end != 0) && (!IS_BLANK(*end)))
                end++;
            element = xmlStrndup(element, end - element);
            if (element) {
#ifdef WITH_XSLT_DEBUG_PARSING
                xsltGenericDebug(xsltGenericDebugContext,
                                 "add cdata section output element %s\n",
                                 element);
#endif
        if (xmlValidateQName(BAD_CAST element, 0) != 0) {
            xsltTransformError(NULL, style, cur,
            "Attribute 'cdata-section-elements': The value "
            "'%s' is not a valid QName.\n", element);
            xmlFree(element);
            style->errors++;
        } else {
            const xmlChar *URI;
 
            /*
            * TODO: Don't use xsltGetQNameURI().
            */
            URI = xsltGetQNameURI(cur, &element);
            if (element == NULL) {
            /*
            * TODO: We'll report additionally an error
            *  via the stylesheet's error handling.
            */
            xsltTransformError(NULL, style, cur,
                "Attribute 'cdata-section-elements': "
                "Not a valid QName.\n");
            style->errors++;
            } else {
            xmlNsPtr ns;
 
            /*
            * XSLT-1.0 "Each QName is expanded into an
            *  expanded-name using the namespace declarations in
            *  effect on the xsl:output element in which the QName
            *  occurs; if there is a default namespace, it is used
            *  for QNames that do not have a prefix"
            * NOTE: Fix of bug #339570.
            */
            if (URI == NULL) {
                ns = xmlSearchNs(style->doc, cur, NULL);
                if (ns != NULL)
                URI = ns->href;
            }
            xmlHashAddEntry2(style->cdataSection, element, URI,
                (void *) "cdata");
            xmlFree(element);
            }
        }
            }
            element = end;
        }
        xmlFree(elements);
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *) "media-type", NULL);
    if (prop != NULL) {
    if (style->mediaType)
        xmlFree(style->mediaType);
    style->mediaType = prop;
    }
    if (cur->children != NULL) {
    xsltParseContentError(style, cur->children);
    }
}

Referenced by xsltParseStylesheetTop().

xsltParseStylesheetProcess()

XSLTPUBFUN xsltStylesheetPtr XSLTCALL xsltParseStylesheetProcess	(	xsltStylesheetPtr	ret,
		xmlDocPtr	doc
	)

xsltParseStylesheetProcess: @ret: the XSLT stylesheet (the current stylesheet-level) @doc: and xmlDoc parsed XML

Parses an XSLT stylesheet, adding the associated structures. Called by: xsltParseStylesheetImportedDoc() (xslt.c) xsltParseStylesheetInclude() (imports.c)

Returns the value of the @style parameter if everything went right, NULL if something went amiss.

Definition at line 6447 of file xslt.c.

                                                                 {
    xmlNodePtr cur;
 
    xsltInitGlobals();
 
    if (doc == NULL)
    return(NULL);
    if (ret == NULL)
    return(ret);
 
    /*
     * First steps, remove blank nodes,
     * locate the xsl:stylesheet element and the
     * namespace declaration.
     */
    cur = xmlDocGetRootElement(doc);
    if (cur == NULL) {
    xsltTransformError(NULL, ret, (xmlNodePtr) doc,
        "xsltParseStylesheetProcess : empty stylesheet\n");
    return(NULL);
    }
 
    if ((IS_XSLT_ELEM(cur)) &&
    ((IS_XSLT_NAME(cur, "stylesheet")) ||
     (IS_XSLT_NAME(cur, "transform")))) {
#ifdef WITH_XSLT_DEBUG_PARSING
    xsltGenericDebug(xsltGenericDebugContext,
        "xsltParseStylesheetProcess : found stylesheet\n");
#endif
    ret->literal_result = 0;
    xsltParseStylesheetExcludePrefix(ret, cur, 1);
    xsltParseStylesheetExtPrefix(ret, cur, 1);
    } else {
    xsltParseStylesheetExcludePrefix(ret, cur, 0);
    xsltParseStylesheetExtPrefix(ret, cur, 0);
    ret->literal_result = 1;
    }
    if (!ret->nopreproc) {
    xsltPreprocessStylesheet(ret, cur);
    }
    if (ret->literal_result == 0) {
    xsltParseStylesheetTop(ret, cur);
    } else {
    xmlChar *prop;
    xsltTemplatePtr template;
 
    /*
     * the document itself might be the template, check xsl:version
     */
    prop = xmlGetNsProp(cur, (const xmlChar *)"version", XSLT_NAMESPACE);
    if (prop == NULL) {
        xsltTransformError(NULL, ret, cur,
        "xsltParseStylesheetProcess : document is not a stylesheet\n");
        return(NULL);
    }
 
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
        "xsltParseStylesheetProcess : document is stylesheet\n");
#endif
 
    if ((!xmlStrEqual(prop, (const xmlChar *)"1.0")) &&
            (!xmlStrEqual(prop, (const xmlChar *)"1.1"))) {
        xsltTransformError(NULL, ret, cur,
        "xsl:version: only 1.1 features are supported\n");
            ret->forwards_compatible = 1;
        ret->warnings++;
    }
    xmlFree(prop);
 
    /*
     * Create and link the template
     */
    template = xsltNewTemplate();
    if (template == NULL) {
        return(NULL);
    }
    template->next = ret->templates;
    ret->templates = template;
    template->match = xmlStrdup((const xmlChar *)"/");
 
    /*
     * parse the content and register the pattern
     */
    xsltParseTemplateContent(ret, (xmlNodePtr) doc);
    template->elem = (xmlNodePtr) doc;
    template->content = doc->children;
    xsltAddTemplate(ret, template, NULL, NULL);
    ret->literal_result = 1;
    }
 
    return(ret);
}

Referenced by xsltParseStylesheetInclude(), and xsltParseStylesheetUser().

xsltParseStylesheetUser()

XSLTPUBFUN int XSLTCALL xsltParseStylesheetUser	(	xsltStylesheetPtr	style,
		xmlDocPtr	doc
	)

xsltParseStylesheetUser: @style: pointer to the stylesheet @doc: an xmlDoc parsed XML

Parse an XSLT stylesheet with a user-provided stylesheet struct.

Returns 0 if successful, -1 in case of error.

Definition at line 6584 of file xslt.c.

                                                                {
    if ((style == NULL) || (doc == NULL))
    return(-1);
 
    /*
    * Adjust the string dict.
    */
    if (doc->dict != NULL) {
        xmlDictFree(style->dict);
    style->dict = doc->dict;
#ifdef WITH_XSLT_DEBUG
        xsltGenericDebug(xsltGenericDebugContext,
        "reusing dictionary from %s for stylesheet\n",
        doc->URL);
#endif
    xmlDictReference(style->dict);
    }
 
    /*
    * TODO: Eliminate xsltGatherNamespaces(); we must not restrict
    *  the stylesheet to containt distinct namespace prefixes.
    */
    xsltGatherNamespaces(style);
 
#ifdef XSLT_REFACTORED
    {
    xsltCompilerCtxtPtr cctxt;
    xsltStylesheetPtr oldCurSheet;
 
    if (style->parent == NULL) {
        xsltPrincipalStylesheetDataPtr principalData;
        /*
        * Create extra data for the principal stylesheet.
        */
        principalData = xsltNewPrincipalStylesheetData();
        if (principalData == NULL) {
        return(-1);
        }
        style->principalData = principalData;
        /*
        * Create the compilation context
        * ------------------------------
        * (only once; for the principal stylesheet).
        * This is currently the only function where the
        * compilation context is created.
        */
        cctxt = xsltCompilationCtxtCreate(style);
        if (cctxt == NULL) {
        return(-1);
        }
        style->compCtxt = (void *) cctxt;
        cctxt->style = style;
        cctxt->dict = style->dict;
        cctxt->psData = principalData;
        /*
        * Push initial dummy node info.
        */
        cctxt->depth = -1;
        xsltCompilerNodePush(cctxt, (xmlNodePtr) doc);
    } else {
        /*
        * Imported stylesheet.
        */
        cctxt = style->parent->compCtxt;
        style->compCtxt = cctxt;
    }
    /*
    * Save the old and set the current stylesheet structure in the
    * compilation context.
    */
    oldCurSheet = cctxt->style;
    cctxt->style = style;
 
    style->doc = doc;
    xsltParseStylesheetProcess(style, doc);
 
    cctxt->style = oldCurSheet;
    if (style->parent == NULL) {
        /*
        * Pop the initial dummy node info.
        */
        xsltCompilerNodePop(cctxt, (xmlNodePtr) doc);
    } else {
        /*
        * Clear the compilation context of imported
        * stylesheets.
        * TODO: really?
        */
        /* style->compCtxt = NULL; */
    }
 
#ifdef XSLT_REFACTORED_XSLT_NSCOMP
        if (style->errors != 0) {
            /*
            * Restore all changes made to namespace URIs of ns-decls.
            */
            if (cctxt->psData->nsMap)
                xsltRestoreDocumentNamespaces(cctxt->psData->nsMap, doc);
        }
#endif
 
        if (style->parent == NULL) {
            xsltCompilationCtxtFree(style->compCtxt);
            style->compCtxt = NULL;
        }
    }
 
#else /* XSLT_REFACTORED */
    /*
    * Old behaviour.
    */
    style->doc = doc;
    if (xsltParseStylesheetProcess(style, doc) == NULL) {
        style->doc = NULL;
        return(-1);
    }
#endif /* else of XSLT_REFACTORED */
 
    if (style->parent == NULL)
        xsltResolveStylesheetAttributeSet(style);
 
    if (style->errors != 0) {
        /*
        * Detach the doc from the stylesheet; otherwise the doc
        * will be freed in xsltFreeStylesheet().
        */
        style->doc = NULL;
        /*
        * Cleanup the doc if its the main stylesheet.
        */
        if (style->parent == NULL)
            xsltCleanupStylesheetTree(doc, xmlDocGetRootElement(doc));
        return(-1);
    }
 
    return(0);
}

Referenced by xsltParseStylesheetImportedDoc().

xsltParseTemplateContent()

XSLTPUBFUN void XSLTCALL xsltParseTemplateContent	(	xsltStylesheetPtr	style,
		xmlNodePtr	templ
	)

xsltParseTemplateContent: @style: the XSLT stylesheet @templ: the container node (can be a document for literal results)

parse a template content-model Clean-up the template content from unwanted ignorable blank nodes and process xslt:text

Definition at line 4894 of file xslt.c.

                                                                    {
    xmlNodePtr cur, delete;
 
    if ((style == NULL) || (templ == NULL) ||
        (templ->type == XML_NAMESPACE_DECL)) return;
 
    /*
     * This content comes from the stylesheet
     * For stylesheets, the set of whitespace-preserving
     * element names consists of just xsl:text.
     */
    cur = templ->children;
    delete = NULL;
    while (cur != NULL) {
        style->principal->opCount += 1;
 
    if (delete != NULL) {
#ifdef WITH_XSLT_DEBUG_BLANKS
        xsltGenericDebug(xsltGenericDebugContext,
         "xsltParseTemplateContent: removing text\n");
#endif
        xmlUnlinkNode(delete);
        xmlFreeNode(delete);
        delete = NULL;
    }
    if (IS_XSLT_ELEM(cur)) {
            xsltStylePreCompute(style, cur);
 
        if (IS_XSLT_NAME(cur, "text")) {
        /*
        * TODO: Processing of xsl:text should be moved to
        *   xsltPreprocessStylesheet(), since otherwise this
        *   will be performed for every multiply included
        *   stylesheet; i.e. this here is not skipped with
        *   the use of the style->nopreproc flag.
        */
        if (cur->children != NULL) {
            xmlChar *prop;
            xmlNodePtr text = cur->children, next;
            int noesc = 0;
 
            prop = xmlGetNsProp(cur,
            (const xmlChar *)"disable-output-escaping",
            NULL);
            if (prop != NULL) {
#ifdef WITH_XSLT_DEBUG_PARSING
            xsltGenericDebug(xsltGenericDebugContext,
                 "Disable escaping: %s\n", text->content);
#endif
            if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
                noesc = 1;
            } else if (!xmlStrEqual(prop,
                        (const xmlChar *)"no")){
                xsltTransformError(NULL, style, cur,
         "xsl:text: disable-output-escaping allows only yes or no\n");
                style->warnings++;
 
            }
            xmlFree(prop);
            }
 
            while (text != NULL) {
            if (text->type == XML_COMMENT_NODE) {
                text = text->next;
                continue;
            }
            if ((text->type != XML_TEXT_NODE) &&
                 (text->type != XML_CDATA_SECTION_NODE)) {
                xsltTransformError(NULL, style, cur,
         "xsltParseTemplateContent: xslt:text content problem\n");
                style->errors++;
                break;
            }
            if ((noesc) && (text->type != XML_CDATA_SECTION_NODE))
                text->name = xmlStringTextNoenc;
            text = text->next;
            }
 
            /*
             * replace xsl:text by the list of childs
             */
            if (text == NULL) {
            text = cur->children;
            while (text != NULL) {
                if ((style->internalized) &&
                    (text->content != NULL) &&
                    (!xmlDictOwns(style->dict, text->content))) {
 
                /*
                 * internalize the text string
                 */
                if (text->doc->dict != NULL) {
                    const xmlChar *tmp;
 
                    tmp = xmlDictLookup(text->doc->dict,
                                        text->content, -1);
                    if (tmp != text->content) {
                        xmlNodeSetContent(text, NULL);
                    text->content = (xmlChar *) tmp;
                    }
                }
                }
 
                next = text->next;
                xmlUnlinkNode(text);
                            if (xmlAddPrevSibling(cur, text) == NULL) {
                                xsltTransformError(NULL, style, NULL,
                                        "out of memory\n");
                                xmlFreeNode(text);
                            }
                text = next;
            }
            }
        }
        delete = cur;
        goto skip_children;
        }
    }
    else if ((cur->ns != NULL) && (style->nsDefs != NULL) &&
        (xsltCheckExtPrefix(style, cur->ns->prefix)))
    {
        /*
         * okay this is an extension element compile it too
         */
        xsltStylePreCompute(style, cur);
    }
    else if (cur->type == XML_ELEMENT_NODE)
    {
        /*
         * This is an element which will be output as part of the
         * template exectution, precompile AVT if found.
         */
        if ((cur->ns == NULL) && (style->defaultAlias != NULL)) {
        cur->ns = xmlSearchNsByHref(cur->doc, cur,
            style->defaultAlias);
        }
        if (cur->properties != NULL) {
            xmlAttrPtr attr = cur->properties;
 
        while (attr != NULL) {
            xsltCompileAttr(style, attr);
            attr = attr->next;
        }
        }
    }
    /*
     * Skip to next node
     */
    if (cur->children != NULL) {
        if (cur->children->type != XML_ENTITY_DECL) {
        cur = cur->children;
        continue;
        }
    }
skip_children:
    if (cur->next != NULL) {
        cur = cur->next;
        continue;
    }
 
    do {
        cur = cur->parent;
        if (cur == NULL)
        break;
        if (cur == templ) {
        cur = NULL;
        break;
        }
        if (cur->next != NULL) {
        cur = cur->next;
        break;
        }
    } while (cur != NULL);
    }
    if (delete != NULL) {
#ifdef WITH_XSLT_DEBUG_PARSING
    xsltGenericDebug(xsltGenericDebugContext,
     "xsltParseTemplateContent: removing text\n");
#endif
    xmlUnlinkNode(delete);
    xmlFreeNode(delete);
    delete = NULL;
    }
 
    /*
     * Skip the first params
     */
    cur = templ->children;
    while (cur != NULL) {
    if ((IS_XSLT_ELEM(cur)) && (!(IS_XSLT_NAME(cur, "param"))))
        break;
    cur = cur->next;
    }
 
    /*
     * Browse the remainder of the template
     */
    while (cur != NULL) {
    if ((IS_XSLT_ELEM(cur)) && (IS_XSLT_NAME(cur, "param"))) {
        xmlNodePtr param = cur;
 
        xsltTransformError(NULL, style, cur,
        "xsltParseTemplateContent: ignoring misplaced param element\n");
        if (style != NULL) style->warnings++;
            cur = cur->next;
        xmlUnlinkNode(param);
        xmlFreeNode(param);
    } else
        break;
    }
}

Referenced by xsltParseGlobalParam(), xsltParseGlobalVariable(), xsltParseStylesheetAttributeSet(), xsltParseStylesheetProcess(), and xsltParseStylesheetTemplate().

xsltRegisterLocalRVT()

XSLTPUBFUN int XSLTCALL xsltRegisterLocalRVT	(	xsltTransformContextPtr	ctxt,
		xmlDocPtr	RVT
	)

xsltRegisterLocalRVT: @ctxt: an XSLT transformation context @RVT: a result value tree (Result Tree Fragment; xmlDocPtr)

Registers a result value tree (XSLT 1.0 term: Result Tree Fragment) in the RVT garbage collector. The fragment will be freed when the instruction which created the fragment exits.

Returns 0 in case of success and -1 in case of API or internal errors.

Definition at line 159 of file variables.c.

{
    if ((ctxt == NULL) || (RVT == NULL))
    return(-1);
 
    RVT->prev = NULL;
    RVT->compression = XSLT_RVT_LOCAL;
 
    /*
    * When evaluating "select" expressions of xsl:variable
    * and xsl:param, we need to bind newly created tree fragments
    * to the variable itself; otherwise the fragment will be
    * freed before we leave the scope of a var.
    */
    if ((ctxt->contextVariable != NULL) &&
    (XSLT_TCTXT_VARIABLE(ctxt)->flags & XSLT_VAR_IN_SELECT))
    {
    RVT->next = (xmlNodePtr) XSLT_TCTXT_VARIABLE(ctxt)->fragment;
    XSLT_TCTXT_VARIABLE(ctxt)->fragment = RVT;
    return(0);
    }
    /*
    * Store the fragment in the scope of the current instruction.
    * If not reference by a returning instruction (like EXSLT's function),
    * then this fragment will be freed, when the instruction exits.
    */
    RVT->next = (xmlNodePtr) ctxt->localRVT;
    if (ctxt->localRVT != NULL)
    ctxt->localRVT->prev = (xmlNodePtr) RVT;
    ctxt->localRVT = RVT;
    return(0);
}

Referenced by xsltFreeStackElem(), and xsltReleaseLocalRVTs().

xsltRegisterPersistRVT()

XSLTPUBFUN int XSLTCALL xsltRegisterPersistRVT	(	xsltTransformContextPtr	ctxt,
		xmlDocPtr	RVT
	)

xsltRegisterPersistRVT: @ctxt: an XSLT transformation context @RVT: a result value tree (Result Tree Fragment)

Register the result value tree (XSLT 1.0 term: Result Tree Fragment) in the fragment garbage collector. The fragment will be freed when the transformation context is freed.

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

Definition at line 417 of file variables.c.

{
    if ((ctxt == NULL) || (RVT == NULL)) return(-1);
 
    RVT->compression = XSLT_RVT_GLOBAL;
    RVT->prev = NULL;
    RVT->next = (xmlNodePtr) ctxt->persistRVT;
    if (ctxt->persistRVT != NULL)
    ctxt->persistRVT->prev = (xmlNodePtr) RVT;
    ctxt->persistRVT = RVT;
    return(0);
}

Referenced by xsltEvalGlobalVariable(), and xsltReleaseLocalRVTs().

xsltRegisterTmpRVT()

XSLTPUBFUN int XSLTCALL xsltRegisterTmpRVT	(	xsltTransformContextPtr	ctxt,
		xmlDocPtr	RVT
	)

xsltRegisterTmpRVT: @ctxt: an XSLT transformation context @RVT: a result value tree (Result Tree Fragment)

Registers the result value tree (XSLT 1.0 term: Result Tree Fragment) in the garbage collector. The fragment will be freed at the exit of the currently instantiated xsl:template. Obsolete; this function might produce massive memory overhead, since the fragment is only freed when the current xsl:template exits. Use xsltRegisterLocalRVT() instead.

Returns 0 in case of success and -1 in case of API or internal errors.

Definition at line 120 of file variables.c.

{
    if ((ctxt == NULL) || (RVT == NULL))
    return(-1);
 
    RVT->prev = NULL;
    RVT->compression = XSLT_RVT_LOCAL;
 
    /*
    * We'll restrict the lifetime of user-created fragments
    * insinde an xsl:variable and xsl:param to the lifetime of the
    * var/param itself.
    */
    if (ctxt->contextVariable != NULL) {
    RVT->next = (xmlNodePtr) XSLT_TCTXT_VARIABLE(ctxt)->fragment;
    XSLT_TCTXT_VARIABLE(ctxt)->fragment = RVT;
    return(0);
    }
 
    RVT->next = (xmlNodePtr) ctxt->tmpRVT;
    if (ctxt->tmpRVT != NULL)
    ctxt->tmpRVT->prev = (xmlNodePtr) RVT;
    ctxt->tmpRVT = RVT;
    return(0);
}

xsltReleaseRVT()

XSLTPUBFUN void XSLTCALL xsltReleaseRVT	(	xsltTransformContextPtr	ctxt,
		xmlDocPtr	RVT
	)

xsltReleaseRVT: @ctxt: an XSLT transformation context @RVT: a result value tree (Result Tree Fragment)

Either frees the RVT (which is an xmlDoc) or stores it in the context's cache for later reuse.

Definition at line 351 of file variables.c.

{
    if (RVT == NULL)
    return;
 
    if (ctxt && (ctxt->cache->nbRVT < 40)) {
    /*
    * Store the Result Tree Fragment.
    * Free the document info.
    */
    if (RVT->_private != NULL) {
        xsltFreeDocumentKeys((xsltDocumentPtr) RVT->_private);
        xmlFree(RVT->_private);
        RVT->_private = NULL;
    }
    /*
    * Clear the document tree.
    */
    if (RVT->children != NULL) {
        xmlFreeNodeList(RVT->children);
        RVT->children = NULL;
        RVT->last = NULL;
    }
    if (RVT->ids != NULL) {
        xmlFreeIDTable((xmlIDTablePtr) RVT->ids);
        RVT->ids = NULL;
    }
 
    /*
    * Reset the ownership information.
    */
    RVT->compression = 0;
 
    RVT->next = (xmlNodePtr) ctxt->cache->RVT;
    ctxt->cache->RVT = RVT;
 
    ctxt->cache->nbRVT++;
 
#ifdef XSLT_DEBUG_PROFILE_CACHE
    ctxt->cache->dbgCachedRVTs++;
#endif
    return;
    }
    /*
    * Free it.
    */
    if (RVT->_private != NULL) {
    xsltFreeDocumentKeys((xsltDocumentPtr) RVT->_private);
    xmlFree(RVT->_private);
    }
    xmlFreeDoc(RVT);
}

Referenced by xsltApplyXSLTTemplate(), xsltFreeStackElem(), and xsltReleaseLocalRVTs().

xsltUninit()

XSLTPUBFUN void XSLTCALL xsltUninit

(

void

)

xsltUninit:

Uninitializes the processor.

Definition at line 232 of file xslt.c.

                  {
#ifdef XSLT_LOCALE_WINAPI
    xmlFreeRMutex(xsltLocaleMutex);
    xsltLocaleMutex = NULL;
#endif
    initialized = 0;
}

Referenced by xsltCleanupGlobals().