pattern.h File Reference

#include "xsltInternals.h"
#include "xsltexports.h"

Include dependency graph for pattern.h:

Go to the source code of this file.

Typedefs
typedef struct _xsltCompMatch	xsltCompMatch
typedef xsltCompMatch *	xsltCompMatchPtr

Functions
XSLTPUBFUN xsltCompMatchPtr XSLTCALL	xsltCompilePattern (const xmlChar *pattern, xmlDocPtr doc, xmlNodePtr node, xsltStylesheetPtr style, xsltTransformContextPtr runtime)
XSLTPUBFUN void XSLTCALL	xsltFreeCompMatchList (xsltCompMatchPtr comp)
XSLTPUBFUN int XSLTCALL	xsltTestCompMatchList (xsltTransformContextPtr ctxt, xmlNodePtr node, xsltCompMatchPtr comp)
XSLTPUBFUN void XSLTCALL	xsltCompMatchClearCache (xsltTransformContextPtr ctxt, xsltCompMatchPtr comp)
XSLTPUBFUN void XSLTCALL	xsltNormalizeCompSteps (void *payload, void *data, const xmlChar *name)
XSLTPUBFUN int XSLTCALL	xsltAddTemplate (xsltStylesheetPtr style, xsltTemplatePtr cur, const xmlChar *mode, const xmlChar *modeURI)
XSLTPUBFUN xsltTemplatePtr XSLTCALL	xsltGetTemplate (xsltTransformContextPtr ctxt, xmlNodePtr node, xsltStylesheetPtr style)
XSLTPUBFUN void XSLTCALL	xsltFreeTemplateHashes (xsltStylesheetPtr style)
XSLTPUBFUN void XSLTCALL	xsltCleanupTemplates (xsltStylesheetPtr style)

Typedef Documentation

xsltCompMatch

typedef struct _xsltCompMatch xsltCompMatch

xsltCompMatch:

Data structure used for the implementation of patterns. It is kept private (in pattern.c).

Definition at line 28 of file pattern.h.

xsltCompMatchPtr

typedef xsltCompMatch* xsltCompMatchPtr

Definition at line 29 of file pattern.h.

Function Documentation

xsltAddTemplate()

XSLTPUBFUN int XSLTCALL xsltAddTemplate	(	xsltStylesheetPtr	style,
		xsltTemplatePtr	cur,
		const xmlChar *	mode,
		const xmlChar *	modeURI
	)

xsltAddTemplate: @style: an XSLT stylesheet @cur: an XSLT template @mode: the mode name or NULL @modeURI: the mode URI or NULL

Register the XSLT pattern associated to @cur

Returns -1 in case of error, 0 otherwise

