attributes.c File Reference

#include "libxslt.h"
#include <string.h>
#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/hash.h>
#include <libxml/xmlerror.h>
#include <libxml/uri.h>
#include <libxml/parserInternals.h>
#include "xslt.h"
#include "xsltInternals.h"
#include "xsltutils.h"
#include "attributes.h"
#include "namespaces.h"
#include "templates.h"
#include "imports.h"
#include "transform.h"
#include "preproc.h"

Include dependency graph for attributes.c:

Go to the source code of this file.

Classes
struct	_xsltAttrElem
struct	_xsltUseAttrSet
struct	_xsltAttrSet
struct	_xsltAttrSetContext

Macros
#define	IN_LIBXSLT
#define	WITH_XSLT_DEBUG_ATTRIBUTES
#define	IS_BLANK(c)
#define	IS_BLANK_NODE(n)    (((n)->type == XML_TEXT_NODE) && (xsltIsBlank((n)->content)))
#define	ATTRSET_UNRESOLVED   0
#define	ATTRSET_RESOLVING   1
#define	ATTRSET_RESOLVED   2

Typedefs
typedef struct _xsltAttrElem	xsltAttrElem
typedef xsltAttrElem *	xsltAttrElemPtr
typedef struct _xsltUseAttrSet	xsltUseAttrSet
typedef xsltUseAttrSet *	xsltUseAttrSetPtr
typedef struct _xsltAttrSet	xsltAttrSet
typedef xsltAttrSet *	xsltAttrSetPtr
typedef struct _xsltAttrSetContext	xsltAttrSetContext
typedef xsltAttrSetContext *	xsltAttrSetContextPtr

Functions
static xsltAttrElemPtr	xsltNewAttrElem (xmlNodePtr attr)
static void	xsltFreeAttrElem (xsltAttrElemPtr attr)
static void	xsltFreeAttrElemList (xsltAttrElemPtr list)
static xsltAttrElemPtr	xsltAddAttrElemList (xsltAttrElemPtr list, xmlNodePtr attr)
static xsltUseAttrSetPtr	xsltNewUseAttrSet (const xmlChar *ncname, const xmlChar *ns)
static void	xsltFreeUseAttrSet (xsltUseAttrSetPtr use)
static void	xsltFreeUseAttrSetList (xsltUseAttrSetPtr list)
static xsltUseAttrSetPtr	xsltAddUseAttrSetList (xsltUseAttrSetPtr list, const xmlChar *ncname, const xmlChar *ns)
static xsltAttrSetPtr	xsltNewAttrSet (void)
static void	xsltFreeAttrSet (xsltAttrSetPtr set)
static void	xsltMergeAttrSets (xsltAttrSetPtr set, xsltAttrSetPtr other)
void	xsltParseStylesheetAttributeSet (xsltStylesheetPtr style, xmlNodePtr cur)
static void	xsltResolveUseAttrSets (xsltAttrSetPtr set, xsltStylesheetPtr topStyle, int depth)
: the local name of the attirbute set
xsltResolveSASCallback: @set: the attribute set @asctx: the context for attribute set resolution @ns: the namespace of the attribute set resolve the references in an attribute set.
static void	xsltResolveAttrSet (xsltAttrSetPtr set, xsltStylesheetPtr topStyle, xsltStylesheetPtr style, const xmlChar *name, const xmlChar *ns, int depth)
static void	xsltResolveSASCallback (void *payload, void *data, const xmlChar *name, const xmlChar *ns, ATTRIBUTE_UNUSED const xmlChar *ignored)
void	xsltResolveStylesheetAttributeSet (xsltStylesheetPtr style)
void	xsltAttribute (xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst, xsltElemPreCompPtr castedComp)
void	xsltApplyAttributeSet (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, const xmlChar *attrSets)
static void	xsltFreeAttributeSetsEntry (void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
void	xsltFreeAttributeSetsHashes (xsltStylesheetPtr style)

Macro Definition Documentation

ATTRSET_RESOLVED

#define ATTRSET_RESOLVED   2

Definition at line 53 of file attributes.c.

ATTRSET_RESOLVING

#define ATTRSET_RESOLVING   1

Definition at line 52 of file attributes.c.

ATTRSET_UNRESOLVED

#define ATTRSET_UNRESOLVED   0

Definition at line 51 of file attributes.c.

IN_LIBXSLT

#define IN_LIBXSLT

Definition at line 12 of file attributes.c.

IS_BLANK

#define IS_BLANK

(

c

)

Value:

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

Definition at line 45 of file attributes.c.

IS_BLANK_NODE

#define IS_BLANK_NODE

(

n

)

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

Definition at line 48 of file attributes.c.

WITH_XSLT_DEBUG_ATTRIBUTES

#define WITH_XSLT_DEBUG_ATTRIBUTES

Definition at line 33 of file attributes.c.

Typedef Documentation

xsltAttrElem

typedef struct _xsltAttrElem xsltAttrElem

Definition at line 62 of file attributes.c.

xsltAttrElemPtr

typedef xsltAttrElem* xsltAttrElemPtr

Definition at line 63 of file attributes.c.

xsltAttrSet

typedef struct _xsltAttrSet xsltAttrSet

Definition at line 77 of file attributes.c.

xsltAttrSetContext

typedef struct _xsltAttrSetContext xsltAttrSetContext

Definition at line 85 of file attributes.c.

xsltAttrSetContextPtr

typedef xsltAttrSetContext* xsltAttrSetContextPtr

Definition at line 86 of file attributes.c.

xsltAttrSetPtr

typedef xsltAttrSet* xsltAttrSetPtr

Definition at line 78 of file attributes.c.

xsltUseAttrSet

typedef struct _xsltUseAttrSet xsltUseAttrSet

Definition at line 69 of file attributes.c.

xsltUseAttrSetPtr

typedef xsltUseAttrSet* xsltUseAttrSetPtr

Definition at line 70 of file attributes.c.

Function Documentation

xsltAddAttrElemList()

static xsltAttrElemPtr xsltAddAttrElemList ( xsltAttrElemPtr  list, xmlNodePtr  attr  )

static

xsltAddAttrElemList: @list: an XSLT AttrElem list @attr: the new xsl:attribute node

Add the new attribute to the list.

Returns the new list pointer

Definition at line 165 of file attributes.c.

                                                           {
    xsltAttrElemPtr next, cur;
 
    if (attr == NULL)
    return(list);
    if (list == NULL)
    return(xsltNewAttrElem(attr));
    cur = list;
    while (cur != NULL) {
    next = cur->next;
    if (next == NULL) {
        cur->next = xsltNewAttrElem(attr);
        return(list);
    }
    cur = next;
    }
    return(list);
}

Referenced by xsltParseStylesheetAttributeSet().

xsltAddUseAttrSetList()

static xsltUseAttrSetPtr xsltAddUseAttrSetList ( xsltUseAttrSetPtr  list, const xmlChar *  ncname, const xmlChar *  ns  )

static

xsltAddUseAttrSetList: @list: a xsltUseAttrSet list @ncname: local name @ns: namespace URI

Add the use-attribute-set name to the list.

Returns the new list pointer.

Definition at line 248 of file attributes.c.

                                         {
    xsltUseAttrSetPtr next, cur;
 
    if (ncname == NULL)
        return(list);
    if (list == NULL)
    return(xsltNewUseAttrSet(ncname, ns));
    cur = list;
    while (cur != NULL) {
        if ((cur->ncname == ncname) && (cur->ns == ns))
            return(list);
    next = cur->next;
    if (next == NULL) {
        cur->next = xsltNewUseAttrSet(ncname, ns);
        return(list);
    }
    cur = next;
    }
    return(list);
}

Referenced by xsltParseStylesheetAttributeSet().

xsltApplyAttributeSet()

void xsltApplyAttributeSet	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	node,
		xmlNodePtr	inst,
		const xmlChar *	attrSets
	)

