attributes.c

Go to the documentation of this file.

/*
 * attributes.c: Implementation of the XSLT attributes handling
 *
 * Reference:
 *   http://www.w3.org/TR/1999/REC-xslt-19991116
 *
 * See Copyright for the status of this software.
 *
 * daniel@veillard.com
 */

#define IN_LIBXSLT
#include "libxslt.h"

#include <string.h>

#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_MATH_H
#include <math.h>
#endif
#ifdef HAVE_FLOAT_H
#include <float.h>
#endif
#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif
#ifdef HAVE_NAN_H
#include <nan.h>
#endif
#ifdef HAVE_CTYPE_H
#include <ctype.h>
#endif

#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"

#define WITH_XSLT_DEBUG_ATTRIBUTES
#ifdef WITH_XSLT_DEBUG
#define WITH_XSLT_DEBUG_ATTRIBUTES
#endif

/*
 * TODO: merge attribute sets from different import precedence.
 *       all this should be precomputed just before the transformation
 *       starts or at first hit with a cache in the context.
 *       The simple way for now would be to not allow redefinition of
 *       attributes once generated in the output tree, possibly costlier.
 */

/*
 * Useful macros
 */
#ifdef IS_BLANK
#undef IS_BLANK
#endif

#define IS_BLANK(c) (((c) == 0x20) || ((c) == 0x09) || ((c) == 0xA) ||  \
                     ((c) == 0x0D))

#define IS_BLANK_NODE(n)                        \
    (((n)->type == XML_TEXT_NODE) && (xsltIsBlank((n)->content)))


/*
 * The in-memory structure corresponding to an XSLT Attribute in
 * an attribute set
 */


typedef struct _xsltAttrElem xsltAttrElem;
typedef xsltAttrElem *xsltAttrElemPtr;
struct _xsltAttrElem {
    struct _xsltAttrElem *next;/* chained list */
    xmlNodePtr attr;    /* the xsl:attribute definition */
    const xmlChar *set; /* or the attribute set */
    const xmlChar *ns;  /* and its namespace */
};

/************************************************************************
 *                                  *
 *          XSLT Attribute handling             *
 *                                  *
 ************************************************************************/

static xsltAttrElemPtr
xsltNewAttrElem(xmlNodePtr attr) {
    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);
}

static void
xsltFreeAttrElem(xsltAttrElemPtr attr) {
    xmlFree(attr);
}

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

#ifdef XSLT_REFACTORED
    /*
    * This was moved to xsltParseStylesheetAttributeSet().
    */
#else

static xsltAttrElemPtr
xsltAddAttrElemList(xsltAttrElemPtr list, xmlNodePtr attr) {
    xsltAttrElemPtr next, cur;

    if (attr == NULL)
    return(list);
    if (list == NULL)
    return(xsltNewAttrElem(attr));
    cur = list;
    while (cur != NULL) {   
    next = cur->next;
    if (cur->attr == attr)
        return(cur);
    if (cur->next == NULL) {
        cur->next = xsltNewAttrElem(attr);
        return(list);
    }
    cur = next;
    }
    return(list);
}
#endif /* XSLT_REFACTORED */

static xsltAttrElemPtr
xsltMergeAttrElemList(xsltStylesheetPtr style,
              xsltAttrElemPtr list, xsltAttrElemPtr old) {
    xsltAttrElemPtr cur;
    int add;

    while (old != NULL) {
    if ((old->attr == NULL) && (old->set == NULL)) {
        old = old->next;
        continue;
    }
    /*
     * Check that the attribute is not yet in the list
     */
    cur = list;
    add = 1;
    while (cur != NULL) {
        if ((cur->attr == NULL) && (cur->set == NULL)) {
        if (cur->next == NULL)
            break;
        cur = cur->next;
        continue;
        }
        if ((cur->set != NULL) && (cur->set == old->set)) {
        add = 0;
        break;
        }
        if (cur->set != NULL) {
        if (cur->next == NULL)
            break;
        cur = cur->next;
        continue;
        }
        if (old->set != NULL) {
        if (cur->next == NULL)
            break;
        cur = cur->next;
        continue;
        }
        if (cur->attr == old->attr) {
        xsltGenericError(xsltGenericErrorContext,
         "xsl:attribute-set : use-attribute-sets recursion detected\n");
        return(list);
        }
        if (cur->next == NULL)
        break;
            cur = cur->next;
    }

    if (add == 1) {
        /*
        * Changed to use the string-dict, rather than duplicating
        * @set and @ns; this fixes bug #340400.
        */
        if (cur == NULL) {
        list = xsltNewAttrElem(old->attr);
        if (old->set != NULL) {
            list->set = xmlDictLookup(style->dict, old->set, -1);
            if (old->ns != NULL)
            list->ns = xmlDictLookup(style->dict, old->ns, -1);
        }
        } else if (add) {
        cur->next = xsltNewAttrElem(old->attr);
        if (old->set != NULL) {
            cur->next->set = xmlDictLookup(style->dict, old->set, -1);
            if (old->ns != NULL)
            cur->next->ns = xmlDictLookup(style->dict, old->ns, -1);
        }
        }
    }

    old = old->next;
    }
    return(list);
}