Definition at line 2016 of file pattern.c.

                                                         {
    xsltCompMatchPtr pat, list, next;
    /*
     * 'top' will point to style->xxxMatch ptr - declaring as 'void'
     *  avoids gcc 'type-punned pointer' warning.
     */
    xsltCompMatchPtr *top = NULL;
    const xmlChar *name = NULL;
    float priority;              /* the priority */
 
    if ((style == NULL) || (cur == NULL))
    return(-1);
 
    if (cur->next != NULL)
        cur->position = cur->next->position + 1;
 
    /* Register named template */
    if (cur->name != NULL) {
        if (style->namedTemplates == NULL) {
            style->namedTemplates = xmlHashCreate(10);
            if (style->namedTemplates == NULL)
                return(-1);
        }
        else {
            void *dup = xmlHashLookup2(style->namedTemplates, cur->name,
                                       cur->nameURI);
            if (dup != NULL) {
                xsltTransformError(NULL, style, cur->elem,
                                   "xsl:template: error duplicate name '%s'\n",
                                   cur->name);
                style->errors++;
                return(-1);
            }
        }
 
        xmlHashAddEntry2(style->namedTemplates, cur->name, cur->nameURI, cur);
    }
 
    if (cur->match == NULL) {
            if (cur->name == NULL) {
                xsltTransformError(NULL, style, cur->elem,
                    "xsl:template: need to specify match or name attribute\n");
                style->errors++;
                return(-1);
            }
    return(0);
    }
 
    priority = cur->priority;
    pat = xsltCompilePatternInternal(cur->match, style->doc, cur->elem,
            style, NULL, 1);
    if (pat == NULL)
    return(-1);
    while (pat) {
    next = pat->next;
    pat->next = NULL;
    name = NULL;
 
    pat->template = cur;
    if (mode != NULL)
        pat->mode = xmlDictLookup(style->dict, mode, -1);
    if (modeURI != NULL)
        pat->modeURI = xmlDictLookup(style->dict, modeURI, -1);
    if (priority != XSLT_PAT_NO_PRIORITY)
        pat->priority = priority;
 
    /*
     * insert it in the hash table list corresponding to its lookup name
     */
    switch (pat->steps[0].op) {
        case XSLT_OP_ATTR:
        if (pat->steps[0].value != NULL)
        name = pat->steps[0].value;
        else
        top = &(style->attrMatch);
        break;
        case XSLT_OP_PARENT:
        case XSLT_OP_ANCESTOR:
        top = &(style->elemMatch);
        break;
        case XSLT_OP_ROOT:
        top = &(style->rootMatch);
        break;
        case XSLT_OP_KEY:
        top = &(style->keyMatch);
        break;
        case XSLT_OP_ID:
        /* TODO optimize ID !!! */
        case XSLT_OP_NS:
        case XSLT_OP_ALL:
        top = &(style->elemMatch);
        break;
        case XSLT_OP_END:
    case XSLT_OP_PREDICATE:
        xsltTransformError(NULL, style, NULL,
                 "xsltAddTemplate: invalid compiled pattern\n");
        xsltFreeCompMatch(pat);
        return(-1);
        /*
         * TODO: some flags at the top level about type based patterns
         *       would be faster than inclusion in the hash table.
         */
    case XSLT_OP_PI:
        if (pat->steps[0].value != NULL)
        name = pat->steps[0].value;
        else
        top = &(style->piMatch);
        break;
    case XSLT_OP_COMMENT:
        top = &(style->commentMatch);
        break;
    case XSLT_OP_TEXT:
        top = &(style->textMatch);
        break;
        case XSLT_OP_ELEM:
    case XSLT_OP_NODE:
        if (pat->steps[0].value != NULL)
        name = pat->steps[0].value;
        else
        top = &(style->elemMatch);
        break;
    }
    if (name != NULL) {
        if (style->templatesHash == NULL) {
        style->templatesHash = xmlHashCreate(1024);
        if (style->templatesHash == NULL) {
            xsltFreeCompMatch(pat);
            return(-1);
        }
        xmlHashAddEntry3(style->templatesHash, name, mode, modeURI, pat);
        } else {
        list = (xsltCompMatchPtr) xmlHashLookup3(style->templatesHash,
                             name, mode, modeURI);
        if (list == NULL) {
            xmlHashAddEntry3(style->templatesHash, name,
                     mode, modeURI, pat);
        } else {
            /*
             * Note '<=' since one must choose among the matching
             * template rules that are left, the one that occurs
             * last in the stylesheet
             */
            if (list->priority <= pat->priority) {
            pat->next = list;
            xmlHashUpdateEntry3(style->templatesHash, name,
                        mode, modeURI, pat, NULL);
            } else {
            while (list->next != NULL) {
                if (list->next->priority <= pat->priority)
                break;
                list = list->next;
            }
            pat->next = list->next;
            list->next = pat;
            }
        }
        }
    } else if (top != NULL) {
        list = *top;
        if (list == NULL) {
        *top = pat;
        pat->next = NULL;
        } else if (list->priority <= pat->priority) {
        pat->next = list;
        *top = pat;
        } else {
        while (list->next != NULL) {
            if (list->next->priority <= pat->priority)
            break;
            list = list->next;
        }
        pat->next = list->next;
        list->next = pat;
        }
    } else {
        xsltTransformError(NULL, style, NULL,
                 "xsltAddTemplate: invalid compiled pattern\n");
        xsltFreeCompMatch(pat);
        return(-1);
    }
#ifdef WITH_XSLT_DEBUG_PATTERN
    if (mode)
        xsltGenericDebug(xsltGenericDebugContext,
             "added pattern : '%s' mode '%s' priority %f\n",
                 pat->pattern, pat->mode, pat->priority);
    else
        xsltGenericDebug(xsltGenericDebugContext,
             "added pattern : '%s' priority %f\n",
                 pat->pattern, pat->priority);
#endif
 
    pat = next;
    }
    return(0);
}

Referenced by xsltParseStylesheetProcess(), and xsltParseStylesheetTemplate().

xsltCleanupTemplates()

XSLTPUBFUN void XSLTCALL xsltCleanupTemplates

(

xsltStylesheetPtr style

ATTRIBUTE_UNUSED

)

xsltCleanupTemplates: @style: an XSLT stylesheet

