xslt.c File Reference

#include "precomp.h"

Include dependency graph for xslt.c:

Go to the source code of this file.

Macros
#define	IS_BLANK(c)
#define	IS_BLANK_NODE(n)    (((n)->type == XML_TEXT_NODE) && (xsltIsBlank((n)->content)))

Functions
double	xmlXPathStringEvalNumber (const xmlChar *str)
static void	xsltParseContentError (xsltStylesheetPtr style, xmlNodePtr node)
static int	exclPrefixPush (xsltStylesheetPtr style, xmlChar *value)
static xmlChar *	exclPrefixPop (xsltStylesheetPtr style)
void	xsltInit (void)
void	xsltUninit (void)
int	xsltIsBlank (xmlChar *str)
static xsltDecimalFormatPtr	xsltNewDecimalFormat (const xmlChar *nsUri, xmlChar *name)
static void	xsltFreeDecimalFormat (xsltDecimalFormatPtr self)
static void	xsltFreeDecimalFormatList (xsltStylesheetPtr self)
: the decimal-format name to find
xsltDecimalFormatGetByName: @style: the XSLT stylesheet Find decimal-format by name Returns the xsltDecimalFormatPtr
xsltDecimalFormatPtr	xsltDecimalFormatGetByName (xsltStylesheetPtr style, xmlChar *name)

Variables
const char *	xsltEngineVersion = LIBXSLT_VERSION_STRING LIBXSLT_VERSION_EXTRA
const int	xsltLibxsltVersion = LIBXSLT_VERSION
const int	xsltLibxmlVersion = LIBXML_VERSION
static int	initialized = 0

: the local part of the QName
xsltDecimalFormatGetByQName: @style: the XSLT stylesheet @nsUri: the namespace URI of the QName Find decimal-format by QName Returns the xsltDecimalFormatPtr
#define	CUR   (*cur)
#define	SKIP(val)   cur += (val)
#define	NXT(val)   cur[(val)]
#define	SKIP_BLANKS    while (IS_BLANK(CUR)) NEXT
#define	NEXT   ((*cur) ? cur++ : cur)
xsltDecimalFormatPtr	xsltDecimalFormatGetByQName (xsltStylesheetPtr style, const xmlChar *nsUri, const xmlChar *name)
static xsltTemplatePtr	xsltNewTemplate (void)
static void	xsltFreeTemplate (xsltTemplatePtr template)
static void	xsltFreeTemplateList (xsltTemplatePtr template)
static xsltStylesheetPtr	xsltNewStylesheetInternal (xsltStylesheetPtr parent)
xsltStylesheetPtr	xsltNewStylesheet (void)
int	xsltAllocateExtra (xsltStylesheetPtr style)
int	xsltAllocateExtraCtxt (xsltTransformContextPtr ctxt)
static void	xsltFreeStylesheetList (xsltStylesheetPtr style)
static int	xsltCleanupStylesheetTree (xmlDocPtr doc ATTRIBUTE_UNUSED, xmlNodePtr rootElem ATTRIBUTE_UNUSED)
void	xsltFreeStylesheet (xsltStylesheetPtr style)
static int	xsltGetInheritedNsList (xsltStylesheetPtr style, xsltTemplatePtr template, xmlNodePtr node)
void	xsltParseStylesheetOutput (xsltStylesheetPtr style, xmlNodePtr cur)
static void	xsltParseStylesheetDecimalFormat (xsltStylesheetPtr style, xmlNodePtr cur)
static void	xsltParseStylesheetPreserveSpace (xsltStylesheetPtr style, xmlNodePtr cur)
static void	xsltParseStylesheetExtPrefix (xsltStylesheetPtr style, xmlNodePtr cur, int isXsltElem)
static void	xsltParseStylesheetStripSpace (xsltStylesheetPtr style, xmlNodePtr cur)
static int	xsltParseStylesheetExcludePrefix (xsltStylesheetPtr style, xmlNodePtr cur, int isXsltElem)
static void	xsltPreprocessStylesheet (xsltStylesheetPtr style, xmlNodePtr cur)
static void	xsltGatherNamespaces (xsltStylesheetPtr style)
void	xsltParseTemplateContent (xsltStylesheetPtr style, xmlNodePtr templ)
static void	xsltParseStylesheetKey (xsltStylesheetPtr style, xmlNodePtr key)
static void	xsltParseStylesheetTemplate (xsltStylesheetPtr style, xmlNodePtr template)
static void	xsltParseStylesheetTop (xsltStylesheetPtr style, xmlNodePtr top)
xsltStylesheetPtr	xsltParseStylesheetProcess (xsltStylesheetPtr ret, xmlDocPtr doc)
xsltStylesheetPtr	xsltParseStylesheetImportedDoc (xmlDocPtr doc, xsltStylesheetPtr parentStyle)
int	xsltParseStylesheetUser (xsltStylesheetPtr style, xmlDocPtr doc)
xsltStylesheetPtr	xsltParseStylesheetDoc (xmlDocPtr doc)
xsltStylesheetPtr	xsltParseStylesheetFile (const xmlChar *filename)
static xmlChar *	xsltParseStylesheetPI (const xmlChar *value)
xsltStylesheetPtr	xsltLoadStylesheetPI (xmlDocPtr doc)

Macro Definition Documentation

CUR

#define CUR   (*cur)

Definition at line 6765 of file xslt.c.

IS_BLANK

#define IS_BLANK

(

c

)

Value:

                     (((c) == 0x20) || ((c) == 0x09) || ((c) == 0xA) || \
                     ((c) == 0x0D))

Definition at line 79 of file xslt.c.

IS_BLANK_NODE

#define IS_BLANK_NODE

(

n

)

(((n)->type == XML_TEXT_NODE) && (xsltIsBlank((n)->content)))

Definition at line 85 of file xslt.c.

NEXT

#define NEXT   ((*cur) ? cur++ : cur)

Definition at line 6770 of file xslt.c.

NXT

#define NXT

(

val

)

cur[(val)]

Definition at line 6767 of file xslt.c.

SKIP

#define SKIP

(

val

)

cur += (val)

Definition at line 6766 of file xslt.c.

SKIP_BLANKS

#define SKIP_BLANKS    while (IS_BLANK(CUR)) NEXT

Definition at line 6768 of file xslt.c.

Function Documentation

exclPrefixPop()

static xmlChar * exclPrefixPop ( xsltStylesheetPtr  style )

static

exclPrefixPop: @style: the transformation stylesheet

Pop an excluded prefix value from the stack

Returns the stored excluded prefix value

Definition at line 170 of file xslt.c.

{
    xmlChar *ret;
 
    if (style->exclPrefixNr <= 0)
        return (0);
    style->exclPrefixNr--;
    if (style->exclPrefixNr > 0)
        style->exclPrefix = style->exclPrefixTab[style->exclPrefixNr - 1];
    else
        style->exclPrefix = NULL;
    ret = style->exclPrefixTab[style->exclPrefixNr];
    style->exclPrefixTab[style->exclPrefixNr] = 0;
    return (ret);
}

Referenced by xsltPreprocessStylesheet().

exclPrefixPush()

static int exclPrefixPush ( xsltStylesheetPtr  style, xmlChar *  value  )

static

exclPrefixPush: @style: the transformation stylesheet @value: the excluded namespace name to push on the stack

Push an excluded namespace name on the stack

Returns the new index in the stack or -1 if already present or in case of error

Definition at line 127 of file xslt.c.