/************************************************************************
 *                                  *
 *          Module interfaces               *
 *                                  *
 ************************************************************************/

void
xsltParseStylesheetAttributeSet(xsltStylesheetPtr style, xmlNodePtr cur) {
    const xmlChar *ncname;
    const xmlChar *prefix;
    xmlChar *value;
    xmlNodePtr child;
    xsltAttrElemPtr attrItems;

    if ((cur == NULL) || (style == NULL))
    return;

    value = xmlGetNsProp(cur, (const xmlChar *)"name", NULL);
    if (value == NULL) {
    xsltGenericError(xsltGenericErrorContext,
         "xsl:attribute-set : name is missing\n");
    return;
    }

    ncname = xsltSplitQName(style->dict, value, &prefix);
    xmlFree(value);
    value = NULL;

    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;

    attrItems = xmlHashLookup2(style->attributeSets, ncname, prefix);

    /*
    * 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 XSLT_REFACTORED
        xsltAttrElemPtr nextAttr, curAttr;

        /*
        * Process xsl:attribute
        * ---------------------
        */

#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
        xsltGenericDebug(xsltGenericDebugContext,
        "add attribute to list %s\n", ncname);
#endif
        /*
        * The following was taken over from
        * xsltAddAttrElemList().
        */
        if (attrItems == NULL) {
        attrItems = xsltNewAttrElem(child);
        } else {
        curAttr = attrItems;
        while (curAttr != NULL) {
            nextAttr = curAttr->next;
            if (curAttr->attr == child) {
            /*
            * URGENT TODO: Can somebody explain
            *  why attrItems is set to curAttr
            *  here? Is this somehow related to
            *  avoidance of recursions?
            */
            attrItems = curAttr;
            goto next_child;
            }
            if (curAttr->next == NULL)          
            curAttr->next = xsltNewAttrElem(child);
            curAttr = nextAttr;
        }
        }
        /*
        * Parse the xsl:attribute and its content.
        */
        xsltParseAnyXSLTElem(XSLT_CCTXT(style), child);
#else
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
        xsltGenericDebug(xsltGenericDebugContext,
        "add attribute to list %s\n", ncname);
#endif
        /*
        * OLD behaviour:
        */
        attrItems = xsltAddAttrElemList(attrItems, child);
#endif
    }

#ifdef XSLT_REFACTORED
next_child:
#endif
    child = child->next;
    }

    /*
    * Process attribue "use-attribute-sets".
    */
    /* TODO check recursion */    
    value = xmlGetNsProp(cur, (const xmlChar *)"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;
        xsltAttrElemPtr refAttrItems;
        
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
        xsltGenericDebug(xsltGenericDebugContext,
            "xsl:attribute-set : %s adds use %s\n", ncname, curval);
#endif
        ncname2 = xsltSplitQName(style->dict, curval, &prefix2);
        refAttrItems = xsltNewAttrElem(NULL);
        if (refAttrItems != NULL) {
            refAttrItems->set = ncname2;
            refAttrItems->ns = prefix2;
            attrItems = xsltMergeAttrElemList(style,
            attrItems, refAttrItems);
            xsltFreeAttrElem(refAttrItems);
        }
        }
        curval = endval;
    }
    xmlFree(value);
    value = NULL;
    }

    /*
     * Update the value
     */
    /*
    * TODO: Why is this dummy entry needed.?
    */
    if (attrItems == NULL)
    attrItems = xsltNewAttrElem(NULL);
    xmlHashUpdateEntry2(style->attributeSets, ncname, prefix, attrItems, NULL);
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
    xsltGenericDebug(xsltGenericDebugContext,
    "updated attribute list %s\n", ncname);