xsltApplyAttributeSet: @ctxt: the XSLT stylesheet @node: the node in the source tree. @inst: the attribute node "xsl:use-attribute-sets" @attrSets: the list of QNames of the attribute-sets to be applied

Apply the xsl:use-attribute-sets. If @attrSets is NULL, then @inst will be used to exctract this value. If both, @attrSets and @inst, are NULL, then this will do nothing.

Definition at line 1118 of file attributes.c.

{
    const xmlChar *ncname = NULL;
    const xmlChar *prefix = NULL;
    const xmlChar *curstr, *endstr;
    xsltAttrSetPtr set;
    xsltStylesheetPtr style;
 
    if (attrSets == NULL) {
    if (inst == NULL)
        return;
    else {
        /*
        * Extract the value from @inst.
        */
        if (inst->type == XML_ATTRIBUTE_NODE) {
        if ( ((xmlAttrPtr) inst)->children != NULL)
            attrSets = ((xmlAttrPtr) inst)->children->content;
 
        }
        if (attrSets == NULL) {
        /*
        * TODO: Return an error?
        */
        return;
        }
    }
    }
    /*
    * Parse/apply the list of QNames.
    */
    curstr = attrSets;
    while (*curstr != 0) {
        while (IS_BLANK(*curstr))
            curstr++;
        if (*curstr == 0)
            break;
        endstr = curstr;
        while ((*endstr != 0) && (!IS_BLANK(*endstr)))
            endstr++;
        curstr = xmlDictLookup(ctxt->dict, curstr, endstr - curstr);
        if (curstr) {
            xmlNsPtr ns;
            const xmlChar *nsUri = NULL;
 
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
            xsltGenericDebug(xsltGenericDebugContext,
                             "apply attribute set %s\n", curstr);
#endif
 
            if (xmlValidateQName(curstr, 0)) {
                xsltTransformError(ctxt, NULL, inst,
                    "The name '%s' in use-attribute-sets is not a valid "
                    "QName.\n", curstr);
                return;
            }
 
            ncname = xsltSplitQName(ctxt->dict, curstr, &prefix);
            if (prefix != NULL) {
            ns = xmlSearchNs(inst->doc, inst, prefix);
                if (ns == NULL) {
                    xsltTransformError(ctxt, NULL, inst,
                        "use-attribute-set : No namespace found for QName "
                        "'%s:%s'\n", prefix, ncname);
                    return;
                }
                nsUri = ns->href;
            }
 
            style = ctxt->style;
 
#ifdef WITH_DEBUGGER
            if ((style != NULL) &&
        (style->attributeSets != NULL) &&
        (ctxt->debugStatus != XSLT_DEBUG_NONE))
        {
                set = xmlHashLookup2(style->attributeSets, ncname, nsUri);
                if ((set != NULL) && (set->attrs != NULL) &&
                    (set->attrs->attr != NULL))
                    xslHandleDebugger(set->attrs->attr->parent, node, NULL,
            ctxt);
            }
#endif
        /*
        * Lookup the referenced attribute-set. All attribute sets were
            * moved to the top stylesheet so there's no need to iterate
            * imported stylesheets
        */
            set = xmlHashLookup2(style->attributeSets, ncname, nsUri);
            if (set != NULL) {
                xsltAttrElemPtr cur = set->attrs;
                while (cur != NULL) {
                    if (cur->attr != NULL) {
                        xsltAttribute(ctxt, node, cur->attr,
                            cur->attr->psvi);
                    }
                    cur = cur->next;
                }
            }
        }
        curstr = endstr;
    }
}