{
    int i;
 
    if (style->exclPrefixMax == 0) {
        style->exclPrefixMax = 4;
        style->exclPrefixTab =
            (xmlChar * *)xmlMalloc(style->exclPrefixMax *
                                   sizeof(style->exclPrefixTab[0]));
        if (style->exclPrefixTab == NULL) {
            xmlGenericError(xmlGenericErrorContext, "malloc failed !\n");
            return (-1);
        }
    }
    /* do not push duplicates */
    for (i = 0;i < style->exclPrefixNr;i++) {
        if (xmlStrEqual(style->exclPrefixTab[i], value))
        return(-1);
    }
    if (style->exclPrefixNr >= style->exclPrefixMax) {
        style->exclPrefixMax *= 2;
        style->exclPrefixTab =
            (xmlChar * *)xmlRealloc(style->exclPrefixTab,
                                    style->exclPrefixMax *
                                    sizeof(style->exclPrefixTab[0]));
        if (style->exclPrefixTab == NULL) {
            xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
            return (-1);
        }
    }
    style->exclPrefixTab[style->exclPrefixNr] = value;
    style->exclPrefix = value;
    return (style->exclPrefixNr++);
}

Referenced by xsltParseStylesheetExcludePrefix().

xmlXPathStringEvalNumber()

double xmlXPathStringEvalNumber

(

const xmlChar *

str

)

Referenced by xsltParseStylesheetTemplate().

xsltAllocateExtra()

int 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 809 of file xslt.c.

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

Referenced by xsltCompMatchAdd().

xsltAllocateExtraCtxt()

int 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 825 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().

xsltCleanupStylesheetTree()

static int xsltCleanupStylesheetTree ( xmlDocPtr doc  ATTRIBUTE_UNUSED, xmlNodePtr rootElem  ATTRIBUTE_UNUSED  )

static

xsltCleanupStylesheetTree:

@doc: the document-node @node: the element where the stylesheet is rooted at

Actually @node need not be the document-element, but currently Libxslt does not support embedded stylesheets.

Returns 0 if OK, -1 on API or internal errors.

Definition at line 895 of file xslt.c.

{
#if 0 /* TODO: Currently disabled, since probably not needed. */
    xmlNodePtr cur;
 
    if ((doc == NULL) || (rootElem == NULL) ||
    (rootElem->type != XML_ELEMENT_NODE) ||
    (doc != rootElem->doc))
    return(-1);
 
    /*
    * Cleanup was suggested by Aleksey Sanin:
    * Clear the PSVI field to avoid problems if the
    * node-tree of the stylesheet is intended to be used for
    * further processing by the user (e.g. for compiling it
    * once again - although not recommended).
    */
 
    cur = rootElem;
    while (cur != NULL) {
    if (cur->type == XML_ELEMENT_NODE) {
        /*
        * Clear the PSVI field.
        */
        cur->psvi = NULL;
        if (cur->children) {
        cur = cur->children;
        continue;
        }
    }
 
leave_node:
    if (cur == rootElem)
        break;
    if (cur->next != NULL)
        cur = cur->next;
    else {
        cur = cur->parent;
        if (cur == NULL)
        break;
        goto leave_node;
    }
    }
#endif /* #if 0 */
    return(0);
}

Referenced by xsltFreeStylesheet(), and xsltParseStylesheetUser().

xsltDecimalFormatGetByName()

xsltDecimalFormatPtr xsltDecimalFormatGetByName	(	xsltStylesheetPtr	style,
		xmlChar *	name
	)

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

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

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

xsltFreeDecimalFormat()

static void xsltFreeDecimalFormat ( xsltDecimalFormatPtr  self )

static

Definition at line 278 of file xslt.c.

{
    if (self != NULL) {
    if (self->digit)
        xmlFree(self->digit);
    if (self->patternSeparator)
        xmlFree(self->patternSeparator);
    if (self->decimalPoint)
        xmlFree(self->decimalPoint);
    if (self->grouping)
        xmlFree(self->grouping);
    if (self->percent)
        xmlFree(self->percent);
    if (self->permille)
        xmlFree(self->permille);
    if (self->zeroDigit)
        xmlFree(self->zeroDigit);
    if (self->minusSign)
        xmlFree(self->minusSign);
    if (self->infinity)
        xmlFree(self->infinity);
    if (self->noNumber)
        xmlFree(self->noNumber);
    if (self->name)
        xmlFree(self->name);
    xmlFree(self);
    }
}

Referenced by xsltFreeDecimalFormatList().

xsltFreeDecimalFormatList()

static void xsltFreeDecimalFormatList ( xsltStylesheetPtr  self )

static

Definition at line 308 of file xslt.c.

{
    xsltDecimalFormatPtr iter;
    xsltDecimalFormatPtr tmp;
 
    if (self == NULL)
    return;
 
    iter = self->decimalFormat;
    while (iter != NULL) {
    tmp = iter->next;
    xsltFreeDecimalFormat(iter);
    iter = tmp;
    }
}

Referenced by xsltFreeStylesheet().

xsltFreeStylesheet()

void xsltFreeStylesheet

(

xsltStylesheetPtr

style

)

xsltFreeStylesheet: @style: an XSLT stylesheet

Free up the memory allocated by @style

Definition at line 950 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 xsltDocumentElem(), xsltFreeStylesheetList(), xsltNewStylesheetInternal(), and xsltParseStylesheetImportedDoc().

xsltFreeStylesheetList()

static void xsltFreeStylesheetList ( xsltStylesheetPtr  style )

static

xsltFreeStylesheetList: @style: an XSLT stylesheet list

Free up the memory allocated by the list @style

Definition at line 873 of file xslt.c.

                                                {
    xsltStylesheetPtr next;
 
    while (style != NULL) {
    next = style->next;
    xsltFreeStylesheet(style);
    style = next;
    }
}

Referenced by xsltFreeStylesheet().

xsltFreeTemplate()

static void xsltFreeTemplate ( xsltTemplatePtr  template )

static

xsltFreeTemplate: @template: an XSLT template

Free up the memory allocated by @template

Definition at line 415 of file xslt.c.

                                           {
    if (template == NULL)
    return;
    if (template->match) xmlFree(template->match);
/*
*   NOTE: @name and @nameURI are put into the string dict now.
*   if (template->name) xmlFree(template->name);
*   if (template->nameURI) xmlFree(template->nameURI);
*/
/*
    if (template->mode) xmlFree(template->mode);
    if (template->modeURI) xmlFree(template->modeURI);
 */
    if (template->inheritedNs) xmlFree(template->inheritedNs);
 
    /* free profiling data */
    if (template->templCalledTab) xmlFree(template->templCalledTab);
    if (template->templCountTab) xmlFree(template->templCountTab);
 
    memset(template, -1, sizeof(xsltTemplate));
    xmlFree(template);
}

Referenced by xsltFreeTemplateList().

xsltFreeTemplateList()

static void xsltFreeTemplateList ( xsltTemplatePtr  template )

static

xsltFreeTemplateList: @template: an XSLT template list

Free up the memory allocated by all the elements of @template

Definition at line 445 of file xslt.c.

                                               {
    xsltTemplatePtr cur;
 
    while (template != NULL) {
    cur = template;
    template = template->next;
    xsltFreeTemplate(cur);
    }
}

Referenced by xsltFreeStylesheet().

xsltGatherNamespaces()

static void xsltGatherNamespaces ( xsltStylesheetPtr  style )

static

xsltGatherNamespaces: @style: the XSLT stylesheet

Browse the stylesheet and build the namspace hash table which will be used for XPath interpretation. If needed do a bit of normalization

