xref: /reactos/dll/3rdparty/libxslt/attributes.c (revision 595b846d) 
1 /*
2  * attributes.c: Implementation of the XSLT attributes handling
3  *
4  * Reference:
5  *   http://www.w3.org/TR/1999/REC-xslt-19991116
6  *
7  * See Copyright for the status of this software.
8  *
9  * daniel@veillard.com
10  */
11 
12 #include "precomp.h"
13 
14 #define WITH_XSLT_DEBUG_ATTRIBUTES
15 #ifdef WITH_XSLT_DEBUG
16 #define WITH_XSLT_DEBUG_ATTRIBUTES
17 #endif
18 
19 /*
20  * Useful macros
21  */
22 #ifdef IS_BLANK
23 #undef IS_BLANK
24 #endif
25 
26 #define IS_BLANK(c) (((c) == 0x20) || ((c) == 0x09) || ((c) == 0xA) ||	\
27                      ((c) == 0x0D))
28 
29 #define IS_BLANK_NODE(n)						\
30     (((n)->type == XML_TEXT_NODE) && (xsltIsBlank((n)->content)))
31 
32 #define ATTRSET_UNRESOLVED 0
33 #define ATTRSET_RESOLVING  1
34 #define ATTRSET_RESOLVED   2
35 
36 
37 /*
38  * The in-memory structure corresponding to an XSLT Attribute in
39  * an attribute set
40  */
41 
42 
43 typedef struct _xsltAttrElem xsltAttrElem;
44 typedef xsltAttrElem *xsltAttrElemPtr;
45 struct _xsltAttrElem {
46     struct _xsltAttrElem *next;/* chained list */
47     xmlNodePtr attr;	/* the xsl:attribute definition */
48 };
49 
50 typedef struct _xsltUseAttrSet xsltUseAttrSet;
51 typedef xsltUseAttrSet *xsltUseAttrSetPtr;
52 struct _xsltUseAttrSet {
53     struct _xsltUseAttrSet *next; /* chained list */
54     const xmlChar *ncname;
55     const xmlChar *ns;
56 };
57 
58 typedef struct _xsltAttrSet xsltAttrSet;
59 typedef xsltAttrSet *xsltAttrSetPtr;
60 struct _xsltAttrSet {
61     int state;
62     xsltAttrElemPtr attrs; /* list head */
63     xsltUseAttrSetPtr useAttrSets; /* list head */
64 };
65 
66 typedef struct _xsltAttrSetContext xsltAttrSetContext;
67 typedef xsltAttrSetContext *xsltAttrSetContextPtr;
68 struct _xsltAttrSetContext {
69     xsltStylesheetPtr topStyle;
70     xsltStylesheetPtr style;
71 };
72 
73 static void
74 xsltResolveAttrSet(xsltAttrSetPtr set, xsltStylesheetPtr topStyle,
75                    xsltStylesheetPtr style, const xmlChar *name,
76                    const xmlChar *ns, int depth);
77 
78 /************************************************************************
79  *									*
80  *			XSLT Attribute handling				*
81  *									*
82  ************************************************************************/
83 
84 /**
85  * xsltNewAttrElem:
86  * @attr:  the new xsl:attribute node
87  *
88  * Create a new XSLT AttrElem
89  *
90  * Returns the newly allocated xsltAttrElemPtr or NULL in case of error
91  */
92 static xsltAttrElemPtr
93 xsltNewAttrElem(xmlNodePtr attr) {
94     xsltAttrElemPtr cur;
95 
96     cur = (xsltAttrElemPtr) xmlMalloc(sizeof(xsltAttrElem));
97     if (cur == NULL) {
98         xsltGenericError(xsltGenericErrorContext,
99 		"xsltNewAttrElem : malloc failed\n");
100 	return(NULL);
101     }
102     memset(cur, 0, sizeof(xsltAttrElem));
103     cur->attr = attr;
104     return(cur);
105 }
106 
107 /**
108  * xsltFreeAttrElem:
109  * @attr:  an XSLT AttrElem
110  *
111  * Free up the memory allocated by @attr
112  */
113 static void
114 xsltFreeAttrElem(xsltAttrElemPtr attr) {
115     xmlFree(attr);
116 }
117 
118 /**
119  * xsltFreeAttrElemList:
120  * @list:  an XSLT AttrElem list
121  *
122  * Free up the memory allocated by @list
123  */
124 static void
125 xsltFreeAttrElemList(xsltAttrElemPtr list) {
126     xsltAttrElemPtr next;
127 
128     while (list != NULL) {
129 	next = list->next;
130 	xsltFreeAttrElem(list);
131 	list = next;
132     }
133 }
134 
135 /**
136  * xsltAddAttrElemList:
137  * @list:  an XSLT AttrElem list
138  * @attr:  the new xsl:attribute node
139  *
140  * Add the new attribute to the list.
141  *
142  * Returns the new list pointer
143  */
144 static xsltAttrElemPtr
145 xsltAddAttrElemList(xsltAttrElemPtr list, xmlNodePtr attr) {
146     xsltAttrElemPtr next, cur;
147 
148     if (attr == NULL)
149 	return(list);
150     if (list == NULL)
151 	return(xsltNewAttrElem(attr));
152     cur = list;
153     while (cur != NULL) {
154 	next = cur->next;
155 	if (next == NULL) {
156 	    cur->next = xsltNewAttrElem(attr);
157 	    return(list);
158 	}
159 	cur = next;
160     }
161     return(list);
162 }
163 
164 /**
165  * xsltNewUseAttrSet:
166  * @ncname:  local name
167  * @ns:  namespace URI
168  *
169  * Create a new XSLT UseAttrSet
170  *
171  * Returns the newly allocated xsltUseAttrSetPtr or NULL in case of error.
172  */
173 static xsltUseAttrSetPtr
174 xsltNewUseAttrSet(const xmlChar *ncname, const xmlChar *ns) {
175     xsltUseAttrSetPtr cur;
176 
177     cur = (xsltUseAttrSetPtr) xmlMalloc(sizeof(xsltUseAttrSet));
178     if (cur == NULL) {
179         xsltGenericError(xsltGenericErrorContext,
180 		"xsltNewUseAttrSet : malloc failed\n");
181 	return(NULL);
182     }
183     memset(cur, 0, sizeof(xsltUseAttrSet));
184     cur->ncname = ncname;
185     cur->ns = ns;
186     return(cur);
187 }
188 
189 /**
190  * xsltFreeUseAttrSet:
191  * @use:  an XSLT UseAttrSet
192  *
193  * Free up the memory allocated by @use
194  */
195 static void
196 xsltFreeUseAttrSet(xsltUseAttrSetPtr use) {
197     xmlFree(use);
198 }
199 
200 /**
201  * xsltFreeUseAttrSetList:
202  * @list:  an XSLT UseAttrSet list
203  *
204  * Free up the memory allocated by @list
205  */
206 static void
207 xsltFreeUseAttrSetList(xsltUseAttrSetPtr list) {
208     xsltUseAttrSetPtr next;
209 
210     while (list != NULL) {
211 	next = list->next;
212 	xsltFreeUseAttrSet(list);
213 	list = next;
214     }
215 }
216 
217 /**
218  * xsltAddUseAttrSetList:
219  * @list:  a xsltUseAttrSet list
220  * @ncname:  local name
221  * @ns:  namespace URI
222  *
223  * Add the use-attribute-set name to the list.
224  *
225  * Returns the new list pointer.
226  */
227 static xsltUseAttrSetPtr
228 xsltAddUseAttrSetList(xsltUseAttrSetPtr list, const xmlChar *ncname,
229                       const xmlChar *ns) {
230     xsltUseAttrSetPtr next, cur;
231 
232     if (ncname == NULL)
233         return(list);
234     if (list == NULL)
235 	return(xsltNewUseAttrSet(ncname, ns));
236     cur = list;
237     while (cur != NULL) {
238         if ((cur->ncname == ncname) && (cur->ns == ns))
239             return(list);
240 	next = cur->next;
241 	if (next == NULL) {
242 	    cur->next = xsltNewUseAttrSet(ncname, ns);
243 	    return(list);
244 	}
245 	cur = next;
246     }
247     return(list);
248 }
249 
250 /**
251  * xsltNewAttrSet:
252  *
253  * Create a new attribute set.
254  *
255  * Returns the newly allocated xsltAttrSetPtr or NULL in case of error.
256  */
257 static xsltAttrSetPtr
258 xsltNewAttrSet() {
259     xsltAttrSetPtr cur;
260 
261     cur = (xsltAttrSetPtr) xmlMalloc(sizeof(xsltAttrSet));
262     if (cur == NULL) {
263         xsltGenericError(xsltGenericErrorContext,
264 		"xsltNewAttrSet : malloc failed\n");
265 	return(NULL);
266     }
267     memset(cur, 0, sizeof(xsltAttrSet));
268     return(cur);
269 }
270 
271 /**
272  * xsltFreeAttrSet:
273  * @set:  an attribute set
274  *
275  * Free memory allocated by @set
276  */
277 static void
278 xsltFreeAttrSet(xsltAttrSetPtr set) {
279     if (set == NULL)
280         return;
281 
282     xsltFreeAttrElemList(set->attrs);
283     xsltFreeUseAttrSetList(set->useAttrSets);
284     xmlFree(set);
285 }
286 
287 /**
288  * xsltMergeAttrSets:
289  * @set:  an attribute set
290  * @other:  another attribute set
291  *
292  * Add all the attributes from @other to @set,
293  * but drop redefinition of existing values.
294  */
295 static void
296 xsltMergeAttrSets(xsltAttrSetPtr set, xsltAttrSetPtr other) {
297     xsltAttrElemPtr cur;
298     xsltAttrElemPtr old = other->attrs;
299     int add;
300 
301     while (old != NULL) {
302 	/*
303 	 * Check that the attribute is not yet in the list
304 	 */
305 	cur = set->attrs;
306 	add = 1;
307 	while (cur != NULL) {
308             xsltStylePreCompPtr curComp = cur->attr->psvi;
309             xsltStylePreCompPtr oldComp = old->attr->psvi;
310 
311             if ((curComp->name == oldComp->name) &&
312                 (curComp->ns == oldComp->ns)) {
313                 add = 0;
314                 break;
315             }
316 	    if (cur->next == NULL)
317 		break;
318             cur = cur->next;
319 	}
320 
321 	if (add == 1) {
322 	    if (cur == NULL) {
323 		set->attrs = xsltNewAttrElem(old->attr);
324 	    } else if (add) {
325 		cur->next = xsltNewAttrElem(old->attr);
326 	    }
327 	}
328 
329 	old = old->next;
330     }
331 }
332 
333 /************************************************************************
334  *									*
335  *			Module interfaces				*
336  *									*
337  ************************************************************************/
338 
339 /**
340  * xsltParseStylesheetAttributeSet:
341  * @style:  the XSLT stylesheet
342  * @cur:  the "attribute-set" element
343  *
344  * parse an XSLT stylesheet attribute-set element
345  */
346 
347 void
348 xsltParseStylesheetAttributeSet(xsltStylesheetPtr style, xmlNodePtr cur) {
349     const xmlChar *ncname;
350     const xmlChar *prefix;
351     const xmlChar *nsUri = NULL;
352     xmlChar *value;
353     xmlNodePtr child;
354     xsltAttrSetPtr set;
355 
356     if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
357 	return;
358 
359     value = xmlGetNsProp(cur, (const xmlChar *)"name", NULL);
360     if ((value == NULL) || (*value == 0)) {
361 	xsltGenericError(xsltGenericErrorContext,
362 	     "xsl:attribute-set : name is missing\n");
363         if (value)
364 	    xmlFree(value);
365 	return;
366     }
367 
368     if (xmlValidateQName(value, 0)) {
369         xsltTransformError(NULL, style, cur,
370             "xsl:attribute-set : The name '%s' is not a valid QName.\n",
371             value);
372         style->errors++;
373         xmlFree(value);
374         return;
375     }
376 
377     ncname = xsltSplitQName(style->dict, value, &prefix);
378     xmlFree(value);
379     value = NULL;
380     if (prefix != NULL) {
381         xmlNsPtr ns = xmlSearchNs(style->doc, cur, prefix);
382         if (ns == NULL) {
383             xsltTransformError(NULL, style, cur,
384                 "xsl:attribute-set : No namespace found for QName '%s:%s'\n",
385                 prefix, ncname);
386             style->errors++;
387             return;
388         }
389         nsUri = ns->href;
390     }
391 
392     if (style->attributeSets == NULL) {
393 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
394 	xsltGenericDebug(xsltGenericDebugContext,
395 	    "creating attribute set table\n");
396 #endif
397 	style->attributeSets = xmlHashCreate(10);
398     }
399     if (style->attributeSets == NULL)
400 	return;
401 
402     set = xmlHashLookup2(style->attributeSets, ncname, nsUri);
403     if (set == NULL) {
404         set = xsltNewAttrSet();
405         if (set == NULL)
406             return;
407         xmlHashAddEntry2(style->attributeSets, ncname, nsUri, set);
408     }
409 
410     /*
411     * Parse the content. Only xsl:attribute elements are allowed.
412     */
413     child = cur->children;
414     while (child != NULL) {
415 	/*
416 	* Report invalid nodes.
417 	*/
418 	if ((child->type != XML_ELEMENT_NODE) ||
419 	    (child->ns == NULL) ||
420 	    (! IS_XSLT_ELEM(child)))
421 	{
422 	    if (child->type == XML_ELEMENT_NODE)
423 		xsltTransformError(NULL, style, child,
424 			"xsl:attribute-set : unexpected child %s\n",
425 		                 child->name);
426 	    else
427 		xsltTransformError(NULL, style, child,
428 			"xsl:attribute-set : child of unexpected type\n");
429 	} else if (!IS_XSLT_NAME(child, "attribute")) {
430 	    xsltTransformError(NULL, style, child,
431 		"xsl:attribute-set : unexpected child xsl:%s\n",
432 		child->name);
433 	} else {
434 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
435 	    xsltGenericDebug(xsltGenericDebugContext,
436 		"add attribute to list %s\n", ncname);
437 #endif
438             xsltStylePreCompute(style, child);
439             if (child->children != NULL) {
440 #ifdef XSLT_REFACTORED
441                 xsltParseSequenceConstructor(XSLT_CCTXT(style),
442                                              child->children);
443 #else
444                 xsltParseTemplateContent(style, child);
445 #endif
446             }
447             if (child->psvi == NULL) {
448                 xsltTransformError(NULL, style, child,
449                     "xsl:attribute-set : internal error, attribute %s not "
450                     "compiled\n", child->name);
451             }
452             else {
453 	        set->attrs = xsltAddAttrElemList(set->attrs, child);
454             }
455 	}
456 
457 	child = child->next;
458     }
459 
460     /*
461     * Process attribute "use-attribute-sets".
462     */
463     value = xmlGetNsProp(cur, BAD_CAST "use-attribute-sets", NULL);
464     if (value != NULL) {
465 	const xmlChar *curval, *endval;
466 	curval = value;
467 	while (*curval != 0) {
468 	    while (IS_BLANK(*curval)) curval++;
469 	    if (*curval == 0)
470 		break;
471 	    endval = curval;
472 	    while ((*endval != 0) && (!IS_BLANK(*endval))) endval++;
473 	    curval = xmlDictLookup(style->dict, curval, endval - curval);
474 	    if (curval) {
475 		const xmlChar *ncname2 = NULL;
476 		const xmlChar *prefix2 = NULL;
477                 const xmlChar *nsUri2 = NULL;
478 
479 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
480 		xsltGenericDebug(xsltGenericDebugContext,
481 		    "xsl:attribute-set : %s adds use %s\n", ncname, curval);
482 #endif
483 
484                 if (xmlValidateQName(curval, 0)) {
485                     xsltTransformError(NULL, style, cur,
486                         "xsl:attribute-set : The name '%s' in "
487                         "use-attribute-sets is not a valid QName.\n", curval);
488                     style->errors++;
489                     xmlFree(value);
490                     return;
491                 }
492 
493 		ncname2 = xsltSplitQName(style->dict, curval, &prefix2);
494                 if (prefix2 != NULL) {
495                     xmlNsPtr ns2 = xmlSearchNs(style->doc, cur, prefix2);
496                     if (ns2 == NULL) {
497                         xsltTransformError(NULL, style, cur,
498                             "xsl:attribute-set : No namespace found for QName "
499                             "'%s:%s' in use-attribute-sets\n",
500                             prefix2, ncname2);
501                         style->errors++;
502                         xmlFree(value);
503                         return;
504                     }
505                     nsUri2 = ns2->href;
506                 }
507                 set->useAttrSets = xsltAddUseAttrSetList(set->useAttrSets,
508                                                          ncname2, nsUri2);
509 	    }
510 	    curval = endval;
511 	}
512 	xmlFree(value);
513 	value = NULL;
514     }
515 
516 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
517     xsltGenericDebug(xsltGenericDebugContext,
518 	"updated attribute list %s\n", ncname);
519 #endif
520 }
521 
522 /**
523  * xsltResolveUseAttrSets:
524  * @set: the attribute set
525  * @asctx:  the context for attribute set resolution
526  * @depth: recursion depth
527  *
528  * Process "use-attribute-sets".
529  */
530 static void
531 xsltResolveUseAttrSets(xsltAttrSetPtr set, xsltStylesheetPtr topStyle,
532 		       int depth) {
533     xsltStylesheetPtr cur;
534     xsltAttrSetPtr other;
535     xsltUseAttrSetPtr use = set->useAttrSets;
536     xsltUseAttrSetPtr next;
537 
538     while (use != NULL) {
539         /*
540          * Iterate top stylesheet and all imports.
541          */
542         cur = topStyle;
543         while (cur != NULL) {
544             if (cur->attributeSets) {
545                 other = xmlHashLookup2(cur->attributeSets, use->ncname,
546                                        use->ns);
547                 if (other != NULL) {
548                     xsltResolveAttrSet(other, topStyle, cur, use->ncname,
549                                        use->ns, depth + 1);
550                     xsltMergeAttrSets(set, other);
551                     break;
552                 }
553             }
554             cur = xsltNextImport(cur);
555         }
556 
557         next = use->next;
558         /* Free useAttrSets early. */
559         xsltFreeUseAttrSet(use);
560         use = next;
561     }
562 
563     set->useAttrSets = NULL;
564 }
565 
566 /**
567  * xsltResolveAttrSet:
568  * @set: the attribute set
569  * @asctx:  the context for attribute set resolution
570  * @name: the local name of the attirbute set
571  * @ns: the namespace of the attribute set
572  * @depth: recursion depth
573  *
574  * resolve the references in an attribute set.
575  */
576 static void
577 xsltResolveAttrSet(xsltAttrSetPtr set, xsltStylesheetPtr topStyle,
578                    xsltStylesheetPtr style, const xmlChar *name,
579                    const xmlChar *ns, int depth) {
580     xsltStylesheetPtr cur;
581     xsltAttrSetPtr other;
582 
583     if (set->state == ATTRSET_RESOLVED)
584         return;
585     if (set->state == ATTRSET_RESOLVING) {
586 	xsltTransformError(NULL, topStyle, NULL,
587             "xsl:attribute-set : use-attribute-sets recursion detected"
588             " on %s\n", name);
589         topStyle->errors++;
590         set->state = ATTRSET_RESOLVED;
591         return;
592     }
593     if (depth > 100) {
594 	xsltTransformError(NULL, topStyle, NULL,
595 		"xsl:attribute-set : use-attribute-sets maximum recursion "
596 		"depth exceeded on %s\n", name);
597         topStyle->errors++;
598 	return;
599     }
600 
601     set->state = ATTRSET_RESOLVING;
602 
603     xsltResolveUseAttrSets(set, topStyle, depth);
604 
605     /* Merge imported sets. */
606     cur = xsltNextImport(style);
607     while (cur != NULL) {
608         if (cur->attributeSets != NULL) {
609             other = xmlHashLookup2(cur->attributeSets, name, ns);
610 
611             if (other != NULL) {
612 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
613                 xsltGenericDebug(xsltGenericDebugContext,
614                     "xsl:attribute-set : merging import for %s\n", name);
615 #endif
616                 xsltResolveUseAttrSets(other, topStyle, depth);
617                 xsltMergeAttrSets(set, other);
618                 xmlHashRemoveEntry2(cur->attributeSets, name, ns, NULL);
619                 xsltFreeAttrSet(other);
620             }
621         }
622 
623         cur = xsltNextImport(cur);
624     }
625 
626     set->state = ATTRSET_RESOLVED;
627 }
628 
629 /**
630  * xsltResolveSASCallback:
631  * @set: the attribute set
632  * @asctx:  the context for attribute set resolution
633  * @name: the local name of the attirbute set
634  * @ns: the namespace of the attribute set
635  *
636  * resolve the references in an attribute set.
637  */
638 static void
639 xsltResolveSASCallback(xsltAttrSetPtr set, xsltAttrSetContextPtr asctx,
640 	               const xmlChar *name, const xmlChar *ns,
641 		       ATTRIBUTE_UNUSED const xmlChar *ignored) {
642     xsltStylesheetPtr topStyle = asctx->topStyle;
643     xsltStylesheetPtr style = asctx->style;
644 
645     xsltResolveAttrSet(set, topStyle, style, name, ns, 1);
646 
647     /* Move attribute sets to top stylesheet. */
648     if (style != topStyle) {
649         /*
650          * This imported stylesheet won't be visited anymore. Don't bother
651          * removing the hash entry.
652          */
653         if (xmlHashAddEntry2(topStyle->attributeSets, name, ns, set) < 0) {
654 	    xsltGenericError(xsltGenericErrorContext,
655                 "xsl:attribute-set : internal error, can't move imported "
656                 " attribute set %s\n", name);
657         }
658     }
659 }
660 
661 /**
662  * xsltResolveStylesheetAttributeSet:
663  * @style:  the XSLT stylesheet
664  *
665  * resolve the references between attribute sets.
666  */
667 void
668 xsltResolveStylesheetAttributeSet(xsltStylesheetPtr style) {
669     xsltStylesheetPtr cur;
670     xsltAttrSetContext asctx;
671 
672 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
673     xsltGenericDebug(xsltGenericDebugContext,
674 	    "Resolving attribute sets references\n");
675 #endif
676     asctx.topStyle = style;
677     cur = style;
678     while (cur != NULL) {
679 	if (cur->attributeSets != NULL) {
680 	    if (style->attributeSets == NULL) {
681 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
682 		xsltGenericDebug(xsltGenericDebugContext,
683 		    "creating attribute set table\n");
684 #endif
685 		style->attributeSets = xmlHashCreate(10);
686 	    }
687             asctx.style = cur;
688 	    xmlHashScanFull(cur->attributeSets,
689 		(xmlHashScannerFull) xsltResolveSASCallback, &asctx);
690 
691             if (cur != style) {
692                 /*
693                  * the attribute lists have either been migrated to style
694                  * or freed directly in xsltResolveSASCallback()
695                  */
696                 xmlHashFree(cur->attributeSets, NULL);
697                 cur->attributeSets = NULL;
698             }
699 	}
700 	cur = xsltNextImport(cur);
701     }
702 }
703 
704 /**
705  * xsltAttribute:
706  * @ctxt:  a XSLT process context
707  * @contextNode:  the current node in the source tree
708  * @inst:  the xsl:attribute element
709  * @castedComp:  precomputed information
710  *
711  * Process the xslt attribute node on the source node
712  */
713 void
714 xsltAttribute(xsltTransformContextPtr ctxt,
715 	      xmlNodePtr contextNode,
716               xmlNodePtr inst,
717 	      xsltStylePreCompPtr castedComp)
718 {
719 #ifdef XSLT_REFACTORED
720     xsltStyleItemAttributePtr comp =
721 	(xsltStyleItemAttributePtr) castedComp;
722 #else
723     xsltStylePreCompPtr comp = castedComp;
724 #endif
725     xmlNodePtr targetElem;
726     xmlChar *prop = NULL;
727     const xmlChar *name = NULL, *prefix = NULL, *nsName = NULL;
728     xmlChar *value = NULL;
729     xmlNsPtr ns = NULL;
730     xmlAttrPtr attr;
731 
732     if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL) ||
733         (inst->type != XML_ELEMENT_NODE) )
734         return;
735 
736     /*
737     * A comp->has_name == 0 indicates that we need to skip this instruction,
738     * since it was evaluated to be invalid already during compilation.
739     */
740     if (!comp->has_name)
741         return;
742     /*
743     * BIG NOTE: This previously used xsltGetSpecialNamespace() and
744     *  xsltGetNamespace(), but since both are not appropriate, we
745     *  will process namespace lookup here to avoid adding yet another
746     *  ns-lookup function to namespaces.c.
747     */
748     /*
749     * SPEC XSLT 1.0: Error cases:
750     * - Creating nodes other than text nodes during the instantiation of
751     *   the content of the xsl:attribute element; implementations may
752     *   either signal the error or ignore the offending nodes."
753     */
754 
755     if (comp == NULL) {
756         xsltTransformError(ctxt, NULL, inst,
757 	    "Internal error in xsltAttribute(): "
758 	    "The XSLT 'attribute' instruction was not compiled.\n");
759         return;
760     }
761     /*
762     * TODO: Shouldn't ctxt->insert == NULL be treated as an internal error?
763     *   So report an internal error?
764     */
765     if (ctxt->insert == NULL)
766         return;
767     /*
768     * SPEC XSLT 1.0:
769     *  "Adding an attribute to a node that is not an element;
770     *  implementations may either signal the error or ignore the attribute."
771     *
772     * TODO: I think we should signal such errors in the future, and maybe
773     *  provide an option to ignore such errors.
774     */
775     targetElem = ctxt->insert;
776     if (targetElem->type != XML_ELEMENT_NODE)
777 	return;
778 
779     /*
780     * SPEC XSLT 1.0:
781     * "Adding an attribute to an element after children have been added
782     *  to it; implementations may either signal the error or ignore the
783     *  attribute."
784     *
785     * TODO: We should decide whether not to report such errors or
786     *  to ignore them; note that we *ignore* if the parent is not an
787     *  element, but here we report an error.
788     */
789     if (targetElem->children != NULL) {
790 	/*
791 	* NOTE: Ah! This seems to be intended to support streamed
792 	*  result generation!.
793 	*/
794         xsltTransformError(ctxt, NULL, inst,
795 	    "xsl:attribute: Cannot add attributes to an "
796 	    "element if children have been already added "
797 	    "to the element.\n");
798         return;
799     }
800 
801     /*
802     * Process the name
803     * ----------------
804     */
805 
806 #ifdef WITH_DEBUGGER
807     if (ctxt->debugStatus != XSLT_DEBUG_NONE)
808         xslHandleDebugger(inst, contextNode, NULL, ctxt);
809 #endif
810 
811     if (comp->name == NULL) {
812 	/* TODO: fix attr acquisition wrt to the XSLT namespace */
813         prop = xsltEvalAttrValueTemplate(ctxt, inst,
814 	    (const xmlChar *) "name", XSLT_NAMESPACE);
815         if (prop == NULL) {
816             xsltTransformError(ctxt, NULL, inst,
817 		"xsl:attribute: The attribute 'name' is missing.\n");
818             goto error;
819         }
820 	if (xmlValidateQName(prop, 0)) {
821 	    xsltTransformError(ctxt, NULL, inst,
822 		"xsl:attribute: The effective name '%s' is not a "
823 		"valid QName.\n", prop);
824 	    /* we fall through to catch any further errors, if possible */
825 	}
826 
827 	/*
828 	* Reject a name of "xmlns".
829 	*/
830 	if (xmlStrEqual(prop, BAD_CAST "xmlns")) {
831             xsltTransformError(ctxt, NULL, inst,
832                 "xsl:attribute: The effective name 'xmlns' is not allowed.\n");
833 	    xmlFree(prop);
834 	    goto error;
835 	}
836 
837 	name = xsltSplitQName(ctxt->dict, prop, &prefix);
838 	xmlFree(prop);
839     } else {
840 	/*
841 	* The "name" value was static.
842 	*/
843 #ifdef XSLT_REFACTORED
844 	prefix = comp->nsPrefix;
845 	name = comp->name;
846 #else
847 	name = xsltSplitQName(ctxt->dict, comp->name, &prefix);
848 #endif
849     }
850 
851     /*
852     * Process namespace semantics
853     * ---------------------------
854     *
855     * Evaluate the namespace name.
856     */
857     if (comp->has_ns) {
858 	/*
859 	* The "namespace" attribute was existent.
860 	*/
861 	if (comp->ns != NULL) {
862 	    /*
863 	    * No AVT; just plain text for the namespace name.
864 	    */
865 	    if (comp->ns[0] != 0)
866 		nsName = comp->ns;
867 	} else {
868 	    xmlChar *tmpNsName;
869 	    /*
870 	    * Eval the AVT.
871 	    */
872 	    /* TODO: check attr acquisition wrt to the XSLT namespace */
873 	    tmpNsName = xsltEvalAttrValueTemplate(ctxt, inst,
874 		(const xmlChar *) "namespace", XSLT_NAMESPACE);
875 	    /*
876 	    * This fixes bug #302020: The AVT might also evaluate to the
877 	    * empty string; this means that the empty string also indicates
878 	    * "no namespace".
879 	    * SPEC XSLT 1.0:
880 	    *  "If the string is empty, then the expanded-name of the
881 	    *  attribute has a null namespace URI."
882 	    */
883 	    if ((tmpNsName != NULL) && (tmpNsName[0] != 0))
884 		nsName = xmlDictLookup(ctxt->dict, BAD_CAST tmpNsName, -1);
885 	    xmlFree(tmpNsName);
886 	}
887 
888         if (xmlStrEqual(nsName, BAD_CAST "http://www.w3.org/2000/xmlns/")) {
889             xsltTransformError(ctxt, NULL, inst,
890                 "xsl:attribute: Namespace http://www.w3.org/2000/xmlns/ "
891                 "forbidden.\n");
892             goto error;
893         }
894         if (xmlStrEqual(nsName, XML_XML_NAMESPACE)) {
895             prefix = BAD_CAST "xml";
896         } else if (xmlStrEqual(prefix, BAD_CAST "xml")) {
897             prefix = NULL;
898         }
899     } else if (prefix != NULL) {
900 	/*
901 	* SPEC XSLT 1.0:
902 	*  "If the namespace attribute is not present, then the QName is
903 	*  expanded into an expanded-name using the namespace declarations
904 	*  in effect for the xsl:attribute element, *not* including any
905 	*  default namespace declaration."
906 	*/
907 	ns = xmlSearchNs(inst->doc, inst, prefix);
908 	if (ns == NULL) {
909 	    /*
910 	    * Note that this is treated as an error now (checked with
911 	    *  Saxon, Xalan-J and MSXML).
912 	    */
913 	    xsltTransformError(ctxt, NULL, inst,
914 		"xsl:attribute: The QName '%s:%s' has no "
915 		"namespace binding in scope in the stylesheet; "
916 		"this is an error, since the namespace was not "
917 		"specified by the instruction itself.\n", prefix, name);
918 	} else
919 	    nsName = ns->href;
920     }
921 
922     /*
923     * Find/create a matching ns-decl in the result tree.
924     */
925     ns = NULL;
926 
927 #if 0
928     if (0) {
929 	/*
930 	* OPTIMIZE TODO: How do we know if we are adding to a
931 	*  fragment or to the result tree?
932 	*
933 	* If we are adding to a result tree fragment (i.e., not to the
934 	* actual result tree), we'll don't bother searching for the
935 	* ns-decl, but just store it in the dummy-doc of the result
936 	* tree fragment.
937 	*/
938 	if (nsName != NULL) {
939 	    /*
940 	    * TODO: Get the doc of @targetElem.
941 	    */
942 	    ns = xsltTreeAcquireStoredNs(some doc, nsName, prefix);
943 	}
944     }
945 #endif
946 
947     if (nsName != NULL) {
948 	/*
949 	* Something about ns-prefixes:
950 	* SPEC XSLT 1.0:
951 	*  "XSLT processors may make use of the prefix of the QName specified
952 	*  in the name attribute when selecting the prefix used for outputting
953 	*  the created attribute as XML; however, they are not required to do
954 	*  so and, if the prefix is xmlns, they must not do so"
955 	*/
956 	/*
957 	* xsl:attribute can produce a scenario where the prefix is NULL,
958 	* so generate a prefix.
959 	*/
960 	if ((prefix == NULL) || xmlStrEqual(prefix, BAD_CAST "xmlns")) {
961 	    xmlChar *pref = xmlStrdup(BAD_CAST "ns_1");
962 
963 	    ns = xsltGetSpecialNamespace(ctxt, inst, nsName, pref, targetElem);
964 
965 	    xmlFree(pref);
966 	} else {
967 	    ns = xsltGetSpecialNamespace(ctxt, inst, nsName, prefix,
968 		targetElem);
969 	}
970 	if (ns == NULL) {
971 	    xsltTransformError(ctxt, NULL, inst,
972 		"Namespace fixup error: Failed to acquire an in-scope "
973 		"namespace binding for the generated attribute '{%s}%s'.\n",
974 		nsName, name);
975 	    goto error;
976 	}
977     }
978     /*
979     * Construction of the value
980     * -------------------------
981     */
982     if (inst->children == NULL) {
983 	/*
984 	* No content.
985 	* TODO: Do we need to put the empty string in ?
986 	*/
987 	attr = xmlSetNsProp(ctxt->insert, ns, name, (const xmlChar *) "");
988     } else if ((inst->children->next == NULL) &&
989 	    ((inst->children->type == XML_TEXT_NODE) ||
990 	     (inst->children->type == XML_CDATA_SECTION_NODE)))
991     {
992 	xmlNodePtr copyTxt;
993 
994 	/*
995 	* xmlSetNsProp() will take care of duplicates.
996 	*/
997 	attr = xmlSetNsProp(ctxt->insert, ns, name, NULL);
998 	if (attr == NULL) /* TODO: report error ? */
999 	    goto error;
1000 	/*
1001 	* This was taken over from xsltCopyText() (transform.c).
1002 	*/
1003 	if (ctxt->internalized &&
1004 	    (ctxt->insert->doc != NULL) &&
1005 	    (ctxt->insert->doc->dict == ctxt->dict))
1006 	{
1007 	    copyTxt = xmlNewText(NULL);
1008 	    if (copyTxt == NULL) /* TODO: report error */
1009 		goto error;
1010 	    /*
1011 	    * This is a safe scenario where we don't need to lookup
1012 	    * the dict.
1013 	    */
1014 	    copyTxt->content = inst->children->content;
1015 	    /*
1016 	    * Copy "disable-output-escaping" information.
1017 	    * TODO: Does this have any effect for attribute values
1018 	    *  anyway?
1019 	    */
1020 	    if (inst->children->name == xmlStringTextNoenc)
1021 		copyTxt->name = xmlStringTextNoenc;
1022 	} else {
1023 	    /*
1024 	    * Copy the value.
1025 	    */
1026 	    copyTxt = xmlNewText(inst->children->content);
1027 	    if (copyTxt == NULL) /* TODO: report error */
1028 		goto error;
1029 	}
1030 	attr->children = attr->last = copyTxt;
1031 	copyTxt->parent = (xmlNodePtr) attr;
1032 	copyTxt->doc = attr->doc;
1033 	/*
1034 	* Copy "disable-output-escaping" information.
1035 	* TODO: Does this have any effect for attribute values
1036 	*  anyway?
1037 	*/
1038 	if (inst->children->name == xmlStringTextNoenc)
1039 	    copyTxt->name = xmlStringTextNoenc;
1040 
1041         /*
1042          * since we create the attribute without content IDness must be
1043          * asserted as a second step
1044          */
1045         if ((copyTxt->content != NULL) &&
1046             (xmlIsID(attr->doc, attr->parent, attr)))
1047             xmlAddID(NULL, attr->doc, copyTxt->content, attr);
1048     } else {
1049 	/*
1050 	* The sequence constructor might be complex, so instantiate it.
1051 	*/
1052 	value = xsltEvalTemplateString(ctxt, contextNode, inst);
1053 	if (value != NULL) {
1054 	    attr = xmlSetNsProp(ctxt->insert, ns, name, value);
1055 	    xmlFree(value);
1056 	} else {
1057 	    /*
1058 	    * TODO: Do we have to add the empty string to the attr?
1059 	    * TODO: Does a  value of NULL indicate an
1060 	    *  error in xsltEvalTemplateString() ?
1061 	    */
1062 	    attr = xmlSetNsProp(ctxt->insert, ns, name,
1063 		(const xmlChar *) "");
1064 	}
1065     }
1066 
1067 error:
1068     return;
1069 }
1070 
1071 /**
1072  * xsltApplyAttributeSet:
1073  * @ctxt:  the XSLT stylesheet
1074  * @node:  the node in the source tree.
1075  * @inst:  the attribute node "xsl:use-attribute-sets"
1076  * @attrSets:  the list of QNames of the attribute-sets to be applied
1077  *
1078  * Apply the xsl:use-attribute-sets.
1079  * If @attrSets is NULL, then @inst will be used to exctract this
1080  * value.
1081  * If both, @attrSets and @inst, are NULL, then this will do nothing.
1082  */
1083 void
1084 xsltApplyAttributeSet(xsltTransformContextPtr ctxt, xmlNodePtr node,
1085                       xmlNodePtr inst,
1086                       const xmlChar *attrSets)
1087 {
1088     const xmlChar *ncname = NULL;
1089     const xmlChar *prefix = NULL;
1090     const xmlChar *curstr, *endstr;
1091     xsltAttrSetPtr set;
1092     xsltStylesheetPtr style;
1093 
1094     if (attrSets == NULL) {
1095 	if (inst == NULL)
1096 	    return;
1097 	else {
1098 	    /*
1099 	    * Extract the value from @inst.
1100 	    */
1101 	    if (inst->type == XML_ATTRIBUTE_NODE) {
1102 		if ( ((xmlAttrPtr) inst)->children != NULL)
1103 		    attrSets = ((xmlAttrPtr) inst)->children->content;
1104 
1105 	    }
1106 	    if (attrSets == NULL) {
1107 		/*
1108 		* TODO: Return an error?
1109 		*/
1110 		return;
1111 	    }
1112 	}
1113     }
1114     /*
1115     * Parse/apply the list of QNames.
1116     */
1117     curstr = attrSets;
1118     while (*curstr != 0) {
1119         while (IS_BLANK(*curstr))
1120             curstr++;
1121         if (*curstr == 0)
1122             break;
1123         endstr = curstr;
1124         while ((*endstr != 0) && (!IS_BLANK(*endstr)))
1125             endstr++;
1126         curstr = xmlDictLookup(ctxt->dict, curstr, endstr - curstr);
1127         if (curstr) {
1128             xmlNsPtr ns;
1129             const xmlChar *nsUri = NULL;
1130 
1131 #ifdef WITH_XSLT_DEBUG_ATTRIBUTES
1132             xsltGenericDebug(xsltGenericDebugContext,
1133                              "apply attribute set %s\n", curstr);
1134 #endif
1135 
1136             if (xmlValidateQName(curstr, 0)) {
1137                 xsltTransformError(ctxt, NULL, inst,
1138                     "The name '%s' in use-attribute-sets is not a valid "
1139                     "QName.\n", curstr);
1140                 return;
1141             }
1142 
1143             ncname = xsltSplitQName(ctxt->dict, curstr, &prefix);
1144             if (prefix != NULL) {
1145 	        ns = xmlSearchNs(inst->doc, inst, prefix);
1146                 if (ns == NULL) {
1147                     xsltTransformError(ctxt, NULL, inst,
1148                         "use-attribute-set : No namespace found for QName "
1149                         "'%s:%s'\n", prefix, ncname);
1150                     return;
1151                 }
1152                 nsUri = ns->href;
1153             }
1154 
1155             style = ctxt->style;
1156 
1157 #ifdef WITH_DEBUGGER
1158             if ((style != NULL) &&
1159 		(style->attributeSets != NULL) &&
1160 		(ctxt->debugStatus != XSLT_DEBUG_NONE))
1161 	    {
1162                 set = xmlHashLookup2(style->attributeSets, ncname, nsUri);
1163                 if ((set != NULL) && (set->attrs != NULL) &&
1164                     (set->attrs->attr != NULL))
1165                     xslHandleDebugger(set->attrs->attr->parent, node, NULL,
1166 			ctxt);
1167             }
1168 #endif
1169 	    /*
1170 	    * Lookup the referenced attribute-set. All attribute sets were
1171             * moved to the top stylesheet so there's no need to iterate
1172             * imported stylesheets
1173 	    */
1174             set = xmlHashLookup2(style->attributeSets, ncname, nsUri);
1175             if (set != NULL) {
1176                 xsltAttrElemPtr cur = set->attrs;
1177                 while (cur != NULL) {
1178                     if (cur->attr != NULL) {
1179                         xsltAttribute(ctxt, node, cur->attr,
1180                             cur->attr->psvi);
1181                     }
1182                     cur = cur->next;
1183                 }
1184             }
1185         }
1186         curstr = endstr;
1187     }
1188 }
1189 
1190 /**
1191  * xsltFreeAttributeSetsHashes:
1192  * @style: an XSLT stylesheet
1193  *
1194  * Free up the memory used by attribute sets
1195  */
1196 void
1197 xsltFreeAttributeSetsHashes(xsltStylesheetPtr style) {
1198     if (style->attributeSets != NULL)
1199 	xmlHashFree((xmlHashTablePtr) style->attributeSets,
1200 		    (xmlHashDeallocator) xsltFreeAttrSet);
1201     style->attributeSets = NULL;
1202 }
1203