Referenced by xsltAttrListTemplateProcess(), xsltCopy(), and xsltElement().

xsltAttribute()

void xsltAttribute	(	xsltTransformContextPtr	ctxt,
		xmlNodePtr	contextNode,
		xmlNodePtr	inst,
		xsltElemPreCompPtr	castedComp
	)

xsltAttribute: @ctxt: a XSLT process context @contextNode: the current node in the source tree @inst: the xsl:attribute element @castedComp: precomputed information

Process the xslt attribute node on the source node

Definition at line 748 of file attributes.c.

{
#ifdef XSLT_REFACTORED
    xsltStyleItemAttributePtr comp =
    (xsltStyleItemAttributePtr) castedComp;
#else
    xsltStylePreCompPtr comp = (xsltStylePreCompPtr) castedComp;
#endif
    xmlNodePtr targetElem;
    xmlChar *prop = NULL;
    const xmlChar *name = NULL, *prefix = NULL, *nsName = NULL;
    xmlChar *value = NULL;
    xmlNsPtr ns = NULL;
    xmlAttrPtr attr;
 
    if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL) ||
        (inst->type != XML_ELEMENT_NODE) )
        return;
 
    /*
    * A comp->has_name == 0 indicates that we need to skip this instruction,
    * since it was evaluated to be invalid already during compilation.
    */
    if (!comp->has_name)
        return;
    /*
    * BIG NOTE: This previously used xsltGetSpecialNamespace() and
    *  xsltGetNamespace(), but since both are not appropriate, we
    *  will process namespace lookup here to avoid adding yet another
    *  ns-lookup function to namespaces.c.
    */
    /*
    * SPEC XSLT 1.0: Error cases:
    * - Creating nodes other than text nodes during the instantiation of
    *   the content of the xsl:attribute element; implementations may
    *   either signal the error or ignore the offending nodes."
    */
 
    if (comp == NULL) {
        xsltTransformError(ctxt, NULL, inst,
        "Internal error in xsltAttribute(): "
        "The XSLT 'attribute' instruction was not compiled.\n");
        return;
    }
    /*
    * TODO: Shouldn't ctxt->insert == NULL be treated as an internal error?
    *   So report an internal error?
    */
    if (ctxt->insert == NULL)
        return;
    /*
    * SPEC XSLT 1.0:
    *  "Adding an attribute to a node that is not an element;
    *  implementations may either signal the error or ignore the attribute."
    *
    * TODO: I think we should signal such errors in the future, and maybe
    *  provide an option to ignore such errors.
    */
    targetElem = ctxt->insert;
    if (targetElem->type != XML_ELEMENT_NODE)
    return;
 
    /*
    * SPEC XSLT 1.0:
    * "Adding an attribute to an element after children have been added
    *  to it; implementations may either signal the error or ignore the
    *  attribute."
    *
    * TODO: We should decide whether not to report such errors or
    *  to ignore them; note that we *ignore* if the parent is not an
    *  element, but here we report an error.
    */
    if (targetElem->children != NULL) {
    /*
    * NOTE: Ah! This seems to be intended to support streamed
    *  result generation!.
    */
        xsltTransformError(ctxt, NULL, inst,
        "xsl:attribute: Cannot add attributes to an "
        "element if children have been already added "
        "to the element.\n");
        return;
    }
 
    /*
    * Process the name
    * ----------------
    */
 
#ifdef WITH_DEBUGGER
    if (ctxt->debugStatus != XSLT_DEBUG_NONE)
        xslHandleDebugger(inst, contextNode, NULL, ctxt);