Definition at line 3674 of file xslt.c.

                                              {
    xmlNodePtr cur;
    const xmlChar *URI;
 
    if (style == NULL)
        return;
    /*
     * TODO: basically if the stylesheet uses the same prefix for different
     *       patterns, well they may be in problem, hopefully they will get
     *       a warning first.
     */
    /*
    * TODO: Eliminate the use of the hash for XPath expressions.
    *   An expression should be evaluated in the context of the in-scope
    *   namespaces; eliminate the restriction of an XML document to contain
    *   no duplicate prefixes for different namespace names.
    *
    */
    cur = xmlDocGetRootElement(style->doc);
    while (cur != NULL) {
    if (cur->type == XML_ELEMENT_NODE) {
        xmlNsPtr ns = cur->nsDef;
        while (ns != NULL) {
        if (ns->prefix != NULL) {
            if (style->nsHash == NULL) {
            style->nsHash = xmlHashCreate(10);
            if (style->nsHash == NULL) {
                xsltTransformError(NULL, style, cur,
         "xsltGatherNamespaces: failed to create hash table\n");
                style->errors++;
                return;
            }
            }
            URI = xmlHashLookup(style->nsHash, ns->prefix);
            if ((URI != NULL) && (!xmlStrEqual(URI, ns->href))) {
            xsltTransformError(NULL, style, cur,
         "Namespaces prefix %s used for multiple namespaces\n",ns->prefix);
            style->warnings++;
            } else if (URI == NULL) {
            xmlHashUpdateEntry(style->nsHash, ns->prefix,
                (void *) ns->href, NULL);
 
#ifdef WITH_XSLT_DEBUG_PARSING
            xsltGenericDebug(xsltGenericDebugContext,
         "Added namespace: %s mapped to %s\n", ns->prefix, ns->href);
#endif
            }
        }
        ns = ns->next;
        }
    }
 
    /*
     * Skip to next node
     */
    if (cur->children != NULL) {
        if (cur->children->type != XML_ENTITY_DECL) {
        cur = cur->children;
        continue;
        }
    }
    if (cur->next != NULL) {
        cur = cur->next;
        continue;
    }
 
    do {
        cur = cur->parent;
        if (cur == NULL)
        break;
        if (cur == (xmlNodePtr) style->doc) {
        cur = NULL;
        break;
        }
        if (cur->next != NULL) {
        cur = cur->next;
        break;
        }
    } while (cur != NULL);
    }
}

Referenced by xsltParseStylesheetUser().

xsltGetInheritedNsList()

static int xsltGetInheritedNsList ( xsltStylesheetPtr  style, xsltTemplatePtr  template, xmlNodePtr  node  )

static

xsltGetInheritedNsList: @style: the stylesheet @template: the template @node: the current node

Search all the namespace applying to a given element except the ones from excluded output prefixes currently in scope. Initialize the template inheritedNs list with it.

Returns the number of entries found

Definition at line 1086 of file xslt.c.

{
    xmlNsPtr cur;
    xmlNsPtr *ret = NULL;
    int nbns = 0;
    int maxns = 10;
    int i;
 
    if ((style == NULL) || (template == NULL) || (node == NULL) ||
    (template->inheritedNsNr != 0) || (template->inheritedNs != NULL))
    return(0);
    while (node != NULL) {
        if (node->type == XML_ELEMENT_NODE) {
            cur = node->nsDef;
            while (cur != NULL) {
        if (xmlStrEqual(cur->href, XSLT_NAMESPACE))
            goto skip_ns;
 
        if ((cur->prefix != NULL) &&
            (xsltCheckExtPrefix(style, cur->prefix)))
            goto skip_ns;
        /*
        * Check if this namespace was excluded.
        * Note that at this point only the exclusions defined
        * on the topmost stylesheet element are in the exclusion-list.
        */
        for (i = 0;i < style->exclPrefixNr;i++) {
            if (xmlStrEqual(cur->href, style->exclPrefixTab[i]))
            goto skip_ns;
        }
                if (ret == NULL) {
                    ret =
                        (xmlNsPtr *) xmlMalloc((maxns + 1) *
                                               sizeof(xmlNsPtr));
                    if (ret == NULL) {
                        xmlGenericError(xmlGenericErrorContext,
                                        "xsltGetInheritedNsList : out of memory!\n");
                        return(0);
                    }
                    ret[nbns] = NULL;
                }
        /*
        * Skip shadowed namespace bindings.
        */
                for (i = 0; i < nbns; i++) {
                    if ((cur->prefix == ret[i]->prefix) ||
                        (xmlStrEqual(cur->prefix, ret[i]->prefix)))
                        break;
                }
                if (i >= nbns) {
                    if (nbns >= maxns) {
                        maxns *= 2;
                        ret = (xmlNsPtr *) xmlRealloc(ret,
                                                      (maxns +
                                                       1) *
                                                      sizeof(xmlNsPtr));
                        if (ret == NULL) {
                            xmlGenericError(xmlGenericErrorContext,
                                            "xsltGetInheritedNsList : realloc failed!\n");
                            return(0);
                        }
                    }
                    ret[nbns++] = cur;
                    ret[nbns] = NULL;
                }
skip_ns:
                cur = cur->next;
            }
        }
        node = node->parent;
    }
    if (nbns != 0) {
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
                         "template has %d inherited namespaces\n", nbns);
#endif
    template->inheritedNsNr = nbns;
    template->inheritedNs = ret;
    }
    return (nbns);
}

Referenced by xsltParseStylesheetTemplate().

xsltInit()

void xsltInit

(

void

)

xsltInit:

Initializes the processor (e.g. registers built-in extensions, etc.)

Definition at line 201 of file xslt.c.

                {
    if (initialized == 0) {
    initialized = 1;
#ifdef XSLT_LOCALE_WINAPI
    xsltLocaleMutex = xmlNewRMutex();
#endif
        xsltRegisterAllExtras();
    }
}

Referenced by xsltNewStylesheetInternal().

xsltIsBlank()

int 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 234 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()

xsltStylesheetPtr 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 6873 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);
}

xsltNewDecimalFormat()

static xsltDecimalFormatPtr xsltNewDecimalFormat ( const xmlChar *  nsUri, xmlChar *  name  )

static

Definition at line 250 of file xslt.c.

{
    xsltDecimalFormatPtr self;
    /* UTF-8 for 0x2030 */
    static const xmlChar permille[4] = {0xe2, 0x80, 0xb0, 0};
 
    self = xmlMalloc(sizeof(xsltDecimalFormat));
    if (self != NULL) {
    self->next = NULL;
        self->nsUri = nsUri;
    self->name = name;
 
    /* Default values */
    self->digit = xmlStrdup(BAD_CAST("#"));
    self->patternSeparator = xmlStrdup(BAD_CAST(";"));
    self->decimalPoint = xmlStrdup(BAD_CAST("."));
    self->grouping = xmlStrdup(BAD_CAST(","));
    self->percent = xmlStrdup(BAD_CAST("%"));
    self->permille = xmlStrdup(BAD_CAST(permille));
    self->zeroDigit = xmlStrdup(BAD_CAST("0"));
    self->minusSign = xmlStrdup(BAD_CAST("-"));
    self->infinity = xmlStrdup(BAD_CAST("Infinity"));
    self->noNumber = xmlStrdup(BAD_CAST("NaN"));
    }
    return self;
}

Referenced by xsltNewStylesheetInternal(), and xsltParseStylesheetDecimalFormat().

xsltNewStylesheet()

xsltStylesheetPtr xsltNewStylesheet

(

void

)

xsltNewStylesheet:

Create a new XSLT Stylesheet

Returns the newly allocated xsltStylesheetPtr or NULL in case of error

Definition at line 795 of file xslt.c.

                        {
    return xsltNewStylesheetInternal(NULL);
}

Referenced by xsltDocumentElem().

xsltNewStylesheetInternal()

static xsltStylesheetPtr xsltNewStylesheetInternal ( xsltStylesheetPtr  parent )

static

xsltNewStylesheetInternal: @parent: the parent stylesheet or NULL

Create a new XSLT Stylesheet

Returns the newly allocated xsltStylesheetPtr or NULL in case of error

Definition at line 730 of file xslt.c.

                                                    {
    xsltStylesheetPtr ret = NULL;
 
    ret = (xsltStylesheetPtr) xmlMalloc(sizeof(xsltStylesheet));
    if (ret == NULL) {
    xsltTransformError(NULL, NULL, NULL,
        "xsltNewStylesheet : malloc failed\n");
    goto internal_err;
    }
    memset(ret, 0, sizeof(xsltStylesheet));
 
    ret->parent = parent;
    ret->omitXmlDeclaration = -1;
    ret->standalone = -1;
    ret->decimalFormat = xsltNewDecimalFormat(NULL, NULL);
    ret->indent = -1;
    ret->errors = 0;
    ret->warnings = 0;
    ret->exclPrefixNr = 0;
    ret->exclPrefixMax = 0;
    ret->exclPrefixTab = NULL;
    ret->extInfos = NULL;
    ret->extrasNr = 0;
    ret->internalized = 1;
    ret->literal_result = 0;
    ret->forwards_compatible = 0;
    ret->dict = xmlDictCreate();
#ifdef WITH_XSLT_DEBUG
    xsltGenericDebug(xsltGenericDebugContext,
    "creating dictionary for stylesheet\n");
#endif
 
    if (parent == NULL) {
        ret->principal = ret;
 
        ret->xpathCtxt = xmlXPathNewContext(NULL);
        if (ret->xpathCtxt == NULL) {
            xsltTransformError(NULL, NULL, NULL,
                    "xsltNewStylesheet: xmlXPathNewContext failed\n");
            goto internal_err;
        }
        if (xmlXPathContextSetCache(ret->xpathCtxt, 1, -1, 0) == -1)
            goto internal_err;
    } else {
        ret->principal = parent->principal;
    }
 
    xsltInit();
 
    return(ret);
 
internal_err:
    if (ret != NULL)
    xsltFreeStylesheet(ret);
    return(NULL);
}

Referenced by xsltNewStylesheet(), and xsltParseStylesheetImportedDoc().

xsltNewTemplate()

static xsltTemplatePtr xsltNewTemplate ( void  )

static

xsltNewTemplate:

Create a new XSLT Template

Returns the newly allocated xsltTemplatePtr or NULL in case of error

Definition at line 394 of file xslt.c.

                      {
    xsltTemplatePtr cur;
 
    cur = (xsltTemplatePtr) xmlMalloc(sizeof(xsltTemplate));
    if (cur == NULL) {
    xsltTransformError(NULL, NULL, NULL,
        "xsltNewTemplate : malloc failed\n");
    return(NULL);
    }
    memset(cur, 0, sizeof(xsltTemplate));
    cur->priority = XSLT_PAT_NO_PRIORITY;
    return(cur);
}

Referenced by xsltParseStylesheetProcess(), and xsltParseStylesheetTemplate().

xsltParseContentError()

static void xsltParseContentError ( xsltStylesheetPtr  style, xmlNodePtr  node  )

static

xsltParseContentError:

@style: the stylesheet @node: the node where the error occured

Compile-time error function.

Definition at line 97 of file xslt.c.

{
    if ((style == NULL) || (node == NULL))
    return;
 
    if (IS_XSLT_ELEM(node))
    xsltTransformError(NULL, style, node,
        "The XSLT-element '%s' is not allowed at this position.\n",
        node->name);
    else
    xsltTransformError(NULL, style, node,
        "The element '%s' is not allowed at this position.\n",
        node->name);
    style->errors++;
}

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

xsltParseStylesheetDecimalFormat()

static void xsltParseStylesheetDecimalFormat ( xsltStylesheetPtr  style, xmlNodePtr  cur  )

static

xsltParseStylesheetDecimalFormat: @style: the XSLT stylesheet @cur: the "decimal-format" element

<xsl:decimal-format name = qname, decimal-separator = char, grouping-separator = char, infinity = string, minus-sign = char, NaN = string, percent = char per-mille = char, zero-digit = char, digit = char, pattern-separator = char />

parse an XSLT stylesheet decimal-format element and and record the formatting characteristics

Definition at line 1399 of file xslt.c.

{
    xmlChar *prop;
    xsltDecimalFormatPtr format;
    xsltDecimalFormatPtr iter;
 
    if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
    return;
 
    format = style->decimalFormat;
 
    prop = xmlGetNsProp(cur, BAD_CAST("name"), NULL);
    if (prop != NULL) {
        const xmlChar *nsUri;
 
        if (xmlValidateQName(prop, 0) != 0) {
            xsltTransformError(NULL, style, cur,
                "xsl:decimal-format: Invalid QName '%s'.\n", prop);
        style->warnings++;
            xmlFree(prop);
            return;
        }
        /*
        * TODO: Don't use xsltGetQNameURI().
        */
        nsUri = xsltGetQNameURI(cur, &prop);
        if (prop == NULL) {
        style->warnings++;
            return;
        }
    format = xsltDecimalFormatGetByQName(style, nsUri, prop);
    if (format != NULL) {
        xsltTransformError(NULL, style, cur,
     "xsltParseStylestyleDecimalFormat: %s already exists\n", prop);
        style->warnings++;
            xmlFree(prop);
        return;
    }
    format = xsltNewDecimalFormat(nsUri, prop);
    if (format == NULL) {
        xsltTransformError(NULL, style, cur,
     "xsltParseStylestyleDecimalFormat: failed creating new decimal-format\n");
        style->errors++;
            xmlFree(prop);
        return;
    }
    /* Append new decimal-format structure */
    for (iter = style->decimalFormat; iter->next; iter = iter->next)
        ;
    if (iter)
        iter->next = format;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"decimal-separator", NULL);
    if (prop != NULL) {
    if (format->decimalPoint != NULL) xmlFree(format->decimalPoint);
    format->decimalPoint  = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"grouping-separator", NULL);
    if (prop != NULL) {
    if (format->grouping != NULL) xmlFree(format->grouping);
    format->grouping  = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"infinity", NULL);
    if (prop != NULL) {
    if (format->infinity != NULL) xmlFree(format->infinity);
    format->infinity  = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"minus-sign", NULL);
    if (prop != NULL) {
    if (format->minusSign != NULL) xmlFree(format->minusSign);
    format->minusSign  = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"NaN", NULL);
    if (prop != NULL) {
    if (format->noNumber != NULL) xmlFree(format->noNumber);
    format->noNumber  = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"percent", NULL);
    if (prop != NULL) {
    if (format->percent != NULL) xmlFree(format->percent);
    format->percent  = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"per-mille", NULL);
    if (prop != NULL) {
    if (format->permille != NULL) xmlFree(format->permille);
    format->permille  = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"zero-digit", NULL);
    if (prop != NULL) {
    if (format->zeroDigit != NULL) xmlFree(format->zeroDigit);
    format->zeroDigit  = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"digit", NULL);
    if (prop != NULL) {
    if (format->digit != NULL) xmlFree(format->digit);
    format->digit  = prop;
    }
 
    prop = xmlGetNsProp(cur, (const xmlChar *)"pattern-separator", NULL);
    if (prop != NULL) {
    if (format->patternSeparator != NULL) xmlFree(format->patternSeparator);
    format->patternSeparator  = prop;
    }
    if (cur->children != NULL) {
    xsltParseContentError(style, cur->children);
    }
}