Cleanup the state of the templates used by the stylesheet and the ones it imports.

Definition at line 2517 of file pattern.c.

                                                               {
}

Referenced by xsltApplyStylesheetInternal().

xsltCompilePattern()

XSLTPUBFUN xsltCompMatchPtr XSLTCALL xsltCompilePattern	(	const xmlChar *	pattern,
		xmlDocPtr	doc,
		xmlNodePtr	node,
		xsltStylesheetPtr	style,
		xsltTransformContextPtr	runtime
	)

xsltCompilePattern: @pattern: an XSLT pattern @doc: the containing document @node: the containing element @style: the stylesheet @runtime: the transformation context, if done at run-time

Compile the XSLT pattern and generates a list of precompiled form suitable for fast matching.

[1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern

Returns the generated pattern list or NULL in case of failure

Definition at line 1992 of file pattern.c.

                                            {
    return (xsltCompilePatternInternal(pattern, doc, node, style, runtime, 0));
}

Referenced by xsltNumberComp().

xsltCompMatchClearCache()

XSLTPUBFUN void XSLTCALL xsltCompMatchClearCache	(	xsltTransformContextPtr	ctxt,
		xsltCompMatchPtr	comp
	)

xsltCompMatchClearCache: @ctxt: a XSLT process context @comp: the precompiled pattern list

Clear pattern match cache.

Definition at line 1144 of file pattern.c.

                                                                             {
    xsltStepOpPtr sel;
    xmlXPathObjectPtr list;
 
    if ((ctxt == NULL) || (comp == NULL))
        return;
 
    sel = &comp->steps[0];
    list = (xmlXPathObjectPtr) XSLT_RUNTIME_EXTRA_LST(ctxt, sel->lenExtra);
 
    if (list != NULL) {
        xmlXPathFreeObject(list);
 
        XSLT_RUNTIME_EXTRA_LST(ctxt, sel->lenExtra) = NULL;
        XSLT_RUNTIME_EXTRA(ctxt, sel->previousExtra, ptr) = NULL;
        XSLT_RUNTIME_EXTRA(ctxt, sel->indexExtra, ival) = 0;
        XSLT_RUNTIME_EXTRA_FREE(ctxt, sel->lenExtra) = NULL;
    }
}

Referenced by xsltNumberFormat().

xsltFreeCompMatchList()

XSLTPUBFUN void XSLTCALL xsltFreeCompMatchList

(

xsltCompMatchPtr

comp

)

xsltFreeCompMatchList: @comp: an XSLT comp list

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

Definition at line 192 of file pattern.c.

                                             {
    xsltCompMatchPtr cur;
 
    while (comp != NULL) {
    cur = comp;
    comp = comp->next;
    xsltFreeCompMatch(cur);
    }
}

Referenced by xsltCompilePatternInternal(), xsltFreeCompMatchListEntry(), xsltFreeStylePreComp(), and xsltFreeTemplateHashes().

xsltFreeTemplateHashes()

XSLTPUBFUN void XSLTCALL xsltFreeTemplateHashes

(

xsltStylesheetPtr

style

)

xsltFreeTemplateHashes: @style: an XSLT stylesheet

Free up the memory used by xsltAddTemplate/xsltGetTemplate mechanism

Definition at line 2527 of file pattern.c.

                                                {
    if (style->templatesHash != NULL)
    xmlHashFree(style->templatesHash, xsltFreeCompMatchListEntry);
    if (style->rootMatch != NULL)
        xsltFreeCompMatchList(style->rootMatch);
    if (style->keyMatch != NULL)
        xsltFreeCompMatchList(style->keyMatch);
    if (style->elemMatch != NULL)
        xsltFreeCompMatchList(style->elemMatch);
    if (style->attrMatch != NULL)
        xsltFreeCompMatchList(style->attrMatch);
    if (style->parentMatch != NULL)
        xsltFreeCompMatchList(style->parentMatch);
    if (style->textMatch != NULL)
        xsltFreeCompMatchList(style->textMatch);
    if (style->piMatch != NULL)
        xsltFreeCompMatchList(style->piMatch);
    if (style->commentMatch != NULL)
        xsltFreeCompMatchList(style->commentMatch);
    if (style->namedTemplates != NULL)
        xmlHashFree(style->namedTemplates, NULL);
}

Referenced by xsltFreeStylesheet().

xsltGetTemplate()

XSLTPUBFUN xsltTemplatePtr XSLTCALL xsltGetTemplate	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xsltStylesheetPtr	style
	)