#endif
 
    if (comp->name == NULL) {
    /* TODO: fix attr acquisition wrt to the XSLT namespace */
        prop = xsltEvalAttrValueTemplate(ctxt, inst,
        (const xmlChar *) "name", XSLT_NAMESPACE);
        if (prop == NULL) {
            xsltTransformError(ctxt, NULL, inst,
        "xsl:attribute: The attribute 'name' is missing.\n");
            goto error;
        }
    if (xmlValidateQName(prop, 0)) {
        xsltTransformError(ctxt, NULL, inst,
        "xsl:attribute: The effective name '%s' is not a "
        "valid QName.\n", prop);
        /* we fall through to catch any further errors, if possible */
    }
 
    /*
    * Reject a name of "xmlns".
    */
    if (xmlStrEqual(prop, BAD_CAST "xmlns")) {
            xsltTransformError(ctxt, NULL, inst,
                "xsl:attribute: The effective name 'xmlns' is not allowed.\n");
        xmlFree(prop);
        goto error;
    }
 
    name = xsltSplitQName(ctxt->dict, prop, &prefix);
    xmlFree(prop);
    } else {
    /*
    * The "name" value was static.
    */
#ifdef XSLT_REFACTORED
    prefix = comp->nsPrefix;
    name = comp->name;
#else
    name = xsltSplitQName(ctxt->dict, comp->name, &prefix);
#endif
    }
 
    /*
    * Process namespace semantics
    * ---------------------------
    *
    * Evaluate the namespace name.
    */
    if (comp->has_ns) {
    /*
    * The "namespace" attribute was existent.
    */
    if (comp->ns != NULL) {
        /*
        * No AVT; just plain text for the namespace name.
        */
        if (comp->ns[0] != 0)
        nsName = comp->ns;
    } else {
        xmlChar *tmpNsName;
        /*
        * Eval the AVT.
        */
        /* TODO: check attr acquisition wrt to the XSLT namespace */
        tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
        (const xmlChar *) "namespace", XSLT_NAMESPACE);
        /*
        * This fixes bug #302020: The AVT might also evaluate to the
        * empty string; this means that the empty string also indicates
        * "no namespace".
        * SPEC XSLT 1.0:
        *  "If the string is empty, then the expanded-name of the
        *  attribute has a null namespace URI."
        */
        if ((tmpNsName != NULL) && (tmpNsName[0] != 0))
        nsName = xmlDictLookup(ctxt->dict, BAD_CAST tmpNsName, -1);
        xmlFree(tmpNsName);
    }
 
        if (xmlStrEqual(nsName, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
            xsltTransformError(ctxt, NULL, inst,
                "xsl:attribute: Namespace http://www.w3.org/2000/xmlns/ "
                "forbidden.\n");
            goto error;
        }
        if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) {
            prefix = BAD_CAST "xml";
        } else if (xmlStrEqual(prefix, BAD_CAST "xml")) {
            prefix = NULL;
        }
    } else if (prefix != NULL) {
    /*
    * SPEC XSLT 1.0:
    *  "If the namespace attribute is not present, then the QName is
    *  expanded into an expanded-name using the namespace declarations
    *  in effect for the xsl:attribute element, *not* including any
    *  default namespace declaration."
    */
    ns = xmlSearchNs(inst->doc, inst, prefix);
    if (ns == NULL) {
        /*
        * Note that this is treated as an error now (checked with
        *  Saxon, Xalan-J and MSXML).
        */
        xsltTransformError(ctxt, NULL, inst,
        "xsl:attribute: The QName '%s:%s' has no "
        "namespace binding in scope in the stylesheet; "
        "this is an error, since the namespace was not "
        "specified by the instruction itself.\n", prefix, name);
    } else
        nsName = ns->href;
    }
 
    /*
    * Find/create a matching ns-decl in the result tree.
    */
    ns = NULL;
 
#if 0
    if (0) {
    /*
    * OPTIMIZE TODO: How do we know if we are adding to a
    *  fragment or to the result tree?
    *
    * If we are adding to a result tree fragment (i.e., not to the
    * actual result tree), we'll don't bother searching for the
    * ns-decl, but just store it in the dummy-doc of the result
    * tree fragment.
    */
    if (nsName != NULL) {
        /*
        * TODO: Get the doc of @targetElem.
        */
        ns = xsltTreeAcquireStoredNs(some doc, nsName, prefix);
    }
    }