Referenced by xsltParseStylesheetTop().

xsltParseStylesheetDoc()

xsltStylesheetPtr xsltParseStylesheetDoc

(

xmlDocPtr

doc

)

xsltParseStylesheetDoc: @doc: and 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 6695 of file xslt.c.

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

Referenced by xsltLoadStylesheetPI(), and xsltParseStylesheetFile().

xsltParseStylesheetExcludePrefix()

static int xsltParseStylesheetExcludePrefix ( xsltStylesheetPtr  style, xmlNodePtr  cur, int  isXsltElem  )

static

xsltParseStylesheetExcludePrefix: @style: the XSLT stylesheet @cur: the current point in the stylesheet

parse an XSLT stylesheet exclude prefix and record namespaces needing stripping

Returns the number of Excluded prefixes added at that level

Definition at line 1735 of file xslt.c.

{
    int nb = 0;
    xmlChar *prefixes;
    xmlChar *prefix, *end;
 
    if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
    return(0);
 
    if (isXsltElem)
    prefixes = xmlGetNsProp(cur,
        (const xmlChar *)"exclude-result-prefixes", NULL);
    else
    prefixes = xmlGetNsProp(cur,
        (const xmlChar *)"exclude-result-prefixes", XSLT_NAMESPACE);
 
    if (prefixes == NULL) {
    return(0);
    }
 
    prefix = prefixes;
    while (*prefix != 0) {
    while (IS_BLANK(*prefix)) prefix++;
    if (*prefix == 0)
        break;
        end = prefix;
    while ((*end != 0) && (!IS_BLANK(*end))) end++;
    prefix = xmlStrndup(prefix, end - prefix);
    if (prefix) {
        xmlNsPtr ns;
 
        if (xmlStrEqual(prefix, (const xmlChar *)"#default"))
        ns = xmlSearchNs(style->doc, cur, NULL);
        else
        ns = xmlSearchNs(style->doc, cur, prefix);
        if (ns == NULL) {
        xsltTransformError(NULL, style, cur,
        "xsl:exclude-result-prefixes : undefined namespace %s\n",
                             prefix);
        if (style != NULL) style->warnings++;
        } else {
        if (exclPrefixPush(style, (xmlChar *) ns->href) >= 0) {
#ifdef WITH_XSLT_DEBUG_PARSING
            xsltGenericDebug(xsltGenericDebugContext,
            "exclude result prefix %s\n", prefix);
#endif
            nb++;
        }
        }
        xmlFree(prefix);
    }
    prefix = end;
    }
    xmlFree(prefixes);
    return(nb);
}

Referenced by xsltParseStylesheetProcess(), and xsltPreprocessStylesheet().

xsltParseStylesheetExtPrefix()

static void xsltParseStylesheetExtPrefix ( xsltStylesheetPtr  style, xmlNodePtr  cur, int  isXsltElem  )

static

xsltParseStylesheetExtPrefix: @style: the XSLT stylesheet @template: the "extension-element-prefixes" prefix

parse an XSLT stylesheet's "extension-element-prefix" attribute value and register the namespaces of extension instruction. SPEC "A namespace is designated as an extension namespace by using an extension-element-prefixes attribute on: 1) an xsl:stylesheet element 2) an xsl:extension-element-prefixes attribute on a literal result element 3) an extension instruction."

Definition at line 1599 of file xslt.c.

                                 {
    xmlChar *prefixes;
    xmlChar *prefix, *end;
 
    if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
    return;
 
    if (isXsltElem) {
    /* For xsl:stylesheet/xsl:transform. */
    prefixes = xmlGetNsProp(cur,
        (const xmlChar *)"extension-element-prefixes", NULL);
    } else {
    /* For literal result elements and extension instructions. */
    prefixes = xmlGetNsProp(cur,
        (const xmlChar *)"extension-element-prefixes", XSLT_NAMESPACE);
    }
    if (prefixes == NULL) {
    return;
    }
 
    prefix = prefixes;
    while (*prefix != 0) {
    while (IS_BLANK(*prefix)) prefix++;
    if (*prefix == 0)
        break;
        end = prefix;
    while ((*end != 0) && (!IS_BLANK(*end))) end++;
    prefix = xmlStrndup(prefix, end - prefix);
    if (prefix) {
        xmlNsPtr ns;
 
        if (xmlStrEqual(prefix, (const xmlChar *)"#default"))
        ns = xmlSearchNs(style->doc, cur, NULL);
        else
        ns = xmlSearchNs(style->doc, cur, prefix);
        if (ns == NULL) {
        xsltTransformError(NULL, style, cur,
        "xsl:extension-element-prefix : undefined namespace %s\n",
                             prefix);
        if (style != NULL) style->warnings++;
        } else {
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
            "add extension prefix %s\n", prefix);
#endif
        xsltRegisterExtPrefix(style, prefix, ns->href);
        }
        xmlFree(prefix);
    }
    prefix = end;
    }
    xmlFree(prefixes);
}

Referenced by xsltParseStylesheetProcess().

xsltParseStylesheetFile()

xsltStylesheetPtr 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 6711 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()

xsltStylesheetPtr 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 6514 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().

xsltParseStylesheetKey()

static void xsltParseStylesheetKey ( xsltStylesheetPtr  style, xmlNodePtr  key  )

static

xsltParseStylesheetKey: @style: the XSLT stylesheet @key: the "key" element

<xsl:key name = qname, match = pattern, use = expression />

parse an XSLT stylesheet key definition and register it

Definition at line 5098 of file xslt.c.

                                                                {
    xmlChar *prop = NULL;
    xmlChar *use = NULL;
    xmlChar *match = NULL;
    xmlChar *name = NULL;
    xmlChar *nameURI = NULL;
 
    if ((style == NULL) || (key == NULL) || (key->type != XML_ELEMENT_NODE))
    return;
 
    /*
     * Get arguments
     */
    prop = xmlGetNsProp(key, (const xmlChar *)"name", NULL);
    if (prop != NULL) {
        const xmlChar *URI;
 
    /*
    * TODO: Don't use xsltGetQNameURI().
    */
    URI = xsltGetQNameURI(key, &prop);
    if (prop == NULL) {
        if (style != NULL) style->errors++;
        goto error;
    } else {
        name = prop;
        if (URI != NULL)
        nameURI = xmlStrdup(URI);
    }
#ifdef WITH_XSLT_DEBUG_PARSING
    xsltGenericDebug(xsltGenericDebugContext,
         "xsltParseStylesheetKey: name %s\n", name);
#endif
    } else {
    xsltTransformError(NULL, style, key,
        "xsl:key : error missing name\n");
    if (style != NULL) style->errors++;
    goto error;
    }
 
    match = xmlGetNsProp(key, (const xmlChar *)"match", NULL);
    if (match == NULL) {
    xsltTransformError(NULL, style, key,
        "xsl:key : error missing match\n");
    if (style != NULL) style->errors++;
    goto error;
    }
 
    use = xmlGetNsProp(key, (const xmlChar *)"use", NULL);
    if (use == NULL) {
    xsltTransformError(NULL, style, key,
        "xsl:key : error missing use\n");
    if (style != NULL) style->errors++;
    goto error;
    }
 
    /*
     * register the keys
     */
    xsltAddKey(style, name, nameURI, match, use, key);
 
 
error:
    if (use != NULL)
    xmlFree(use);
    if (match != NULL)
    xmlFree(match);
    if (name != NULL)
    xmlFree(name);
    if (nameURI != NULL)
    xmlFree(nameURI);
 
    if (key->children != NULL) {
    xsltParseContentError(style, key->children);
    }
}