#endif
}

static xsltAttrElemPtr
xsltGetSAS(xsltStylesheetPtr style, const xmlChar *name, const xmlChar *ns) {
    xsltAttrElemPtr values;

    while (style != NULL) {
    values = xmlHashLookup2(style->attributeSets, name, ns);
    if (values != NULL)
        return(values);
    style = xsltNextImport(style);
    }
    return(NULL);
}

static void
xsltResolveSASCallback(xsltAttrElemPtr values, xsltStylesheetPtr style,
                   const xmlChar *name, const xmlChar *ns,
               ATTRIBUTE_UNUSED const xmlChar *ignored) {
    xsltAttrElemPtr tmp;
    xsltAttrElemPtr refs;

    tmp = values;
    while (tmp != NULL) {
    if (tmp->set != NULL) {
        /*
         * Check against cycles !
         */
        if ((xmlStrEqual(name, tmp->set)) && (xmlStrEqual(ns, tmp->ns))) {
        xsltGenericError(xsltGenericErrorContext,
     "xsl:attribute-set : use-attribute-sets recursion detected on %s\n",
                                 name);
        } else {
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
        xsltGenericDebug(xsltGenericDebugContext,
            "Importing attribute list %s\n", tmp->set);
#endif

        refs = xsltGetSAS(style, tmp->set, tmp->ns);
        if (refs == NULL) {
            xsltGenericError(xsltGenericErrorContext,
     "xsl:attribute-set : use-attribute-sets %s reference missing %s\n",
                     name, tmp->set);
        } else {
            /*
             * recurse first for cleanup
             */
            xsltResolveSASCallback(refs, style, name, ns, NULL);
            /*
             * Then merge
             */
            xsltMergeAttrElemList(style, values, refs);
            /*
             * Then suppress the reference
             */
            tmp->set = NULL;
            tmp->ns = NULL;
        }
        }
    }
    tmp = tmp->next;
    }
}

static void
xsltMergeSASCallback(xsltAttrElemPtr values, xsltStylesheetPtr style,
                   const xmlChar *name, const xmlChar *ns,
               ATTRIBUTE_UNUSED const xmlChar *ignored) {
    int ret;
    xsltAttrElemPtr topSet;

    ret = xmlHashAddEntry2(style->attributeSets, name, ns, values);
    if (ret < 0) {
    /*
     * Add failed, this attribute set can be removed.
     */
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
    xsltGenericDebug(xsltGenericDebugContext,
        "attribute set %s present already in top stylesheet"
        " - merging\n", name);
#endif
    topSet = xmlHashLookup2(style->attributeSets, name, ns);
    if (topSet==NULL) {
        xsltGenericError(xsltGenericErrorContext,
            "xsl:attribute-set : logic error merging from imports for"
        " attribute-set %s\n", name);
    } else {
        topSet = xsltMergeAttrElemList(style, topSet, values);
        xmlHashUpdateEntry2(style->attributeSets, name, ns, topSet, NULL);
    }
    xsltFreeAttrElemList(values);
#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
    } else {
    xsltGenericDebug(xsltGenericDebugContext,
        "attribute set %s moved to top stylesheet\n",
                 name);
#endif
    }
}

void
xsltResolveStylesheetAttributeSet(xsltStylesheetPtr style) {
    xsltStylesheetPtr cur;

#ifdef WITH_XSLT_DEBUG_ATTRIBUTES
    xsltGenericDebug(xsltGenericDebugContext,
        "Resolving attribute sets references\n");
#endif
    /*
     * First aggregate all the attribute sets definitions from the imports
     */
    cur = xsltNextImport(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);
        }
        xmlHashScanFull(cur->attributeSets, 
        (xmlHashScannerFull) xsltMergeSASCallback, style);
        /*
         * the attribute lists have either been migrated to style
         * or freed directly in xsltMergeSASCallback()
         */
        xmlHashFree(cur->attributeSets, NULL);
        cur->attributeSets = NULL;
    }
    cur = xsltNextImport(cur);
    }

    /*
     * Then resolve all the references and computes the resulting sets
     */
    if (style->attributeSets != NULL) {
    xmlHashScanFull(style->attributeSets, 
        (xmlHashScannerFull) xsltResolveSASCallback, style);
    }
}