#endif
 
    if (nsName != NULL) {
    /*
    * Something about ns-prefixes:
    * SPEC XSLT 1.0:
    *  "XSLT processors may make use of the prefix of the QName specified
    *  in the name attribute when selecting the prefix used for outputting
    *  the created attribute as XML; however, they are not required to do
    *  so and, if the prefix is xmlns, they must not do so"
    */
    /*
    * xsl:attribute can produce a scenario where the prefix is NULL,
    * so generate a prefix.
    */
    if ((prefix == NULL) || xmlStrEqual(prefix, BAD_CAST "xmlns")) {
        xmlChar *pref = xmlStrdup(BAD_CAST "ns_1");
 
        ns = xsltGetSpecialNamespace(ctxt, inst, nsName, pref, targetElem);
 
        xmlFree(pref);
    } else {
        ns = xsltGetSpecialNamespace(ctxt, inst, nsName, prefix,
        targetElem);
    }
    if (ns == NULL) {
        xsltTransformError(ctxt, NULL, inst,
        "Namespace fixup error: Failed to acquire an in-scope "
        "namespace binding for the generated attribute '{%s}%s'.\n",
        nsName, name);
        goto error;
    }
    }
    /*
    * Construction of the value
    * -------------------------
    */
    if (inst->children == NULL) {
    /*
    * No content.
    * TODO: Do we need to put the empty string in ?
    */
    attr = xmlSetNsProp(ctxt->insert, ns, name, (const xmlChar *) "");
    } else if ((inst->children->next == NULL) &&
        ((inst->children->type == XML_TEXT_NODE) ||
         (inst->children->type == XML_CDATA_SECTION_NODE)))
    {
    xmlNodePtr copyTxt;
 
    /*
    * xmlSetNsProp() will take care of duplicates.
    */
    attr = xmlSetNsProp(ctxt->insert, ns, name, NULL);
    if (attr == NULL) /* TODO: report error ? */
        goto error;
    /*
    * This was taken over from xsltCopyText() (transform.c).
    */
    if (ctxt->internalized &&
        (ctxt->insert->doc != NULL) &&
        (ctxt->insert->doc->dict == ctxt->dict))
    {
        copyTxt = xmlNewText(NULL);
        if (copyTxt == NULL) /* TODO: report error */
        goto error;
        /*
        * This is a safe scenario where we don't need to lookup
        * the dict.
        */
        copyTxt->content = inst->children->content;
        /*
        * Copy "disable-output-escaping" information.
        * TODO: Does this have any effect for attribute values
        *  anyway?
        */
        if (inst->children->name == xmlStringTextNoenc)
        copyTxt->name = xmlStringTextNoenc;
    } else {
        /*
        * Copy the value.
        */
        copyTxt = xmlNewText(inst->children->content);
        if (copyTxt == NULL) /* TODO: report error */
        goto error;
    }
    attr->children = attr->last = copyTxt;
    copyTxt->parent = (xmlNodePtr) attr;
    copyTxt->doc = attr->doc;
    /*
    * Copy "disable-output-escaping" information.
    * TODO: Does this have any effect for attribute values
    *  anyway?
    */
    if (inst->children->name == xmlStringTextNoenc)
        copyTxt->name = xmlStringTextNoenc;
 
        /*
         * since we create the attribute without content IDness must be
         * asserted as a second step
         */
        if ((copyTxt->content != NULL) &&
            (xmlIsID(attr->doc, attr->parent, attr)))
            xmlAddID(NULL, attr->doc, copyTxt->content, attr);
    } else {
    /*
    * The sequence constructor might be complex, so instantiate it.
    */
    value = xsltEvalTemplateString(ctxt, contextNode, inst);
    if (value != NULL) {
        attr = xmlSetNsProp(ctxt->insert, ns, name, value);
        xmlFree(value);
    } else {
        /*
        * TODO: Do we have to add the empty string to the attr?
        * TODO: Does a  value of NULL indicate an
        *  error in xsltEvalTemplateString() ?
        */
        attr = xmlSetNsProp(ctxt->insert, ns, name,
        (const xmlChar *) "");
    }
    }
 
error:
    return;
}

Referenced by xsltApplyAttributeSet(), xsltNewStylePreComp(), and xsltRegisterAllElement().

xsltFreeAttrElem()

static void xsltFreeAttrElem ( xsltAttrElemPtr  attr )

static

xsltFreeAttrElem: @attr: an XSLT AttrElem

Free up the memory allocated by @attr

Definition at line 134 of file attributes.c.

                                       {
    xmlFree(attr);
}

Referenced by xsltFreeAttrElemList().

xsltFreeAttrElemList()

static void xsltFreeAttrElemList ( xsltAttrElemPtr  list )

static

xsltFreeAttrElemList: @list: an XSLT AttrElem list

Free up the memory allocated by @list

Definition at line 145 of file attributes.c.

                                           {
    xsltAttrElemPtr next;
 
    while (list != NULL) {
    next = list->next;
    xsltFreeAttrElem(list);
    list = next;
    }
}

Referenced by xsltFreeAttrSet().

xsltFreeAttributeSetsEntry()