Referenced by xsltParseStylesheetTop().

xsltParseStylesheetOutput()

void 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 1181 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)
            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().

xsltParseStylesheetPI()

static xmlChar * xsltParseStylesheetPI ( const xmlChar *  value )

static

xsltParseStylesheetPI: @value: the value of the PI

This function checks that the type is text/xml and extracts the URI-Reference for the stylesheet

Returns the URI-Reference for the stylesheet or NULL (it need to be freed by the caller)

Definition at line 6783 of file xslt.c.

                                            {
    const xmlChar *cur;
    const xmlChar *start;
    xmlChar *val;
    xmlChar tmp;
    xmlChar *href = NULL;
    int isXml = 0;
 
    if (value == NULL)
    return(NULL);
 
    cur = value;
    while (CUR != 0) {
    SKIP_BLANKS;
    if ((CUR == 't') && (NXT(1) == 'y') && (NXT(2) == 'p') &&
        (NXT(3) == 'e')) {
        SKIP(4);
        SKIP_BLANKS;
        if (CUR != '=')
        continue;
        NEXT;
        if ((CUR != '\'') && (CUR != '"'))
        continue;
        tmp = CUR;
        NEXT;
        start = cur;
        while ((CUR != 0) && (CUR != tmp))
        NEXT;
        if (CUR != tmp)
        continue;
        val = xmlStrndup(start, cur - start);
        NEXT;
        if (val == NULL)
        return(NULL);
        if ((xmlStrcasecmp(val, BAD_CAST "text/xml")) &&
        (xmlStrcasecmp(val, BAD_CAST "text/xsl"))) {
                xmlFree(val);
        break;
        }
        isXml = 1;
        xmlFree(val);
    } else if ((CUR == 'h') && (NXT(1) == 'r') && (NXT(2) == 'e') &&
        (NXT(3) == 'f')) {
        SKIP(4);
        SKIP_BLANKS;
        if (CUR != '=')
        continue;
        NEXT;
        if ((CUR != '\'') && (CUR != '"'))
        continue;
        tmp = CUR;
        NEXT;
        start = cur;
        while ((CUR != 0) && (CUR != tmp))
        NEXT;
        if (CUR != tmp)
        continue;
        if (href == NULL)
        href = xmlStrndup(start, cur - start);
        NEXT;
    } else {
        while ((CUR != 0) && (!IS_BLANK(CUR)))
        NEXT;
    }
 
    }
 
    if (!isXml) {
    if (href != NULL)
        xmlFree(href);
    href = NULL;
    }
    return(href);
}

Referenced by xsltLoadStylesheetPI().

xsltParseStylesheetPreserveSpace()

static void xsltParseStylesheetPreserveSpace ( xsltStylesheetPtr  style, xmlNodePtr  cur  )

static

xsltParseStylesheetPreserveSpace: @style: the XSLT stylesheet @cur: the "preserve-space" element

parse an XSLT stylesheet preserve-space element and record elements needing preserving

Definition at line 1526 of file xslt.c.

                                                                          {
    xmlChar *elements;
    xmlChar *element, *end;
 
    if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
    return;
 
    elements = xmlGetNsProp(cur, (const xmlChar *)"elements", NULL);
    if (elements == NULL) {
    xsltTransformError(NULL, style, cur,
        "xsltParseStylesheetPreserveSpace: missing elements attribute\n");
    if (style != NULL) style->warnings++;
    return;
    }
 
    if (style->stripSpaces == NULL)
    style->stripSpaces = xmlHashCreate(10);
    if (style->stripSpaces == NULL)
    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 preserved space element %s\n", element);
#endif
        if (xmlStrEqual(element, (const xmlChar *)"*")) {
        style->stripAll = -1;
        } else {
        const xmlChar *URI;
 
        /*
        * TODO: Don't use xsltGetQNameURI().
        */
                URI = xsltGetQNameURI(cur, &element);
 
        xmlHashAddEntry2(style->stripSpaces, element, URI,
                (xmlChar *) "preserve");
        }
        xmlFree(element);
    }
    element = end;
    }
    xmlFree(elements);
    if (cur->children != NULL) {
    xsltParseContentError(style, cur->children);
    }
}

Referenced by xsltParseStylesheetTop().

xsltParseStylesheetProcess()

xsltStylesheetPtr 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 6406 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().

xsltParseStylesheetStripSpace()

static void xsltParseStylesheetStripSpace ( xsltStylesheetPtr  style, xmlNodePtr  cur  )

static

xsltParseStylesheetStripSpace: @style: the XSLT stylesheet @cur: the "strip-space" element

parse an XSLT stylesheet's strip-space element and record the elements needing stripping

Definition at line 1665 of file xslt.c.

                                                                       {
    xmlChar *elements;
    xmlChar *element, *end;
 
    if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
    return;
 
    elements = xmlGetNsProp(cur, (const xmlChar *)"elements", NULL);
    if (elements == NULL) {
    xsltTransformError(NULL, style, cur,
        "xsltParseStylesheetStripSpace: missing elements attribute\n");
    if (style != NULL) style->warnings++;
    return;
    }
 
    if (style->stripSpaces == NULL)
    style->stripSpaces = xmlHashCreate(10);
    if (style->stripSpaces == NULL)
    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 stripped space element %s\n", element);
#endif
        if (xmlStrEqual(element, (const xmlChar *)"*")) {
        style->stripAll = 1;
        } else {
        const xmlChar *URI;
 
        /*
        * TODO: Don't use xsltGetQNameURI().
        */
                URI = xsltGetQNameURI(cur, &element);
 
        xmlHashAddEntry2(style->stripSpaces, element, URI,
                    (xmlChar *) "strip");
        }
        xmlFree(element);
    }
    element = end;
    }
    xmlFree(elements);
    if (cur->children != NULL) {
    xsltParseContentError(style, cur->children);
    }
}

Referenced by xsltParseStylesheetTop().

xsltParseStylesheetTemplate()

static void xsltParseStylesheetTemplate ( xsltStylesheetPtr  style, xmlNodePtr  template  )

static

xsltParseStylesheetTemplate: @style: the XSLT stylesheet @template: the "template" element

parse an XSLT stylesheet template building the associated structures