static void
xsltAttributeInternal(xsltTransformContextPtr ctxt,
              xmlNodePtr contextNode,
                      xmlNodePtr inst,
              xsltStylePreCompPtr castedComp,
                      int fromAttributeSet)
{
#ifdef XSLT_REFACTORED
    xsltStyleItemAttributePtr comp =
    (xsltStyleItemAttributePtr) castedComp;   
#else
    xsltStylePreCompPtr comp = 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))
        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 xsltAttributeInternal(): "
        "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 */
    }
    name = xsltSplitQName(ctxt->dict, prop, &prefix);
    xmlFree(prop);

    /*
    * Reject a prefix of "xmlns".
    */
    if ((prefix != NULL) &&
        (!xmlStrncasecmp(prefix, (xmlChar *) "xmlns", 5)))
    {
#ifdef WITH_XSLT_DEBUG_PARSING
        xsltGenericDebug(xsltGenericDebugContext,
        "xsltAttribute: xmlns prefix forbidden\n");
#endif
        /*
        * SPEC XSLT 1.0:
        *  "It is an error if the string that results from instantiating
        *  the attribute value template is not a QName or is the string
        *  xmlns. An XSLT processor may signal the error; if it does not
        *  signal the error, it must recover by not adding the attribute
        *  to the result tree."
        * TODO: Decide which way to go here.
        */
        goto error;
    }

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

    if (fromAttributeSet) {
    /*
    * This tries to ensure that xsl:attribute(s) coming
    * from an xsl:attribute-set won't override attribute of
    * literal result elements or of explicit xsl:attribute(s).
    * URGENT TODO: This might be buggy, since it will miss to
    *  overwrite two equal attributes both from attribute sets.
    */
    attr = xmlHasNsProp(targetElem, name, nsName);
    if (attr != NULL)
        return;
    }

    /*
    * 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) {
        xmlChar *pref = xmlStrdup(BAD_CAST "ns_1");

        ns = xsltGetSpecialNamespace(ctxt, inst, nsName, BAD_CAST 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;    
}

void
xsltAttribute(xsltTransformContextPtr ctxt, xmlNodePtr node,
          xmlNodePtr inst, xsltStylePreCompPtr comp) {
    xsltAttributeInternal(ctxt, node, inst, comp, 0);
}

void
xsltApplyAttributeSet(xsltTransformContextPtr ctxt, xmlNodePtr node,
                      xmlNodePtr inst,
                      const xmlChar *attrSets)
{
    const xmlChar *ncname = NULL;
    const xmlChar *prefix = NULL;    
    const xmlChar *curstr, *endstr;
    xsltAttrElemPtr attrs;
    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) {
        /*
        * TODO: Validate the QName.
        */

#ifdef WITH_XSLT_DEBUG_curstrUTES
            xsltGenericDebug(xsltGenericDebugContext,
                             "apply curstrute set %s\n", curstr);
#endif
            ncname = xsltSplitQName(ctxt->dict, curstr, &prefix);

            style = ctxt->style;

#ifdef WITH_DEBUGGER
            if ((style != NULL) &&
        (style->attributeSets != NULL) &&
        (ctxt->debugStatus != XSLT_DEBUG_NONE))
        {
                attrs =
                    xmlHashLookup2(style->attributeSets, ncname, prefix);
                if ((attrs != NULL) && (attrs->attr != NULL))
                    xslHandleDebugger(attrs->attr->parent, node, NULL,
            ctxt);
            }
#endif
        /*
        * Lookup the referenced curstrute-set.
        */
            while (style != NULL) {
                attrs =
                    xmlHashLookup2(style->attributeSets, ncname, prefix);
                while (attrs != NULL) {
                    if (attrs->attr != NULL) {
                        xsltAttributeInternal(ctxt, node, attrs->attr,
                attrs->attr->psvi, 1);
                    }
                    attrs = attrs->next;
                }
                style = xsltNextImport(style);
            }
        }
        curstr = endstr;
    }
}

void
xsltFreeAttributeSetsHashes(xsltStylesheetPtr style) {
    if (style->attributeSets != NULL)
    xmlHashFree((xmlHashTablePtr) style->attributeSets,
            (xmlHashDeallocator) xsltFreeAttrElemList);
    style->attributeSets = NULL;
}