static void xsltFreeAttributeSetsEntry ( void *  payload, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 1225 of file attributes.c.

                                                                 {
    xsltFreeAttrSet((xsltAttrSetPtr) payload);
}

Referenced by xsltFreeAttributeSetsHashes().

xsltFreeAttributeSetsHashes()

void xsltFreeAttributeSetsHashes

(

xsltStylesheetPtr

style

)

xsltFreeAttributeSetsHashes: @style: an XSLT stylesheet

Free up the memory used by attribute sets

Definition at line 1237 of file attributes.c.

                                                     {
    if (style->attributeSets != NULL)
    xmlHashFree((xmlHashTablePtr) style->attributeSets,
            xsltFreeAttributeSetsEntry);
    style->attributeSets = NULL;
}

Referenced by xsltFreeStylesheet().

xsltFreeAttrSet()

static void xsltFreeAttrSet ( xsltAttrSetPtr  set )

static

xsltFreeAttrSet: @set: an attribute set

Free memory allocated by @set

Definition at line 298 of file attributes.c.

                                    {
    if (set == NULL)
        return;
 
    xsltFreeAttrElemList(set->attrs);
    xsltFreeUseAttrSetList(set->useAttrSets);
    xmlFree(set);
}

Referenced by xsltFreeAttributeSetsEntry(), xsltParseStylesheetAttributeSet(), xsltResolveAttrSet(), and xsltResolveSASCallback().

xsltFreeUseAttrSet()

static void xsltFreeUseAttrSet ( xsltUseAttrSetPtr  use )

static

xsltFreeUseAttrSet: @use: an XSLT UseAttrSet

Free up the memory allocated by @use

Definition at line 216 of file attributes.c.

                                          {
    xmlFree(use);
}

Referenced by xsltFreeUseAttrSetList(), and xsltResolveUseAttrSets().

xsltFreeUseAttrSetList()

static void xsltFreeUseAttrSetList ( xsltUseAttrSetPtr  list )

static

xsltFreeUseAttrSetList: @list: an XSLT UseAttrSet list

Free up the memory allocated by @list

Definition at line 227 of file attributes.c.

                                               {
    xsltUseAttrSetPtr next;
 
    while (list != NULL) {
    next = list->next;
    xsltFreeUseAttrSet(list);
    list = next;
    }
}

Referenced by xsltFreeAttrSet().

xsltMergeAttrSets()

static void xsltMergeAttrSets ( xsltAttrSetPtr  set, xsltAttrSetPtr  other  )

static

xsltMergeAttrSets: @set: an attribute set @other: another attribute set

Add all the attributes from @other to @set, but drop redefinition of existing values.

Definition at line 316 of file attributes.c.

                                                            {
    xsltAttrElemPtr cur;
    xsltAttrElemPtr old = other->attrs;
    int add;
 
    while (old != NULL) {
    /*
     * Check that the attribute is not yet in the list
     */
    cur = set->attrs;
    add = 1;
    while (cur != NULL) {
            xsltStylePreCompPtr curComp = cur->attr->psvi;
            xsltStylePreCompPtr oldComp = old->attr->psvi;
 
            if ((curComp->name == oldComp->name) &&
                (curComp->ns == oldComp->ns)) {
                add = 0;
                break;
            }
        if (cur->next == NULL)
        break;
            cur = cur->next;
    }
 
    if (add == 1) {
        if (cur == NULL) {
        set->attrs = xsltNewAttrElem(old->attr);
        } else if (add) {
        cur->next = xsltNewAttrElem(old->attr);
        }
    }
 
    old = old->next;
    }
}

Referenced by xsltResolveAttrSet(), and xsltResolveUseAttrSets().

xsltNewAttrElem()

static xsltAttrElemPtr xsltNewAttrElem ( xmlNodePtr  attr )

static

xsltNewAttrElem: @attr: the new xsl:attribute node

Create a new XSLT AttrElem

Returns the newly allocated xsltAttrElemPtr or NULL in case of error

Definition at line 113 of file attributes.c.

                                 {
    xsltAttrElemPtr cur;
 
    cur = (xsltAttrElemPtr) xmlMalloc(sizeof(xsltAttrElem));
    if (cur == NULL) {
        xsltGenericError(xsltGenericErrorContext,
        "xsltNewAttrElem : malloc failed\n");
    return(NULL);
    }
    memset(cur, 0, sizeof(xsltAttrElem));
    cur->attr = attr;
    return(cur);
}

Referenced by xsltAddAttrElemList(), and xsltMergeAttrSets().

xsltNewAttrSet()

static xsltAttrSetPtr xsltNewAttrSet ( void  )

static

xsltNewAttrSet:

Create a new attribute set.

Returns the newly allocated xsltAttrSetPtr or NULL in case of error.

Definition at line 278 of file attributes.c.

                     {
    xsltAttrSetPtr cur;
 
    cur = (xsltAttrSetPtr) xmlMalloc(sizeof(xsltAttrSet));
    if (cur == NULL) {
        xsltGenericError(xsltGenericErrorContext,
        "xsltNewAttrSet : malloc failed\n");
    return(NULL);
    }
    memset(cur, 0, sizeof(xsltAttrSet));
    return(cur);
}

Referenced by xsltParseStylesheetAttributeSet().

xsltNewUseAttrSet()

static xsltUseAttrSetPtr xsltNewUseAttrSet ( const xmlChar *  ncname, const xmlChar *  ns  )

static

xsltNewUseAttrSet: @ncname: local name @ns: namespace URI

Create a new XSLT UseAttrSet

Returns the newly allocated xsltUseAttrSetPtr or NULL in case of error.

Definition at line 194 of file attributes.c.

                                                            {
    xsltUseAttrSetPtr cur;
 
    cur = (xsltUseAttrSetPtr) xmlMalloc(sizeof(xsltUseAttrSet));
    if (cur == NULL) {
        xsltGenericError(xsltGenericErrorContext,
        "xsltNewUseAttrSet : malloc failed\n");
    return(NULL);
    }
    memset(cur, 0, sizeof(xsltUseAttrSet));
    cur->ncname = ncname;
    cur->ns = ns;
    return(cur);
}

Referenced by xsltAddUseAttrSetList().

xsltParseStylesheetAttributeSet()

void xsltParseStylesheetAttributeSet	(	xsltStylesheetPtr	style,
		xmlNodePtr	cur
	)

xsltParseStylesheetAttributeSet: @style: the XSLT stylesheet @cur: the "attribute-set" element

parse an XSLT stylesheet attribute-set element

Definition at line 368 of file attributes.c.

                                                                         {
    const xmlChar *ncname;
    const xmlChar *prefix;
    const xmlChar *nsUri = NULL;
    xmlChar *value;
    xmlNodePtr child;
    xsltAttrSetPtr set;
 
    if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
    return;
 
    value = xmlGetNsProp(cur, (const xmlChar *)"name", NULL);
    if ((value == NULL) || (*value == 0)) {
    xsltGenericError(xsltGenericErrorContext,
         "xsl:attribute-set : name is missing\n");
        if (value)
        xmlFree(value);
    return;
    }
 
    if (xmlValidateQName(value, 0)) {
        xsltTransformError(NULL, style, cur,
            "xsl:attribute-set : The name '%s' is not a valid QName.\n",
            value);
        style->errors++;
        xmlFree(value);
        return;
    }
 
    ncname = xsltSplitQName(style->dict, value, &prefix);
    xmlFree(value);
    value = NULL;
    if (prefix != NULL) {
        xmlNsPtr ns = xmlSearchNs(style->doc, cur, prefix);
        if (ns == NULL) {
            xsltTransformError(NULL, style, cur,
                "xsl:attribute-set : No namespace found for QName '%s:%s'\n",
                prefix, ncname);
            style->errors++;
            return;
        }
        nsUri = ns->href;
    }
 
    if (style->attributeSets == NULL) {
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
    xsltGenericDebug(xsltGenericDebugContext,
        "creating attribute set table\n");
#endif
    style->attributeSets = xmlHashCreate(10);
    }
    if (style->attributeSets == NULL)
    return;
 
    set = xmlHashLookup2(style->attributeSets, ncname, nsUri);
    if (set == NULL) {
        set = xsltNewAttrSet();
        if ((set == NULL) ||
            (xmlHashAddEntry2(style->attributeSets, ncname, nsUri, set) < 0)) {
        xsltGenericError(xsltGenericErrorContext, "memory error\n");
            xsltFreeAttrSet(set);
            return;
        }
    }
 
    /*
    * Parse the content. Only xsl:attribute elements are allowed.
    */
    child = cur->children;
    while (child != NULL) {
    /*
    * Report invalid nodes.
    */
    if ((child->type != XML_ELEMENT_NODE) ||
        (child->ns == NULL) ||
        (! IS_XSLT_ELEM(child)))
    {
        if (child->type == XML_ELEMENT_NODE)
        xsltTransformError(NULL, style, child,
            "xsl:attribute-set : unexpected child %s\n",
                         child->name);
        else
        xsltTransformError(NULL, style, child,
            "xsl:attribute-set : child of unexpected type\n");
    } else if (!IS_XSLT_NAME(child, "attribute")) {
        xsltTransformError(NULL, style, child,
        "xsl:attribute-set : unexpected child xsl:%s\n",
        child->name);
    } else {
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
        xsltGenericDebug(xsltGenericDebugContext,
        "add attribute to list %s\n", ncname);
#endif
            xsltStylePreCompute(style, child);
            if (child->children != NULL) {
#ifdef XSLT_REFACTORED
                xsltParseSequenceConstructor(XSLT_CCTXT(style),
                                             child->children);
#else
                xsltParseTemplateContent(style, child);
#endif
            }
            if (child->psvi == NULL) {
                xsltTransformError(NULL, style, child,
                    "xsl:attribute-set : internal error, attribute %s not "
                    "compiled\n", child->name);
            }
            else {
            set->attrs = xsltAddAttrElemList(set->attrs, child);
            }
    }
 
    child = child->next;
    }
 
    /*
    * Process attribute "use-attribute-sets".
    */
    value = xmlGetNsProp(cur, BAD_CAST "use-attribute-sets", NULL);
    if (value != NULL) {
    const xmlChar *curval, *endval;
    curval = value;
    while (*curval != 0) {
        while (IS_BLANK(*curval)) curval++;
        if (*curval == 0)
        break;
        endval = curval;
        while ((*endval != 0) && (!IS_BLANK(*endval))) endval++;
        curval = xmlDictLookup(style->dict, curval, endval - curval);
        if (curval) {
        const xmlChar *ncname2 = NULL;
        const xmlChar *prefix2 = NULL;
                const xmlChar *nsUri2 = NULL;
 
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
        xsltGenericDebug(xsltGenericDebugContext,
            "xsl:attribute-set : %s adds use %s\n", ncname, curval);
#endif
 
                if (xmlValidateQName(curval, 0)) {
                    xsltTransformError(NULL, style, cur,
                        "xsl:attribute-set : The name '%s' in "
                        "use-attribute-sets is not a valid QName.\n", curval);
                    style->errors++;
                    xmlFree(value);
                    return;
                }
 
        ncname2 = xsltSplitQName(style->dict, curval, &prefix2);
                if (prefix2 != NULL) {
                    xmlNsPtr ns2 = xmlSearchNs(style->doc, cur, prefix2);
                    if (ns2 == NULL) {
                        xsltTransformError(NULL, style, cur,
                            "xsl:attribute-set : No namespace found for QName "
                            "'%s:%s' in use-attribute-sets\n",
                            prefix2, ncname2);
                        style->errors++;
                        xmlFree(value);
                        return;
                    }
                    nsUri2 = ns2->href;
                }
                set->useAttrSets = xsltAddUseAttrSetList(set->useAttrSets,
                                                         ncname2, nsUri2);
        }
        curval = endval;
    }
    xmlFree(value);
    value = NULL;
    }
 
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
    xsltGenericDebug(xsltGenericDebugContext,
    "updated attribute list %s\n", ncname);
#endif
}

Referenced by xsltParseStylesheetTop().

xsltResolveAttrSet()

static void xsltResolveAttrSet ( xsltAttrSetPtr  set, xsltStylesheetPtr  topStyle, xsltStylesheetPtr  style, const xmlChar *  name, const xmlChar *  ns, int  depth  )

static

Definition at line 600 of file attributes.c.

                                                 {
    xsltStylesheetPtr cur;
    xsltAttrSetPtr other;
 
    if (set->state == ATTRSET_RESOLVED)
        return;
    if (set->state == ATTRSET_RESOLVING) {
    xsltTransformError(NULL, topStyle, NULL,
            "xsl:attribute-set : use-attribute-sets recursion detected"
            " on %s\n", name);
        topStyle->errors++;
        set->state = ATTRSET_RESOLVED;
        return;
    }
    if (depth > 100) {
    xsltTransformError(NULL, topStyle, NULL,
        "xsl:attribute-set : use-attribute-sets maximum recursion "
        "depth exceeded on %s\n", name);
        topStyle->errors++;
    return;
    }
 
    set->state = ATTRSET_RESOLVING;
 
    xsltResolveUseAttrSets(set, topStyle, depth);
 
    /* Merge imported sets. */
    cur = xsltNextImport(style);
    while (cur != NULL) {
        if (cur->attributeSets != NULL) {
            other = xmlHashLookup2(cur->attributeSets, name, ns);
 
            if (other != NULL) {
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
                xsltGenericDebug(xsltGenericDebugContext,
                    "xsl:attribute-set : merging import for %s\n", name);
#endif
                xsltResolveUseAttrSets(other, topStyle, depth);
                xsltMergeAttrSets(set, other);
                xmlHashRemoveEntry2(cur->attributeSets, name, ns, NULL);
                xsltFreeAttrSet(other);
            }
        }
 
        cur = xsltNextImport(cur);
    }
 
    set->state = ATTRSET_RESOLVED;
}

Referenced by xsltResolveSASCallback(), and xsltResolveUseAttrSets().

xsltResolveSASCallback()

static void xsltResolveSASCallback ( void *  payload, void *  data, const xmlChar *  name, const xmlChar *  ns, ATTRIBUTE_UNUSED const xmlChar *  ignored  )

static

Definition at line 662 of file attributes.c.

                                                        {
    xsltAttrSetPtr set = (xsltAttrSetPtr) payload;
    xsltAttrSetContextPtr asctx = (xsltAttrSetContextPtr) data;
    xsltStylesheetPtr topStyle = asctx->topStyle;
    xsltStylesheetPtr style = asctx->style;
 
    if (asctx->error) {
        if (style != topStyle)
            xsltFreeAttrSet(set);
        return;
    }
 
    xsltResolveAttrSet(set, topStyle, style, name, ns, 1);
 
    /* Move attribute sets to top stylesheet. */
    if (style != topStyle) {
        /*
         * This imported stylesheet won't be visited anymore. Don't bother
         * removing the hash entry.
         */
        if (xmlHashAddEntry2(topStyle->attributeSets, name, ns, set) < 0) {
        xsltGenericError(xsltGenericErrorContext,
                "xsl:attribute-set : internal error, can't move imported "
                " attribute set %s\n", name);
            asctx->error = 1;
            xsltFreeAttrSet(set);
        }
    }
}

Referenced by xsltResolveStylesheetAttributeSet().

xsltResolveStylesheetAttributeSet()

void xsltResolveStylesheetAttributeSet

(

xsltStylesheetPtr

style

)

xsltResolveStylesheetAttributeSet: @style: the XSLT stylesheet

resolve the references between attribute sets.

Definition at line 701 of file attributes.c.

                                                           {
    xsltStylesheetPtr cur;
    xsltAttrSetContext asctx;
 
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
    xsltGenericDebug(xsltGenericDebugContext,
        "Resolving attribute sets references\n");
#endif
    asctx.topStyle = style;
    asctx.error = 0;
    cur = style;
    while (cur != NULL) {
    if (cur->attributeSets != NULL) {
        if (style->attributeSets == NULL) {
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
        xsltGenericDebug(xsltGenericDebugContext,
            "creating attribute set table\n");
#endif
        style->attributeSets = xmlHashCreate(10);
        }
            asctx.style = cur;
        xmlHashScanFull(cur->attributeSets, xsltResolveSASCallback,
                            &asctx);
 
            if (cur != style) {
                /*
                 * the attribute lists have either been migrated to style
                 * or freed directly in xsltResolveSASCallback()
                 */
                xmlHashFree(cur->attributeSets, NULL);
                cur->attributeSets = NULL;
            }
    }
    cur = xsltNextImport(cur);
    }
}

Referenced by xsltParseStylesheetUser().

xsltResolveUseAttrSets()

static void xsltResolveUseAttrSets ( xsltAttrSetPtr  set, xsltStylesheetPtr  topStyle, int  depth  )

static

xsltResolveUseAttrSets: @set: the attribute set @asctx: the context for attribute set resolution @depth: recursion depth

Process "use-attribute-sets".

Definition at line 554 of file attributes.c.

                          {
    xsltStylesheetPtr cur;
    xsltAttrSetPtr other;
    xsltUseAttrSetPtr use = set->useAttrSets;
    xsltUseAttrSetPtr next;
 
    while (use != NULL) {
        /*
         * Iterate top stylesheet and all imports.
         */
        cur = topStyle;
        while (cur != NULL) {
            if (cur->attributeSets) {
                other = xmlHashLookup2(cur->attributeSets, use->ncname,
                                       use->ns);
                if (other != NULL) {
                    xsltResolveAttrSet(other, topStyle, cur, use->ncname,
                                       use->ns, depth + 1);
                    xsltMergeAttrSets(set, other);
                    break;
                }
            }
            cur = xsltNextImport(cur);
        }
 
        next = use->next;
        /* Free useAttrSets early. */
        xsltFreeUseAttrSet(use);
        use = next;
    }
 
    set->useAttrSets = NULL;
}

Referenced by xsltResolveAttrSet().