Definition at line 5350 of file xslt.c.

                                                                          {
    xsltTemplatePtr ret;
    xmlChar *prop;
    xmlChar *mode = NULL;
    xmlChar *modeURI = NULL;
    double  priority;
 
    if ((style == NULL) || (template == NULL) ||
        (template->type != XML_ELEMENT_NODE))
    return;
 
    /*
     * Create and link the structure
     */
    ret = xsltNewTemplate();
    if (ret == NULL)
    return;
    ret->next = style->templates;
    style->templates = ret;
    ret->style = style;
 
    /*
     * Get inherited namespaces
     */
    /*
    * TODO: Apply the optimized in-scope-namespace mechanism
    *   as for the other XSLT instructions.
    */
    xsltGetInheritedNsList(style, ret, template);
 
    /*
     * Get arguments
     */
    prop = xmlGetNsProp(template, (const xmlChar *)"mode", NULL);
    if (prop != NULL) {
        const xmlChar *URI;
 
    /*
    * TODO: Don't use xsltGetQNameURI().
    */
    URI = xsltGetQNameURI(template, &prop);
    if (prop == NULL) {
        if (style != NULL) style->errors++;
        goto error;
    } else {
        mode = prop;
        if (URI != NULL)
        modeURI = xmlStrdup(URI);
    }
    ret->mode = xmlDictLookup(style->dict, mode, -1);
    ret->modeURI = xmlDictLookup(style->dict, modeURI, -1);
#ifdef WITH_XSLT_DEBUG_PARSING
    xsltGenericDebug(xsltGenericDebugContext,
         "xsltParseStylesheetTemplate: mode %s\n", mode);
#endif
        if (mode != NULL) xmlFree(mode);
    if (modeURI != NULL) xmlFree(modeURI);
    }
    prop = xmlGetNsProp(template, (const xmlChar *)"match", NULL);
    if (prop != NULL) {
    if (ret->match != NULL) xmlFree(ret->match);
    ret->match  = prop;
    }
 
    prop = xmlGetNsProp(template, (const xmlChar *)"priority", NULL);
    if (prop != NULL) {
    priority = xmlXPathStringEvalNumber(prop);
    ret->priority = (float) priority;
    xmlFree(prop);
    }
 
    prop = xmlGetNsProp(template, (const xmlChar *)"name", NULL);
    if (prop != NULL) {
        const xmlChar *URI;
 
    /*
    * TODO: Don't use xsltGetQNameURI().
    */
    URI = xsltGetQNameURI(template, &prop);
    if (prop == NULL) {
        if (style != NULL) style->errors++;
        goto error;
    } else {
        if (xmlValidateNCName(prop,0)) {
            xsltTransformError(NULL, style, template,
                "xsl:template : error invalid name '%s'\n", prop);
        if (style != NULL) style->errors++;
                xmlFree(prop);
        goto error;
        }
        ret->name = xmlDictLookup(style->dict, BAD_CAST prop, -1);
        xmlFree(prop);
        prop = NULL;
        if (URI != NULL)
        ret->nameURI = xmlDictLookup(style->dict, BAD_CAST URI, -1);
        else
        ret->nameURI = NULL;
    }
    }
 
    /*
     * parse the content and register the pattern
     */
    xsltParseTemplateContent(style, template);
    ret->elem = template;
    ret->content = template->children;
    xsltAddTemplate(style, ret, ret->mode, ret->modeURI);
 
error:
    return;
}

Referenced by xsltParseStylesheetTop().

xsltParseStylesheetTop()

static void xsltParseStylesheetTop ( xsltStylesheetPtr  style, xmlNodePtr  top  )

static

xsltParseStylesheetTop: @style: the XSLT stylesheet @top: the top level "stylesheet" or "transform" element

scan the top level elements of an XSL stylesheet

Definition at line 6078 of file xslt.c.

                                                                {
    xmlNodePtr cur;
    xmlChar *prop;
#ifdef WITH_XSLT_DEBUG_PARSING
    int templates = 0;
#endif
 
    if ((top == NULL) || (top->type != XML_ELEMENT_NODE))
    return;
 
    prop = xmlGetNsProp(top, (const xmlChar *)"version", NULL);
    if (prop == NULL) {
    xsltTransformError(NULL, style, top,
        "xsl:version is missing: document may not be a stylesheet\n");
    if (style != NULL) style->warnings++;
    } else {
    if ((!xmlStrEqual(prop, (const xmlChar *)"1.0")) &&
            (!xmlStrEqual(prop, (const xmlChar *)"1.1"))) {
        xsltTransformError(NULL, style, top,
        "xsl:version: only 1.1 features are supported\n");
        if (style != NULL) {
                style->forwards_compatible = 1;
                style->warnings++;
            }
    }
    xmlFree(prop);
    }
 
    /*
     * process xsl:import elements
     */
    cur = top->children;
    while (cur != NULL) {
        if (IS_BLANK_NODE(cur)) {
            cur = cur->next;
            continue;
        }
        if (IS_XSLT_ELEM(cur) && IS_XSLT_NAME(cur, "import")) {
            if (xsltParseStylesheetImport(style, cur) != 0)
                if (style != NULL) style->errors++;
        } else
            break;
        cur = cur->next;
    }
 
    /*
     * process other top-level elements
     */
    while (cur != NULL) {
    if (IS_BLANK_NODE(cur)) {
        cur = cur->next;
        continue;
    }
    if (cur->type == XML_TEXT_NODE) {
        if (cur->content != NULL) {
        xsltTransformError(NULL, style, cur,
            "misplaced text node: '%s'\n", cur->content);
        }
        if (style != NULL) style->errors++;
            cur = cur->next;
        continue;
    }
    if ((cur->type == XML_ELEMENT_NODE) && (cur->ns == NULL)) {
        xsltGenericError(xsltGenericErrorContext,
             "Found a top-level element %s with null namespace URI\n",
             cur->name);
        if (style != NULL) style->errors++;
        cur = cur->next;
        continue;
    }
    if ((cur->type == XML_ELEMENT_NODE) && (!(IS_XSLT_ELEM(cur)))) {
        xsltTopLevelFunction function;
 
        function = xsltExtModuleTopLevelLookup(cur->name,
                           cur->ns->href);
        if (function != NULL)
        function(style, cur);
 
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
            "xsltParseStylesheetTop : found foreign element %s\n",
            cur->name);
#endif
            cur = cur->next;
        continue;
    }
    if (IS_XSLT_NAME(cur, "import")) {
        xsltTransformError(NULL, style, cur,
            "xsltParseStylesheetTop: ignoring misplaced import element\n");
        if (style != NULL) style->errors++;
        } else if (IS_XSLT_NAME(cur, "include")) {
        if (xsltParseStylesheetInclude(style, cur) != 0)
        if (style != NULL) style->errors++;
        } else if (IS_XSLT_NAME(cur, "strip-space")) {
        xsltParseStylesheetStripSpace(style, cur);
        } else if (IS_XSLT_NAME(cur, "preserve-space")) {
        xsltParseStylesheetPreserveSpace(style, cur);
        } else if (IS_XSLT_NAME(cur, "output")) {
        xsltParseStylesheetOutput(style, cur);
        } else if (IS_XSLT_NAME(cur, "key")) {
        xsltParseStylesheetKey(style, cur);
        } else if (IS_XSLT_NAME(cur, "decimal-format")) {
        xsltParseStylesheetDecimalFormat(style, cur);
        } else if (IS_XSLT_NAME(cur, "attribute-set")) {
        xsltParseStylesheetAttributeSet(style, cur);
        } else if (IS_XSLT_NAME(cur, "variable")) {
        xsltParseGlobalVariable(style, cur);
        } else if (IS_XSLT_NAME(cur, "param")) {
        xsltParseGlobalParam(style, cur);
        } else if (IS_XSLT_NAME(cur, "template")) {
#ifdef WITH_XSLT_DEBUG_PARSING
        templates++;
#endif
        xsltParseStylesheetTemplate(style, cur);
        } else if (IS_XSLT_NAME(cur, "namespace-alias")) {
        xsltNamespaceAlias(style, cur);
    } else {
            if ((style != NULL) && (style->forwards_compatible == 0)) {
            xsltTransformError(NULL, style, cur,
            "xsltParseStylesheetTop: unknown %s element\n",
            cur->name);
            if (style != NULL) style->errors++;
        }
    }
    cur = cur->next;
    }
#ifdef WITH_XSLT_DEBUG_PARSING
    xsltGenericDebug(xsltGenericDebugContext,
            "parsed %d templates\n", templates);