xsltGetTemplate: @ctxt: a XSLT process context @node: the node being processed @style: the current style

Finds the template applying to this node, if @style is non-NULL it means one needs to look for the next imported template in scope.

Returns the xsltTemplatePtr or NULL if not found

Definition at line 2259 of file pattern.c.

{
    xsltStylesheetPtr curstyle;
    xsltTemplatePtr ret = NULL;
    const xmlChar *name = NULL;
    xsltCompMatchPtr list = NULL;
    float priority;
    int keyed = 0;
 
    if ((ctxt == NULL) || (node == NULL))
    return(NULL);
 
    if (style == NULL) {
    curstyle = ctxt->style;
    } else {
    curstyle = xsltNextImport(style);
    }
 
    while ((curstyle != NULL) && (curstyle != style)) {
    priority = XSLT_PAT_NO_PRIORITY;
    /* TODO : handle IDs/keys here ! */
    if (curstyle->templatesHash != NULL) {
        /*
         * Use the top name as selector
         */
        switch (node->type) {
        case XML_ELEMENT_NODE:
            if (node->name[0] == ' ')
            break;
                    /* Intentional fall-through */
        case XML_ATTRIBUTE_NODE:
        case XML_PI_NODE:
            name = node->name;
            break;
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE:
        case XML_TEXT_NODE:
        case XML_CDATA_SECTION_NODE:
        case XML_COMMENT_NODE:
        case XML_ENTITY_REF_NODE:
        case XML_ENTITY_NODE:
        case XML_DOCUMENT_TYPE_NODE:
        case XML_DOCUMENT_FRAG_NODE:
        case XML_NOTATION_NODE:
        case XML_DTD_NODE:
        case XML_ELEMENT_DECL:
        case XML_ATTRIBUTE_DECL:
        case XML_ENTITY_DECL:
        case XML_NAMESPACE_DECL:
        case XML_XINCLUDE_START:
        case XML_XINCLUDE_END:
            break;
        default:
            return(NULL);
 
        }
    }
    if (name != NULL) {
        /*
         * find the list of applicable expressions based on the name
         */
        list = (xsltCompMatchPtr) xmlHashLookup3(curstyle->templatesHash,
                         name, ctxt->mode, ctxt->modeURI);
    } else
        list = NULL;
    while (list != NULL) {
        if (xsltTestCompMatch(ctxt, list, node,
                      ctxt->mode, ctxt->modeURI) == 1) {
        ret = list->template;
        priority = list->priority;
        break;
        }
        list = list->next;
    }
    list = NULL;
 
    /*
     * find alternate generic matches
     */
    switch (node->type) {
        case XML_ELEMENT_NODE:
        if (node->name[0] == ' ')
            list = curstyle->rootMatch;
        else
            list = curstyle->elemMatch;
        if (node->psvi != NULL) keyed = 1;
        break;
        case XML_ATTRIBUTE_NODE: {
            xmlAttrPtr attr;
 
        list = curstyle->attrMatch;
        attr = (xmlAttrPtr) node;
        if (attr->psvi != NULL) keyed = 1;
        break;
        }
        case XML_PI_NODE:
        list = curstyle->piMatch;
        if (node->psvi != NULL) keyed = 1;
        break;
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE: {
            xmlDocPtr doc;
 
        list = curstyle->rootMatch;
        doc = (xmlDocPtr) node;
        if (doc->psvi != NULL) keyed = 1;
        break;
        }
        case XML_TEXT_NODE:
        case XML_CDATA_SECTION_NODE:
        list = curstyle->textMatch;
        if (node->psvi != NULL) keyed = 1;
        break;
        case XML_COMMENT_NODE:
        list = curstyle->commentMatch;
        if (node->psvi != NULL) keyed = 1;
        break;
        case XML_ENTITY_REF_NODE:
        case XML_ENTITY_NODE:
        case XML_DOCUMENT_TYPE_NODE:
        case XML_DOCUMENT_FRAG_NODE:
        case XML_NOTATION_NODE:
        case XML_DTD_NODE:
        case XML_ELEMENT_DECL:
        case XML_ATTRIBUTE_DECL:
        case XML_ENTITY_DECL:
        case XML_NAMESPACE_DECL:
        case XML_XINCLUDE_START:
        case XML_XINCLUDE_END:
        break;
        default:
        break;
    }
    while ((list != NULL) &&
           ((ret == NULL) ||
                (list->priority > priority) ||
                ((list->priority == priority) &&
                 (list->template->position > ret->position)))) {
        if (xsltTestCompMatch(ctxt, list, node,
                      ctxt->mode, ctxt->modeURI) == 1) {
        ret = list->template;
        priority = list->priority;
        break;
        }
        list = list->next;
    }
    /*
     * Some of the tests for elements can also apply to documents
     */
    if ((node->type == XML_DOCUMENT_NODE) ||
        (node->type == XML_HTML_DOCUMENT_NODE) ||
        (node->type == XML_TEXT_NODE)) {
        list = curstyle->elemMatch;
        while ((list != NULL) &&
                   ((ret == NULL) ||
                    (list->priority > priority) ||
                    ((list->priority == priority) &&
                     (list->template->position > ret->position)))) {
        if (xsltTestCompMatch(ctxt, list, node,
                      ctxt->mode, ctxt->modeURI) == 1) {
            ret = list->template;
            priority = list->priority;
            break;
        }
        list = list->next;
        }
    } else if ((node->type == XML_PI_NODE) ||
           (node->type == XML_COMMENT_NODE)) {
        list = curstyle->elemMatch;
        while ((list != NULL) &&
                   ((ret == NULL) ||
                    (list->priority > priority) ||
                    ((list->priority == priority) &&
                     (list->template->position > ret->position)))) {
        if (xsltTestCompMatch(ctxt, list, node,
                      ctxt->mode, ctxt->modeURI) == 1) {
            ret = list->template;
            priority = list->priority;
            break;
        }
        list = list->next;
        }
    }
 
keyed_match:
    if (keyed) {
        list = curstyle->keyMatch;
        while ((list != NULL) &&
                   ((ret == NULL) ||
                    (list->priority > priority) ||
                    ((list->priority == priority) &&
                     (list->template->position > ret->position)))) {
        if (xsltTestCompMatch(ctxt, list, node,
                      ctxt->mode, ctxt->modeURI) == 1) {
            ret = list->template;
            priority = list->priority;
            break;
        }
        list = list->next;
        }
    }
    else if (ctxt->hasTemplKeyPatterns &&
        ((ctxt->document == NULL) ||
         (ctxt->document->nbKeysComputed < ctxt->nbKeys)))
    {
        /*
        * Compute all remaining keys for this document.
        *
        * REVISIT TODO: I think this could be further optimized.
        */
        if (xsltComputeAllKeys(ctxt, node) == -1)
        goto error;
 
        switch (node->type) {
        case XML_ELEMENT_NODE:
            if (node->psvi != NULL) keyed = 1;
            break;
        case XML_ATTRIBUTE_NODE:
            if (((xmlAttrPtr) node)->psvi != NULL) keyed = 1;
            break;
        case XML_TEXT_NODE:
        case XML_CDATA_SECTION_NODE:
        case XML_COMMENT_NODE:
        case XML_PI_NODE:
            if (node->psvi != NULL) keyed = 1;
            break;
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE:
            if (((xmlDocPtr) node)->psvi != NULL) keyed = 1;
            break;
        default:
            break;
        }
        if (keyed)
        goto keyed_match;
    }
    if (ret != NULL)
        return(ret);
 
    /*
     * Cycle on next curstylesheet import.
     */
    curstyle = xsltNextImport(curstyle);
    }
 
error:
    return(NULL);
}

Referenced by xsltApplyImports(), xsltDefaultProcessOneNode(), and xsltProcessOneNode().

xsltNormalizeCompSteps()

XSLTPUBFUN void XSLTCALL xsltNormalizeCompSteps	(	void *	payload,
		void *	data,
		const xmlChar *	name
	)

xsltTestCompMatchList()

XSLTPUBFUN int XSLTCALL xsltTestCompMatchList	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xsltCompMatchPtr	comp
	)

xsltTestCompMatchList: @ctxt: a XSLT process context @node: a node @comp: the precompiled pattern list

Test whether the node matches one of the patterns in the list

Returns 1 if it matches, 0 if it doesn't and -1 in case of failure

Definition at line 1121 of file pattern.c.

                                         {
    int ret;
 
    if ((ctxt == NULL) || (node == NULL))
    return(-1);
    while (comp != NULL) {
    ret = xsltTestCompMatch(ctxt, comp, node, NULL, NULL);
    if (ret == 1)
        return(1);
    comp = comp->next;
    }
    return(0);
}

Referenced by xsltNumberFormatGetAnyLevel(), xsltNumberFormatGetMultipleLevel(), and xsltTestCompMatchCount().