mirror of
https://github.com/reactos/reactos.git
synced 2024-11-11 01:04:11 +00:00
c424146e2c
svn path=/branches/cmake-bringup/; revision=48236
1139 lines
29 KiB
C
1139 lines
29 KiB
C
/*
|
|
* 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 *
|
|
* *
|
|
************************************************************************/
|
|
|
|
/**
|
|
* xsltNewAttrElem:
|
|
* @attr: the new xsl:attribute node
|
|
*
|
|
* Create a new XSLT AttrElem
|
|
*
|
|
* Returns the newly allocated xsltAttrElemPtr or NULL in case of error
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* xsltFreeAttrElem:
|
|
* @attr: an XSLT AttrElem
|
|
*
|
|
* Free up the memory allocated by @attr
|
|
*/
|
|
static void
|
|
xsltFreeAttrElem(xsltAttrElemPtr attr) {
|
|
xmlFree(attr);
|
|
}
|
|
|
|
/**
|
|
* xsltFreeAttrElemList:
|
|
* @list: an XSLT AttrElem list
|
|
*
|
|
* Free up the memory allocated by @list
|
|
*/
|
|
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
|
|
/**
|
|
* xsltAddAttrElemList:
|
|
* @list: an XSLT AttrElem list
|
|
* @attr: the new xsl:attribute node
|
|
*
|
|
* Add the new attribute to the list.
|
|
*
|
|
* Returns the new list pointer
|
|
*/
|
|
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 */
|
|
|
|
/**
|
|
* xsltMergeAttrElemList:
|
|
* @list: an XSLT AttrElem list
|
|
* @old: another XSLT AttrElem list
|
|
*
|
|
* Add all the attributes from list @old to list @list,
|
|
* but drop redefinition of existing values.
|
|
*
|
|
* Returns the new list pointer
|
|
*/
|
|
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 *
|
|
* *
|
|
************************************************************************/
|
|
|
|
/**
|
|
* xsltParseStylesheetAttributeSet:
|
|
* @style: the XSLT stylesheet
|
|
* @cur: the "attribute-set" element
|
|
*
|
|
* parse an XSLT stylesheet attribute-set element
|
|
*/
|
|
|
|
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
|
|
}
|
|
|
|
/**
|
|
* xsltGetSAS:
|
|
* @style: the XSLT stylesheet
|
|
* @name: the attribute list name
|
|
* @ns: the attribute list namespace
|
|
*
|
|
* lookup an attribute set based on the style cascade
|
|
*
|
|
* Returns the attribute set or NULL
|
|
*/
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* xsltResolveSASCallback,:
|
|
* @style: the XSLT stylesheet
|
|
*
|
|
* resolve the references in an attribute set.
|
|
*/
|
|
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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* xsltMergeSASCallback,:
|
|
* @style: the XSLT stylesheet
|
|
*
|
|
* Merge an attribute set from an imported stylesheet.
|
|
*/
|
|
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
|
|
}
|
|
}
|
|
|
|
/**
|
|
* xsltResolveStylesheetAttributeSet:
|
|
* @style: the XSLT stylesheet
|
|
*
|
|
* resolve the references between attribute sets.
|
|
*/
|
|
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);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* xsltAttributeInternal:
|
|
* @ctxt: a XSLT process context
|
|
* @node: the current node in the source tree
|
|
* @inst: the xsl:attribute element
|
|
* @comp: precomputed information
|
|
* @fromAttributeSet: the attribute comes from an attribute-set
|
|
*
|
|
* Process the xslt attribute node on the source node
|
|
*/
|
|
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;
|
|
}
|
|
|
|
/**
|
|
* xsltAttribute:
|
|
* @ctxt: a XSLT process context
|
|
* @node: the node in the source tree.
|
|
* @inst: the xslt attribute node
|
|
* @comp: precomputed information
|
|
*
|
|
* Process the xslt attribute node on the source node
|
|
*/
|
|
void
|
|
xsltAttribute(xsltTransformContextPtr ctxt, xmlNodePtr node,
|
|
xmlNodePtr inst, xsltStylePreCompPtr comp) {
|
|
xsltAttributeInternal(ctxt, node, inst, comp, 0);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* xsltFreeAttributeSetsHashes:
|
|
* @style: an XSLT stylesheet
|
|
*
|
|
* Free up the memory used by attribute sets
|
|
*/
|
|
void
|
|
xsltFreeAttributeSetsHashes(xsltStylesheetPtr style) {
|
|
if (style->attributeSets != NULL)
|
|
xmlHashFree((xmlHashTablePtr) style->attributeSets,
|
|
(xmlHashDeallocator) xsltFreeAttrElemList);
|
|
style->attributeSets = NULL;
|
|
}
|