#endif
}

Referenced by xsltParseStylesheetProcess().

xsltParseStylesheetUser()

int 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 6543 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->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);
    }
 
    if (style->parent == NULL)
        xsltResolveStylesheetAttributeSet(style);
 
    return(0);
}

Referenced by xsltParseStylesheetImportedDoc().

xsltParseTemplateContent()

void 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 4878 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) {
    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);
                xmlAddPrevSibling(cur, 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().

xsltPreprocessStylesheet()

static void xsltPreprocessStylesheet ( xsltStylesheetPtr  style, xmlNodePtr  cur  )

static

Definition at line 3469 of file xslt.c.

{
    xmlNodePtr deleteNode, styleelem;
    int internalize = 0;
 
    if ((style == NULL) || (cur == NULL))
        return;
 
    if ((cur->doc != NULL) && (style->dict != NULL) &&
        (cur->doc->dict == style->dict))
    internalize = 1;
    else
        style->internalized = 0;
 
    if ((cur != NULL) && (IS_XSLT_ELEM(cur)) &&
        (IS_XSLT_NAME(cur, "stylesheet"))) {
    styleelem = cur;
    } else {
        styleelem = NULL;
    }
 
    /*
     * This content comes from the stylesheet
     * For stylesheets, the set of whitespace-preserving
     * element names consists of just xsl:text.
     */
    deleteNode = NULL;
    while (cur != NULL) {
    if (deleteNode != NULL) {
#ifdef WITH_XSLT_DEBUG_BLANKS
        xsltGenericDebug(xsltGenericDebugContext,
         "xsltPreprocessStylesheet: removing ignorable blank node\n");
#endif
        xmlUnlinkNode(deleteNode);
        xmlFreeNode(deleteNode);
        deleteNode = NULL;
    }
    if (cur->type == XML_ELEMENT_NODE) {
        int exclPrefixes;
        /*
         * Internalize attributes values.
         */
        if ((internalize) && (cur->properties != NULL)) {
            xmlAttrPtr attr = cur->properties;
        xmlNodePtr txt;
 
        while (attr != NULL) {
            txt = attr->children;
            if ((txt != NULL) && (txt->type == XML_TEXT_NODE) &&
                (txt->content != NULL) &&
            (!xmlDictOwns(style->dict, txt->content)))
            {
            xmlChar *tmp;
 
            /*
             * internalize the text string, goal is to speed
             * up operations and minimize used space by compiled
             * stylesheets.
             */
            tmp = (xmlChar *) xmlDictLookup(style->dict,
                                            txt->content, -1);
            if (tmp != txt->content) {
                xmlNodeSetContent(txt, NULL);
                txt->content = tmp;
            }
            }
            attr = attr->next;
        }
        }
        if (IS_XSLT_ELEM(cur)) {
        exclPrefixes = 0;
        if (IS_XSLT_NAME(cur, "text")) {
            for (;exclPrefixes > 0;exclPrefixes--)
            exclPrefixPop(style);
            goto skip_children;
        }
        } else {
        exclPrefixes = xsltParseStylesheetExcludePrefix(style, cur, 0);
        }
 
        if ((cur->nsDef != NULL) && (style->exclPrefixNr > 0)) {
        xmlNsPtr ns = cur->nsDef, prev = NULL, next;
        xmlNodePtr root = NULL;
        int i, moved;
 
        root = xmlDocGetRootElement(cur->doc);
        if ((root != NULL) && (root != cur)) {
            while (ns != NULL) {
            moved = 0;
            next = ns->next;
            for (i = 0;i < style->exclPrefixNr;i++) {
                if ((ns->prefix != NULL) &&
                    (xmlStrEqual(ns->href,
                         style->exclPrefixTab[i]))) {
                /*
                 * Move the namespace definition on the root
                 * element to avoid duplicating it without
                 * loosing it.
                 */
                if (prev == NULL) {
                    cur->nsDef = ns->next;
                } else {
                    prev->next = ns->next;
                }
                ns->next = root->nsDef;
                root->nsDef = ns;
                moved = 1;
                break;
                }
            }
            if (moved == 0)
                prev = ns;
            ns = next;
            }
        }
        }
        /*
         * If we have prefixes locally, recurse and pop them up when
         * going back
         */
        if (exclPrefixes > 0) {
        xsltPreprocessStylesheet(style, cur->children);
        for (;exclPrefixes > 0;exclPrefixes--)
            exclPrefixPop(style);
        goto skip_children;
        }
    } else if (cur->type == XML_TEXT_NODE) {
        if (IS_BLANK_NODE(cur)) {
        if (xmlNodeGetSpacePreserve(cur->parent) != 1) {
            deleteNode = cur;
        }
        } else if ((cur->content != NULL) && (internalize) &&
                   (!xmlDictOwns(style->dict, cur->content))) {
        xmlChar *tmp;
 
        /*
         * internalize the text string, goal is to speed
         * up operations and minimize used space by compiled
         * stylesheets.
         */
        tmp = (xmlChar *) xmlDictLookup(style->dict, cur->content, -1);
        xmlNodeSetContent(cur, NULL);
        cur->content = tmp;
        }
    } else if ((cur->type != XML_ELEMENT_NODE) &&
           (cur->type != XML_CDATA_SECTION_NODE)) {
        deleteNode = cur;
        goto skip_children;
    }
 
    /*
     * Skip to next node. In case of a namespaced element children of
     * the stylesheet and not in the XSLT namespace and not an extension
     * element, ignore its content.
     */
    if ((cur->type == XML_ELEMENT_NODE) && (cur->ns != NULL) &&
        (styleelem != NULL) && (cur->parent == styleelem) &&
        (!xmlStrEqual(cur->ns->href, XSLT_NAMESPACE)) &&
        (!xsltCheckExtURI(style, cur->ns->href))) {
        goto skip_children;
    } else if (cur->children != NULL) {
        cur = cur->children;
        continue;
    }
 
skip_children:
    if (cur->next != NULL) {
        cur = cur->next;
        continue;
    }
    do {
 
        cur = cur->parent;
        if (cur == NULL)
        break;
        if (cur == (xmlNodePtr) style->doc) {
        cur = NULL;
        break;
        }
        if (cur->next != NULL) {
        cur = cur->next;
        break;
        }
    } while (cur != NULL);
    }
    if (deleteNode != NULL) {
#ifdef WITH_XSLT_DEBUG_PARSING
    xsltGenericDebug(xsltGenericDebugContext,
     "xsltPreprocessStylesheet: removing ignorable blank node\n");
#endif
    xmlUnlinkNode(deleteNode);
    xmlFreeNode(deleteNode);
    }
}

Referenced by xsltParseStylesheetProcess(), and xsltPreprocessStylesheet().

xsltUninit()

void xsltUninit

(

void

)

xsltUninit:

Uninitializes the processor.

Definition at line 217 of file xslt.c.

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

Referenced by xsltCleanupGlobals().

Variable Documentation

initialized

int initialized = 0

static

Definition at line 193 of file xslt.c.

Referenced by xsltInit(), and xsltUninit().

xsltEngineVersion

const char* xsltEngineVersion = LIBXSLT_VERSION_STRING LIBXSLT_VERSION_EXTRA

Definition at line 23 of file xslt.c.

xsltLibxmlVersion

const int xsltLibxmlVersion = LIBXML_VERSION

Definition at line 25 of file xslt.c.

xsltLibxsltVersion

const int xsltLibxsltVersion = LIBXSLT_VERSION

Definition at line 24 of file xslt.c.