1 /*
2 * xslt.c: Implemetation of an XSL Transformation 1.0 engine
3 *
4 * Reference:
5 * XSLT specification
6 * http://www.w3.org/TR/1999/REC-xslt-19991116
7 *
8 * Associating Style Sheets with XML documents
9 * http://www.w3.org/1999/06/REC-xml-stylesheet-19990629
10 *
11 * See Copyright for the status of this software.
12 *
13 * daniel@veillard.com
14 */
15
16 #define IN_LIBXSLT
17 #include "libxslt.h"
18
19 #include <string.h>
20
21 #include <libxml/xmlmemory.h>
22 #include <libxml/parser.h>
23 #include <libxml/tree.h>
24 #include <libxml/valid.h>
25 #include <libxml/hash.h>
26 #include <libxml/uri.h>
27 #include <libxml/xmlerror.h>
28 #include <libxml/parserInternals.h>
29 #include <libxml/xpathInternals.h>
30 #include <libxml/xpath.h>
31 #include "xslt.h"
32 #include "xsltInternals.h"
33 #include "pattern.h"
34 #include "variables.h"
35 #include "namespaces.h"
36 #include "attributes.h"
37 #include "xsltutils.h"
38 #include "imports.h"
39 #include "keys.h"
40 #include "documents.h"
41 #include "extensions.h"
42 #include "preproc.h"
43 #include "extra.h"
44 #include "security.h"
45 #include "xsltlocale.h"
46
47 #ifdef WITH_XSLT_DEBUG
48 #define WITH_XSLT_DEBUG_PARSING
49 /* #define WITH_XSLT_DEBUG_BLANKS */
50 #endif
51
52 const char *xsltEngineVersion = LIBXSLT_VERSION_STRING LIBXSLT_VERSION_EXTRA;
53 const int xsltLibxsltVersion = LIBXSLT_VERSION;
54 const int xsltLibxmlVersion = LIBXML_VERSION;
55
56 #ifdef XSLT_REFACTORED
57
58 const xmlChar *xsltConstNamespaceNameXSLT = (const xmlChar *) XSLT_NAMESPACE;
59
60 #define XSLT_ELEMENT_CATEGORY_XSLT 0
61 #define XSLT_ELEMENT_CATEGORY_EXTENSION 1
62 #define XSLT_ELEMENT_CATEGORY_LRE 2
63
64 /*
65 * xsltLiteralResultMarker:
66 * Marker for Literal result elements, in order to avoid multiple attempts
67 * to recognize such elements in the stylesheet's tree.
68 * This marker is set on node->psvi during the initial traversal
69 * of a stylesheet's node tree.
70 *
71 const xmlChar *xsltLiteralResultMarker =
72 (const xmlChar *) "Literal Result Element";
73 */
74
75 /*
76 * xsltXSLTTextMarker:
77 * Marker for xsl:text elements. Used to recognize xsl:text elements
78 * for post-processing of the stylesheet's tree, where those
79 * elements are removed from the tree.
80 */
81 const xmlChar *xsltXSLTTextMarker = (const xmlChar *) "XSLT Text Element";
82
83 /*
84 * xsltXSLTAttrMarker:
85 * Marker for XSLT attribute on Literal Result Elements.
86 */
87 const xmlChar *xsltXSLTAttrMarker = (const xmlChar *) "LRE XSLT Attr";
88
89 #endif
90
91 #ifdef XSLT_LOCALE_WINAPI
92 extern xmlRMutexPtr xsltLocaleMutex;
93 #endif
94 /*
95 * Harmless but avoiding a problem when compiling against a
96 * libxml <= 2.3.11 without LIBXML_DEBUG_ENABLED
97 */
98 #ifndef LIBXML_DEBUG_ENABLED
99 double xmlXPathStringEvalNumber(const xmlChar *str);
100 #endif
101 /*
102 * Useful macros
103 */
104
105 #ifdef IS_BLANK
106 #undef IS_BLANK
107 #endif
108 #define IS_BLANK(c) (((c) == 0x20) || ((c) == 0x09) || ((c) == 0xA) || \
109 ((c) == 0x0D))
110
111 #ifdef IS_BLANK_NODE
112 #undef IS_BLANK_NODE
113 #endif
114 #define IS_BLANK_NODE(n) \
115 (((n)->type == XML_TEXT_NODE) && (xsltIsBlank((n)->content)))
116
117 /**
118 * xsltParseContentError:
119 *
120 * @style: the stylesheet
121 * @node: the node where the error occured
122 *
123 * Compile-time error function.
124 */
125 static void
126 xsltParseContentError(xsltStylesheetPtr style,
127 xmlNodePtr node)
128 {
129 if ((style == NULL) || (node == NULL))
130 return;
131
132 if (IS_XSLT_ELEM(node))
133 xsltTransformError(NULL, style, node,
134 "The XSLT-element '%s' is not allowed at this position.\n",
135 node->name);
136 else
137 xsltTransformError(NULL, style, node,
138 "The element '%s' is not allowed at this position.\n",
139 node->name);
140 style->errors++;
141 }
142
143 #ifdef XSLT_REFACTORED
144 #else
145 /**
146 * exclPrefixPush:
147 * @style: the transformation stylesheet
148 * @value: the excluded namespace name to push on the stack
149 *
150 * Push an excluded namespace name on the stack
151 *
152 * Returns the new index in the stack or -1 if already present or
153 * in case of error
154 */
155 static int
156 exclPrefixPush(xsltStylesheetPtr style, xmlChar * value)
157 {
158 int i;
159
160 if (style->exclPrefixMax == 0) {
161 style->exclPrefixMax = 4;
162 style->exclPrefixTab =
163 (xmlChar * *)xmlMalloc(style->exclPrefixMax *
164 sizeof(style->exclPrefixTab[0]));
165 if (style->exclPrefixTab == NULL) {
166 xmlGenericError(xmlGenericErrorContext, "malloc failed !\n");
167 return (-1);
168 }
169 }
170 /* do not push duplicates */
171 for (i = 0;i < style->exclPrefixNr;i++) {
172 if (xmlStrEqual(style->exclPrefixTab[i], value))
173 return(-1);
174 }
175 if (style->exclPrefixNr >= style->exclPrefixMax) {
176 style->exclPrefixMax *= 2;
177 style->exclPrefixTab =
178 (xmlChar * *)xmlRealloc(style->exclPrefixTab,
179 style->exclPrefixMax *
180 sizeof(style->exclPrefixTab[0]));
181 if (style->exclPrefixTab == NULL) {
182 xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
183 return (-1);
184 }
185 }
186 style->exclPrefixTab[style->exclPrefixNr] = value;
187 style->exclPrefix = value;
188 return (style->exclPrefixNr++);
189 }
190 /**
191 * exclPrefixPop:
192 * @style: the transformation stylesheet
193 *
194 * Pop an excluded prefix value from the stack
195 *
196 * Returns the stored excluded prefix value
197 */
198 static xmlChar *
199 exclPrefixPop(xsltStylesheetPtr style)
200 {
201 xmlChar *ret;
202
203 if (style->exclPrefixNr <= 0)
204 return (0);
205 style->exclPrefixNr--;
206 if (style->exclPrefixNr > 0)
207 style->exclPrefix = style->exclPrefixTab[style->exclPrefixNr - 1];
208 else
209 style->exclPrefix = NULL;
210 ret = style->exclPrefixTab[style->exclPrefixNr];
211 style->exclPrefixTab[style->exclPrefixNr] = 0;
212 return (ret);
213 }
214 #endif
215
216 /************************************************************************
217 * *
218 * Helper functions *
219 * *
220 ************************************************************************/
221
222 static int initialized = 0;
223 /**
224 * xsltInit:
225 *
226 * Initializes the processor (e.g. registers built-in extensions,
227 * etc.)
228 */
229 void
230 xsltInit (void) {
231 if (initialized == 0) {
232 initialized = 1;
233 #ifdef XSLT_LOCALE_WINAPI
234 xsltLocaleMutex = xmlNewRMutex();
235 #endif
236 xsltRegisterAllExtras();
237 }
238 }
239
240 /**
241 * xsltUninit:
242 *
243 * Uninitializes the processor.
244 */
245 void
246 xsltUninit (void) {
247 #ifdef XSLT_LOCALE_WINAPI
248 xmlFreeRMutex(xsltLocaleMutex);
249 xsltLocaleMutex = NULL;
250 #endif
251 initialized = 0;
252 }
253
254 /**
255 * xsltIsBlank:
256 * @str: a string
257 *
258 * Check if a string is ignorable
259 *
260 * Returns 1 if the string is NULL or made of blanks chars, 0 otherwise
261 */
262 int
263 xsltIsBlank(xmlChar *str) {
264 if (str == NULL)
265 return(1);
266 while (*str != 0) {
267 if (!(IS_BLANK(*str))) return(0);
268 str++;
269 }
270 return(1);
271 }
272
273 /************************************************************************
274 * *
275 * Routines to handle XSLT data structures *
276 * *
277 ************************************************************************/
278 static xsltDecimalFormatPtr
279 xsltNewDecimalFormat(const xmlChar *nsUri, xmlChar *name)
280 {
281 xsltDecimalFormatPtr self;
282 /* UTF-8 for 0x2030 */
283 static const xmlChar permille[4] = {0xe2, 0x80, 0xb0, 0};
284
285 self = xmlMalloc(sizeof(xsltDecimalFormat));
286 if (self != NULL) {
287 self->next = NULL;
288 self->nsUri = nsUri;
289 self->name = name;
290
291 /* Default values */
292 self->digit = xmlStrdup(BAD_CAST("#"));
293 self->patternSeparator = xmlStrdup(BAD_CAST(";"));
294 self->decimalPoint = xmlStrdup(BAD_CAST("."));
295 self->grouping = xmlStrdup(BAD_CAST(","));
296 self->percent = xmlStrdup(BAD_CAST("%"));
297 self->permille = xmlStrdup(BAD_CAST(permille));
298 self->zeroDigit = xmlStrdup(BAD_CAST("0"));
299 self->minusSign = xmlStrdup(BAD_CAST("-"));
300 self->infinity = xmlStrdup(BAD_CAST("Infinity"));
301 self->noNumber = xmlStrdup(BAD_CAST("NaN"));
302 }
303 return self;
304 }
305
306 static void
307 xsltFreeDecimalFormat(xsltDecimalFormatPtr self)
308 {
309 if (self != NULL) {
310 if (self->digit)
311 xmlFree(self->digit);
312 if (self->patternSeparator)
313 xmlFree(self->patternSeparator);
314 if (self->decimalPoint)
315 xmlFree(self->decimalPoint);
316 if (self->grouping)
317 xmlFree(self->grouping);
318 if (self->percent)
319 xmlFree(self->percent);
320 if (self->permille)
321 xmlFree(self->permille);
322 if (self->zeroDigit)
323 xmlFree(self->zeroDigit);
324 if (self->minusSign)
325 xmlFree(self->minusSign);
326 if (self->infinity)
327 xmlFree(self->infinity);
328 if (self->noNumber)
329 xmlFree(self->noNumber);
330 if (self->name)
331 xmlFree(self->name);
332 xmlFree(self);
333 }
334 }
335
336 static void
337 xsltFreeDecimalFormatList(xsltStylesheetPtr self)
338 {
339 xsltDecimalFormatPtr iter;
340 xsltDecimalFormatPtr tmp;
341
342 if (self == NULL)
343 return;
344
345 iter = self->decimalFormat;
346 while (iter != NULL) {
347 tmp = iter->next;
348 xsltFreeDecimalFormat(iter);
349 iter = tmp;
350 }
351 }
352
353 /**
354 * xsltDecimalFormatGetByName:
355 * @style: the XSLT stylesheet
356 * @name: the decimal-format name to find
357 *
358 * Find decimal-format by name
359 *
360 * Returns the xsltDecimalFormatPtr
361 */
362 xsltDecimalFormatPtr
363 xsltDecimalFormatGetByName(xsltStylesheetPtr style, xmlChar *name)
364 {
365 xsltDecimalFormatPtr result = NULL;
366
367 if (name == NULL)
368 return style->decimalFormat;
369
370 while (style != NULL) {
371 for (result = style->decimalFormat->next;
372 result != NULL;
373 result = result->next) {
374 if ((result->nsUri == NULL) && xmlStrEqual(name, result->name))
375 return result;
376 }
377 style = xsltNextImport(style);
378 }
379 return result;
380 }
381
382 /**
383 * xsltDecimalFormatGetByQName:
384 * @style: the XSLT stylesheet
385 * @nsUri: the namespace URI of the QName
386 * @name: the local part of the QName
387 *
388 * Find decimal-format by QName
389 *
390 * Returns the xsltDecimalFormatPtr
391 */
392 xsltDecimalFormatPtr
393 xsltDecimalFormatGetByQName(xsltStylesheetPtr style, const xmlChar *nsUri,
394 const xmlChar *name)
395 {
396 xsltDecimalFormatPtr result = NULL;
397
398 if (name == NULL)
399 return style->decimalFormat;
400
401 while (style != NULL) {
402 for (result = style->decimalFormat->next;
403 result != NULL;
404 result = result->next) {
405 if (xmlStrEqual(nsUri, result->nsUri) &&
406 xmlStrEqual(name, result->name))
407 return result;
408 }
409 style = xsltNextImport(style);
410 }
411 return result;
412 }
413
414
415 /**
416 * xsltNewTemplate:
417 *
418 * Create a new XSLT Template
419 *
420 * Returns the newly allocated xsltTemplatePtr or NULL in case of error
421 */
422 static xsltTemplatePtr
423 xsltNewTemplate(void) {
424 xsltTemplatePtr cur;
425
426 cur = (xsltTemplatePtr) xmlMalloc(sizeof(xsltTemplate));
427 if (cur == NULL) {
428 xsltTransformError(NULL, NULL, NULL,
429 "xsltNewTemplate : malloc failed\n");
430 return(NULL);
431 }
432 memset(cur, 0, sizeof(xsltTemplate));
433 cur->priority = XSLT_PAT_NO_PRIORITY;
434 return(cur);
435 }
436
437 /**
438 * xsltFreeTemplate:
439 * @template: an XSLT template
440 *
441 * Free up the memory allocated by @template
442 */
443 static void
444 xsltFreeTemplate(xsltTemplatePtr template) {
445 if (template == NULL)
446 return;
447 if (template->match) xmlFree(template->match);
448 /*
449 * NOTE: @name and @nameURI are put into the string dict now.
450 * if (template->name) xmlFree(template->name);
451 * if (template->nameURI) xmlFree(template->nameURI);
452 */
453 /*
454 if (template->mode) xmlFree(template->mode);
455 if (template->modeURI) xmlFree(template->modeURI);
456 */
457 if (template->inheritedNs) xmlFree(template->inheritedNs);
458
459 /* free profiling data */
460 if (template->templCalledTab) xmlFree(template->templCalledTab);
461 if (template->templCountTab) xmlFree(template->templCountTab);
462
463 memset(template, -1, sizeof(xsltTemplate));
464 xmlFree(template);
465 }
466
467 /**
468 * xsltFreeTemplateList:
469 * @template: an XSLT template list
470 *
471 * Free up the memory allocated by all the elements of @template
472 */
473 static void
474 xsltFreeTemplateList(xsltTemplatePtr template) {
475 xsltTemplatePtr cur;
476
477 while (template != NULL) {
478 cur = template;
479 template = template->next;
480 xsltFreeTemplate(cur);
481 }
482 }
483
484 #ifdef XSLT_REFACTORED
485
486 static void
487 xsltFreeNsAliasList(xsltNsAliasPtr item)
488 {
489 xsltNsAliasPtr tmp;
490
491 while (item) {
492 tmp = item;
493 item = item->next;
494 xmlFree(tmp);
495 }
496 return;
497 }
498
499 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
500 static void
501 xsltFreeNamespaceMap(xsltNsMapPtr item)
502 {
503 xsltNsMapPtr tmp;
504
505 while (item) {
506 tmp = item;
507 item = item->next;
508 xmlFree(tmp);
509 }
510 return;
511 }
512
513 static xsltNsMapPtr
514 xsltNewNamespaceMapItem(xsltCompilerCtxtPtr cctxt,
515 xmlDocPtr doc,
516 xmlNsPtr ns,
517 xmlNodePtr elem)
518 {
519 xsltNsMapPtr ret;
520
521 if ((cctxt == NULL) || (doc == NULL) || (ns == NULL))
522 return(NULL);
523
524 ret = (xsltNsMapPtr) xmlMalloc(sizeof(xsltNsMap));
525 if (ret == NULL) {
526 xsltTransformError(NULL, cctxt->style, elem,
527 "Internal error: (xsltNewNamespaceMapItem) "
528 "memory allocation failed.\n");
529 return(NULL);
530 }
531 memset(ret, 0, sizeof(xsltNsMap));
532 ret->doc = doc;
533 ret->ns = ns;
534 ret->origNsName = ns->href;
535 /*
536 * Store the item at current stylesheet-level.
537 */
538 if (cctxt->psData->nsMap != NULL)
539 ret->next = cctxt->psData->nsMap;
540 cctxt->psData->nsMap = ret;
541
542 return(ret);
543 }
544 #endif /* XSLT_REFACTORED_XSLT_NSCOMP */
545
546 /**
547 * xsltCompilerVarInfoFree:
548 * @cctxt: the compilation context
549 *
550 * Frees the list of information for vars/params.
551 */
552 static void
553 xsltCompilerVarInfoFree(xsltCompilerCtxtPtr cctxt)
554 {
555 xsltVarInfoPtr ivar = cctxt->ivars, ivartmp;
556
557 while (ivar) {
558 ivartmp = ivar;
559 ivar = ivar->next;
560 xmlFree(ivartmp);
561 }
562 }
563
564 /**
565 * xsltCompilerCtxtFree:
566 *
567 * Free an XSLT compiler context.
568 */
569 static void
570 xsltCompilationCtxtFree(xsltCompilerCtxtPtr cctxt)
571 {
572 if (cctxt == NULL)
573 return;
574 #ifdef WITH_XSLT_DEBUG_PARSING
575 xsltGenericDebug(xsltGenericDebugContext,
576 "Freeing compilation context\n");
577 xsltGenericDebug(xsltGenericDebugContext,
578 "### Max inodes: %d\n", cctxt->maxNodeInfos);
579 xsltGenericDebug(xsltGenericDebugContext,
580 "### Max LREs : %d\n", cctxt->maxLREs);
581 #endif
582 /*
583 * Free node-infos.
584 */
585 if (cctxt->inodeList != NULL) {
586 xsltCompilerNodeInfoPtr tmp, cur = cctxt->inodeList;
587 while (cur != NULL) {
588 tmp = cur;
589 cur = cur->next;
590 xmlFree(tmp);
591 }
592 }
593 if (cctxt->tmpList != NULL)
594 xsltPointerListFree(cctxt->tmpList);
595 #ifdef XSLT_REFACTORED_XPATHCOMP
596 if (cctxt->xpathCtxt != NULL)
597 xmlXPathFreeContext(cctxt->xpathCtxt);
598 #endif
599 if (cctxt->nsAliases != NULL)
600 xsltFreeNsAliasList(cctxt->nsAliases);
601
602 if (cctxt->ivars)
603 xsltCompilerVarInfoFree(cctxt);
604
605 xmlFree(cctxt);
606 }
607
608 /**
609 * xsltCompilerCreate:
610 *
611 * Creates an XSLT compiler context.
612 *
613 * Returns the pointer to the created xsltCompilerCtxt or
614 * NULL in case of an internal error.
615 */
616 static xsltCompilerCtxtPtr
617 xsltCompilationCtxtCreate(xsltStylesheetPtr style) {
618 xsltCompilerCtxtPtr ret;
619
620 ret = (xsltCompilerCtxtPtr) xmlMalloc(sizeof(xsltCompilerCtxt));
621 if (ret == NULL) {
622 xsltTransformError(NULL, style, NULL,
623 "xsltCompilerCreate: allocation of compiler "
624 "context failed.\n");
625 return(NULL);
626 }
627 memset(ret, 0, sizeof(xsltCompilerCtxt));
628
629 ret->errSeverity = XSLT_ERROR_SEVERITY_ERROR;
630 ret->tmpList = xsltPointerListCreate(20);
631 if (ret->tmpList == NULL) {
632 goto internal_err;
633 }
634 #ifdef XSLT_REFACTORED_XPATHCOMP
635 /*
636 * Create the XPath compilation context in order
637 * to speed up precompilation of XPath expressions.
638 */
639 ret->xpathCtxt = xmlXPathNewContext(NULL);
640 if (ret->xpathCtxt == NULL)
641 goto internal_err;
642 #endif
643
644 return(ret);
645
646 internal_err:
647 xsltCompilationCtxtFree(ret);
648 return(NULL);
649 }
650
651 static void
652 xsltLREEffectiveNsNodesFree(xsltEffectiveNsPtr first)
653 {
654 xsltEffectiveNsPtr tmp;
655
656 while (first != NULL) {
657 tmp = first;
658 first = first->nextInStore;
659 xmlFree(tmp);
660 }
661 }
662
663 static void
664 xsltFreePrincipalStylesheetData(xsltPrincipalStylesheetDataPtr data)
665 {
666 if (data == NULL)
667 return;
668
669 if (data->inScopeNamespaces != NULL) {
670 int i;
671 xsltNsListContainerPtr nsi;
672 xsltPointerListPtr list =
673 (xsltPointerListPtr) data->inScopeNamespaces;
674
675 for (i = 0; i < list->number; i++) {
676 /*
677 * REVISIT TODO: Free info of in-scope namespaces.
678 */
679 nsi = (xsltNsListContainerPtr) list->items[i];
680 if (nsi->list != NULL)
681 xmlFree(nsi->list);
682 xmlFree(nsi);
683 }
684 xsltPointerListFree(list);
685 data->inScopeNamespaces = NULL;
686 }
687
688 if (data->exclResultNamespaces != NULL) {
689 int i;
690 xsltPointerListPtr list = (xsltPointerListPtr)
691 data->exclResultNamespaces;
692
693 for (i = 0; i < list->number; i++)
694 xsltPointerListFree((xsltPointerListPtr) list->items[i]);
695
696 xsltPointerListFree(list);
697 data->exclResultNamespaces = NULL;
698 }
699
700 if (data->extElemNamespaces != NULL) {
701 xsltPointerListPtr list = (xsltPointerListPtr)
702 data->extElemNamespaces;
703 int i;
704
705 for (i = 0; i < list->number; i++)
706 xsltPointerListFree((xsltPointerListPtr) list->items[i]);
707
708 xsltPointerListFree(list);
709 data->extElemNamespaces = NULL;
710 }
711 if (data->effectiveNs) {
712 xsltLREEffectiveNsNodesFree(data->effectiveNs);
713 data->effectiveNs = NULL;
714 }
715 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
716 xsltFreeNamespaceMap(data->nsMap);
717 #endif
718 xmlFree(data);
719 }
720
721 static xsltPrincipalStylesheetDataPtr
722 xsltNewPrincipalStylesheetData(void)
723 {
724 xsltPrincipalStylesheetDataPtr ret;
725
726 ret = (xsltPrincipalStylesheetDataPtr)
727 xmlMalloc(sizeof(xsltPrincipalStylesheetData));
728 if (ret == NULL) {
729 xsltTransformError(NULL, NULL, NULL,
730 "xsltNewPrincipalStylesheetData: memory allocation failed.\n");
731 return(NULL);
732 }
733 memset(ret, 0, sizeof(xsltPrincipalStylesheetData));
734
735 /*
736 * Global list of in-scope namespaces.
737 */
738 ret->inScopeNamespaces = xsltPointerListCreate(-1);
739 if (ret->inScopeNamespaces == NULL)
740 goto internal_err;
741 /*
742 * Global list of excluded result ns-decls.
743 */
744 ret->exclResultNamespaces = xsltPointerListCreate(-1);
745 if (ret->exclResultNamespaces == NULL)
746 goto internal_err;
747 /*
748 * Global list of extension instruction namespace names.
749 */
750 ret->extElemNamespaces = xsltPointerListCreate(-1);
751 if (ret->extElemNamespaces == NULL)
752 goto internal_err;
753
754 return(ret);
755
756 internal_err:
757
758 return(NULL);
759 }
760
761 #endif
762
763 /**
764 * xsltNewStylesheet:
765 *
766 * Create a new XSLT Stylesheet
767 *
768 * Returns the newly allocated xsltStylesheetPtr or NULL in case of error
769 */
770 xsltStylesheetPtr
771 xsltNewStylesheet(void) {
772 xsltStylesheetPtr ret = NULL;
773
774 ret = (xsltStylesheetPtr) xmlMalloc(sizeof(xsltStylesheet));
775 if (ret == NULL) {
776 xsltTransformError(NULL, NULL, NULL,
777 "xsltNewStylesheet : malloc failed\n");
778 goto internal_err;
779 }
780 memset(ret, 0, sizeof(xsltStylesheet));
781
782 ret->omitXmlDeclaration = -1;
783 ret->standalone = -1;
784 ret->decimalFormat = xsltNewDecimalFormat(NULL, NULL);
785 ret->indent = -1;
786 ret->errors = 0;
787 ret->warnings = 0;
788 ret->exclPrefixNr = 0;
789 ret->exclPrefixMax = 0;
790 ret->exclPrefixTab = NULL;
791 ret->extInfos = NULL;
792 ret->extrasNr = 0;
793 ret->internalized = 1;
794 ret->literal_result = 0;
795 ret->forwards_compatible = 0;
796 ret->dict = xmlDictCreate();
797 #ifdef WITH_XSLT_DEBUG
798 xsltGenericDebug(xsltGenericDebugContext,
799 "creating dictionary for stylesheet\n");
800 #endif
801
802 xsltInit();
803
804 return(ret);
805
806 internal_err:
807 if (ret != NULL)
808 xsltFreeStylesheet(ret);
809 return(NULL);
810 }
811
812 /**
813 * xsltAllocateExtra:
814 * @style: an XSLT stylesheet
815 *
816 * Allocate an extra runtime information slot statically while compiling
817 * the stylesheet and return its number
818 *
819 * Returns the number of the slot
820 */
821 int
822 xsltAllocateExtra(xsltStylesheetPtr style)
823 {
824 return(style->extrasNr++);
825 }
826
827 /**
828 * xsltAllocateExtraCtxt:
829 * @ctxt: an XSLT transformation context
830 *
831 * Allocate an extra runtime information slot at run-time
832 * and return its number
833 * This make sure there is a slot ready in the transformation context
834 *
835 * Returns the number of the slot
836 */
837 int
838 xsltAllocateExtraCtxt(xsltTransformContextPtr ctxt)
839 {
840 if (ctxt->extrasNr >= ctxt->extrasMax) {
841 int i;
842 if (ctxt->extrasNr == 0) {
843 ctxt->extrasMax = 20;
844 ctxt->extras = (xsltRuntimeExtraPtr)
845 xmlMalloc(ctxt->extrasMax * sizeof(xsltRuntimeExtra));
846 if (ctxt->extras == NULL) {
847 xsltTransformError(ctxt, NULL, NULL,
848 "xsltAllocateExtraCtxt: out of memory\n");
849 return(0);
850 }
851 for (i = 0;i < ctxt->extrasMax;i++) {
852 ctxt->extras[i].info = NULL;
853 ctxt->extras[i].deallocate = NULL;
854 ctxt->extras[i].val.ptr = NULL;
855 }
856
857 } else {
858 xsltRuntimeExtraPtr tmp;
859
860 ctxt->extrasMax += 100;
861 tmp = (xsltRuntimeExtraPtr) xmlRealloc(ctxt->extras,
862 ctxt->extrasMax * sizeof(xsltRuntimeExtra));
863 if (tmp == NULL) {
864 xsltTransformError(ctxt, NULL, NULL,
865 "xsltAllocateExtraCtxt: out of memory\n");
866 return(0);
867 }
868 ctxt->extras = tmp;
869 for (i = ctxt->extrasNr;i < ctxt->extrasMax;i++) {
870 ctxt->extras[i].info = NULL;
871 ctxt->extras[i].deallocate = NULL;
872 ctxt->extras[i].val.ptr = NULL;
873 }
874 }
875 }
876 return(ctxt->extrasNr++);
877 }
878
879 /**
880 * xsltFreeStylesheetList:
881 * @style: an XSLT stylesheet list
882 *
883 * Free up the memory allocated by the list @style
884 */
885 static void
886 xsltFreeStylesheetList(xsltStylesheetPtr style) {
887 xsltStylesheetPtr next;
888
889 while (style != NULL) {
890 next = style->next;
891 xsltFreeStylesheet(style);
892 style = next;
893 }
894 }
895
896 /**
897 * xsltCleanupStylesheetTree:
898 *
899 * @doc: the document-node
900 * @node: the element where the stylesheet is rooted at
901 *
902 * Actually @node need not be the document-element, but
903 * currently Libxslt does not support embedded stylesheets.
904 *
905 * Returns 0 if OK, -1 on API or internal errors.
906 */
907 static int
908 xsltCleanupStylesheetTree(xmlDocPtr doc ATTRIBUTE_UNUSED,
909 xmlNodePtr rootElem ATTRIBUTE_UNUSED)
910 {
911 #if 0 /* TODO: Currently disabled, since probably not needed. */
912 xmlNodePtr cur;
913
914 if ((doc == NULL) || (rootElem == NULL) ||
915 (rootElem->type != XML_ELEMENT_NODE) ||
916 (doc != rootElem->doc))
917 return(-1);
918
919 /*
920 * Cleanup was suggested by Aleksey Sanin:
921 * Clear the PSVI field to avoid problems if the
922 * node-tree of the stylesheet is intended to be used for
923 * further processing by the user (e.g. for compiling it
924 * once again - although not recommended).
925 */
926
927 cur = rootElem;
928 while (cur != NULL) {
929 if (cur->type == XML_ELEMENT_NODE) {
930 /*
931 * Clear the PSVI field.
932 */
933 cur->psvi = NULL;
934 if (cur->children) {
935 cur = cur->children;
936 continue;
937 }
938 }
939
940 leave_node:
941 if (cur == rootElem)
942 break;
943 if (cur->next != NULL)
944 cur = cur->next;
945 else {
946 cur = cur->parent;
947 if (cur == NULL)
948 break;
949 goto leave_node;
950 }
951 }
952 #endif /* #if 0 */
953 return(0);
954 }
955
956 /**
957 * xsltFreeStylesheet:
958 * @style: an XSLT stylesheet
959 *
960 * Free up the memory allocated by @style
961 */
962 void
963 xsltFreeStylesheet(xsltStylesheetPtr style)
964 {
965 if (style == NULL)
966 return;
967
968 #ifdef XSLT_REFACTORED
969 /*
970 * Start with a cleanup of the main stylesheet's doc.
971 */
972 if ((style->principal == style) && (style->doc))
973 xsltCleanupStylesheetTree(style->doc,
974 xmlDocGetRootElement(style->doc));
975 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
976 /*
977 * Restore changed ns-decls before freeing the document.
978 */
979 if ((style->doc != NULL) &&
980 XSLT_HAS_INTERNAL_NSMAP(style))
981 {
982 xsltRestoreDocumentNamespaces(XSLT_GET_INTERNAL_NSMAP(style),
983 style->doc);
984 }
985 #endif /* XSLT_REFACTORED_XSLT_NSCOMP */
986 #else
987 /*
988 * Start with a cleanup of the main stylesheet's doc.
989 */
990 if ((style->parent == NULL) && (style->doc))
991 xsltCleanupStylesheetTree(style->doc,
992 xmlDocGetRootElement(style->doc));
993 #endif /* XSLT_REFACTORED */
994
995 xsltFreeKeys(style);
996 xsltFreeExts(style);
997 xsltFreeTemplateHashes(style);
998 xsltFreeDecimalFormatList(style);
999 xsltFreeTemplateList(style->templates);
1000 xsltFreeAttributeSetsHashes(style);
1001 xsltFreeNamespaceAliasHashes(style);
1002 xsltFreeStylePreComps(style);
1003 /*
1004 * Free documents of all included stylsheet modules of this
1005 * stylesheet level.
1006 */
1007 xsltFreeStyleDocuments(style);
1008 /*
1009 * TODO: Best time to shutdown extension stuff?
1010 */
1011 xsltShutdownExts(style);
1012
1013 if (style->variables != NULL)
1014 xsltFreeStackElemList(style->variables);
1015 if (style->cdataSection != NULL)
1016 xmlHashFree(style->cdataSection, NULL);
1017 if (style->stripSpaces != NULL)
1018 xmlHashFree(style->stripSpaces, NULL);
1019 if (style->nsHash != NULL)
1020 xmlHashFree(style->nsHash, NULL);
1021 if (style->exclPrefixTab != NULL)
1022 xmlFree(style->exclPrefixTab);
1023 if (style->method != NULL)
1024 xmlFree(style->method);
1025 if (style->methodURI != NULL)
1026 xmlFree(style->methodURI);
1027 if (style->version != NULL)
1028 xmlFree(style->version);
1029 if (style->encoding != NULL)
1030 xmlFree(style->encoding);
1031 if (style->doctypePublic != NULL)
1032 xmlFree(style->doctypePublic);
1033 if (style->doctypeSystem != NULL)
1034 xmlFree(style->doctypeSystem);
1035 if (style->mediaType != NULL)
1036 xmlFree(style->mediaType);
1037 if (style->attVTs)
1038 xsltFreeAVTList(style->attVTs);
1039 if (style->imports != NULL)
1040 xsltFreeStylesheetList(style->imports);
1041
1042 #ifdef XSLT_REFACTORED
1043 /*
1044 * If this is the principal stylesheet, then
1045 * free its internal data.
1046 */
1047 if (style->principal == style) {
1048 if (style->principalData) {
1049 xsltFreePrincipalStylesheetData(style->principalData);
1050 style->principalData = NULL;
1051 }
1052 }
1053 #endif
1054 /*
1055 * Better to free the main document of this stylesheet level
1056 * at the end - so here.
1057 */
1058 if (style->doc != NULL) {
1059 xmlFreeDoc(style->doc);
1060 }
1061
1062 #ifdef WITH_XSLT_DEBUG
1063 xsltGenericDebug(xsltGenericDebugContext,
1064 "freeing dictionary from stylesheet\n");
1065 #endif
1066 xmlDictFree(style->dict);
1067
1068 memset(style, -1, sizeof(xsltStylesheet));
1069 xmlFree(style);
1070 }
1071
1072 /************************************************************************
1073 * *
1074 * Parsing of an XSLT Stylesheet *
1075 * *
1076 ************************************************************************/
1077
1078 #ifdef XSLT_REFACTORED
1079 /*
1080 * This is now performed in an optimized way in xsltParseXSLTTemplate.
1081 */
1082 #else
1083 /**
1084 * xsltGetInheritedNsList:
1085 * @style: the stylesheet
1086 * @template: the template
1087 * @node: the current node
1088 *
1089 * Search all the namespace applying to a given element except the ones
1090 * from excluded output prefixes currently in scope. Initialize the
1091 * template inheritedNs list with it.
1092 *
1093 * Returns the number of entries found
1094 */
1095 static int
1096 xsltGetInheritedNsList(xsltStylesheetPtr style,
1097 xsltTemplatePtr template,
1098 xmlNodePtr node)
1099 {
1100 xmlNsPtr cur;
1101 xmlNsPtr *ret = NULL;
1102 int nbns = 0;
1103 int maxns = 10;
1104 int i;
1105
1106 if ((style == NULL) || (template == NULL) || (node == NULL) ||
1107 (template->inheritedNsNr != 0) || (template->inheritedNs != NULL))
1108 return(0);
1109 while (node != NULL) {
1110 if (node->type == XML_ELEMENT_NODE) {
1111 cur = node->nsDef;
1112 while (cur != NULL) {
1113 if (xmlStrEqual(cur->href, XSLT_NAMESPACE))
1114 goto skip_ns;
1115
1116 if ((cur->prefix != NULL) &&
1117 (xsltCheckExtPrefix(style, cur->prefix)))
1118 goto skip_ns;
1119 /*
1120 * Check if this namespace was excluded.
1121 * Note that at this point only the exclusions defined
1122 * on the topmost stylesheet element are in the exclusion-list.
1123 */
1124 for (i = 0;i < style->exclPrefixNr;i++) {
1125 if (xmlStrEqual(cur->href, style->exclPrefixTab[i]))
1126 goto skip_ns;
1127 }
1128 if (ret == NULL) {
1129 ret =
1130 (xmlNsPtr *) xmlMalloc((maxns + 1) *
1131 sizeof(xmlNsPtr));
1132 if (ret == NULL) {
1133 xmlGenericError(xmlGenericErrorContext,
1134 "xsltGetInheritedNsList : out of memory!\n");
1135 return(0);
1136 }
1137 ret[nbns] = NULL;
1138 }
1139 /*
1140 * Skip shadowed namespace bindings.
1141 */
1142 for (i = 0; i < nbns; i++) {
1143 if ((cur->prefix == ret[i]->prefix) ||
1144 (xmlStrEqual(cur->prefix, ret[i]->prefix)))
1145 break;
1146 }
1147 if (i >= nbns) {
1148 if (nbns >= maxns) {
1149 maxns *= 2;
1150 ret = (xmlNsPtr *) xmlRealloc(ret,
1151 (maxns +
1152 1) *
1153 sizeof(xmlNsPtr));
1154 if (ret == NULL) {
1155 xmlGenericError(xmlGenericErrorContext,
1156 "xsltGetInheritedNsList : realloc failed!\n");
1157 return(0);
1158 }
1159 }
1160 ret[nbns++] = cur;
1161 ret[nbns] = NULL;
1162 }
1163 skip_ns:
1164 cur = cur->next;
1165 }
1166 }
1167 node = node->parent;
1168 }
1169 if (nbns != 0) {
1170 #ifdef WITH_XSLT_DEBUG_PARSING
1171 xsltGenericDebug(xsltGenericDebugContext,
1172 "template has %d inherited namespaces\n", nbns);
1173 #endif
1174 template->inheritedNsNr = nbns;
1175 template->inheritedNs = ret;
1176 }
1177 return (nbns);
1178 }
1179 #endif /* else of XSLT_REFACTORED */
1180
1181 /**
1182 * xsltParseStylesheetOutput:
1183 * @style: the XSLT stylesheet
1184 * @cur: the "output" element
1185 *
1186 * parse an XSLT stylesheet output element and record
1187 * information related to the stylesheet output
1188 */
1189
1190 void
1191 xsltParseStylesheetOutput(xsltStylesheetPtr style, xmlNodePtr cur)
1192 {
1193 xmlChar *elements,
1194 *prop;
1195 xmlChar *element,
1196 *end;
1197
1198 if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
1199 return;
1200
1201 prop = xmlGetNsProp(cur, (const xmlChar *) "version", NULL);
1202 if (prop != NULL) {
1203 if (style->version != NULL)
1204 xmlFree(style->version);
1205 style->version = prop;
1206 }
1207
1208 prop = xmlGetNsProp(cur, (const xmlChar *) "encoding", NULL);
1209 if (prop != NULL) {
1210 if (style->encoding != NULL)
1211 xmlFree(style->encoding);
1212 style->encoding = prop;
1213 }
1214
1215 /* relaxed to support xt:document
1216 * TODO KB: What does "relaxed to support xt:document" mean?
1217 */
1218 prop = xmlGetNsProp(cur, (const xmlChar *) "method", NULL);
1219 if (prop != NULL) {
1220 const xmlChar *URI;
1221
1222 if (style->method != NULL)
1223 xmlFree(style->method);
1224 style->method = NULL;
1225 if (style->methodURI != NULL)
1226 xmlFree(style->methodURI);
1227 style->methodURI = NULL;
1228
1229 /*
1230 * TODO: Don't use xsltGetQNameURI().
1231 */
1232 URI = xsltGetQNameURI(cur, &prop);
1233 if (prop == NULL) {
1234 if (style != NULL) style->errors++;
1235 } else if (URI == NULL) {
1236 if ((xmlStrEqual(prop, (const xmlChar *) "xml")) ||
1237 (xmlStrEqual(prop, (const xmlChar *) "html")) ||
1238 (xmlStrEqual(prop, (const xmlChar *) "text"))) {
1239 style->method = prop;
1240 } else {
1241 xsltTransformError(NULL, style, cur,
1242 "invalid value for method: %s\n", prop);
1243 if (style != NULL) style->warnings++;
1244 xmlFree(prop);
1245 }
1246 } else {
1247 style->method = prop;
1248 style->methodURI = xmlStrdup(URI);
1249 }
1250 }
1251
1252 prop = xmlGetNsProp(cur, (const xmlChar *) "doctype-system", NULL);
1253 if (prop != NULL) {
1254 if (style->doctypeSystem != NULL)
1255 xmlFree(style->doctypeSystem);
1256 style->doctypeSystem = prop;
1257 }
1258
1259 prop = xmlGetNsProp(cur, (const xmlChar *) "doctype-public", NULL);
1260 if (prop != NULL) {
1261 if (style->doctypePublic != NULL)
1262 xmlFree(style->doctypePublic);
1263 style->doctypePublic = prop;
1264 }
1265
1266 prop = xmlGetNsProp(cur, (const xmlChar *) "standalone", NULL);
1267 if (prop != NULL) {
1268 if (xmlStrEqual(prop, (const xmlChar *) "yes")) {
1269 style->standalone = 1;
1270 } else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
1271 style->standalone = 0;
1272 } else {
1273 xsltTransformError(NULL, style, cur,
1274 "invalid value for standalone: %s\n", prop);
1275 style->errors++;
1276 }
1277 xmlFree(prop);
1278 }
1279
1280 prop = xmlGetNsProp(cur, (const xmlChar *) "indent", NULL);
1281 if (prop != NULL) {
1282 if (xmlStrEqual(prop, (const xmlChar *) "yes")) {
1283 style->indent = 1;
1284 } else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
1285 style->indent = 0;
1286 } else {
1287 xsltTransformError(NULL, style, cur,
1288 "invalid value for indent: %s\n", prop);
1289 style->errors++;
1290 }
1291 xmlFree(prop);
1292 }
1293
1294 prop = xmlGetNsProp(cur, (const xmlChar *) "omit-xml-declaration", NULL);
1295 if (prop != NULL) {
1296 if (xmlStrEqual(prop, (const xmlChar *) "yes")) {
1297 style->omitXmlDeclaration = 1;
1298 } else if (xmlStrEqual(prop, (const xmlChar *) "no")) {
1299 style->omitXmlDeclaration = 0;
1300 } else {
1301 xsltTransformError(NULL, style, cur,
1302 "invalid value for omit-xml-declaration: %s\n",
1303 prop);
1304 style->errors++;
1305 }
1306 xmlFree(prop);
1307 }
1308
1309 elements = xmlGetNsProp(cur, (const xmlChar *) "cdata-section-elements",
1310 NULL);
1311 if (elements != NULL) {
1312 if (style->cdataSection == NULL)
1313 style->cdataSection = xmlHashCreate(10);
1314 if (style->cdataSection == NULL)
1315 return;
1316
1317 element = elements;
1318 while (*element != 0) {
1319 while (IS_BLANK(*element))
1320 element++;
1321 if (*element == 0)
1322 break;
1323 end = element;
1324 while ((*end != 0) && (!IS_BLANK(*end)))
1325 end++;
1326 element = xmlStrndup(element, end - element);
1327 if (element) {
1328 #ifdef WITH_XSLT_DEBUG_PARSING
1329 xsltGenericDebug(xsltGenericDebugContext,
1330 "add cdata section output element %s\n",
1331 element);
1332 #endif
1333 if (xmlValidateQName(BAD_CAST element, 0) != 0) {
1334 xsltTransformError(NULL, style, cur,
1335 "Attribute 'cdata-section-elements': The value "
1336 "'%s' is not a valid QName.\n", element);
1337 xmlFree(element);
1338 style->errors++;
1339 } else {
1340 const xmlChar *URI;
1341
1342 /*
1343 * TODO: Don't use xsltGetQNameURI().
1344 */
1345 URI = xsltGetQNameURI(cur, &element);
1346 if (element == NULL) {
1347 /*
1348 * TODO: We'll report additionally an error
1349 * via the stylesheet's error handling.
1350 */
1351 xsltTransformError(NULL, style, cur,
1352 "Attribute 'cdata-section-elements': The value "
1353 "'%s' is not a valid QName.\n", element);
1354 style->errors++;
1355 } else {
1356 xmlNsPtr ns;
1357
1358 /*
1359 * XSLT-1.0 "Each QName is expanded into an
1360 * expanded-name using the namespace declarations in
1361 * effect on the xsl:output element in which the QName
1362 * occurs; if there is a default namespace, it is used
1363 * for QNames that do not have a prefix"
1364 * NOTE: Fix of bug #339570.
1365 */
1366 if (URI == NULL) {
1367 ns = xmlSearchNs(style->doc, cur, NULL);
1368 if (ns != NULL)
1369 URI = ns->href;
1370 }
1371 xmlHashAddEntry2(style->cdataSection, element, URI,
1372 (void *) "cdata");
1373 xmlFree(element);
1374 }
1375 }
1376 }
1377 element = end;
1378 }
1379 xmlFree(elements);
1380 }
1381
1382 prop = xmlGetNsProp(cur, (const xmlChar *) "media-type", NULL);
1383 if (prop != NULL) {
1384 if (style->mediaType)
1385 xmlFree(style->mediaType);
1386 style->mediaType = prop;
1387 }
1388 if (cur->children != NULL) {
1389 xsltParseContentError(style, cur->children);
1390 }
1391 }
1392
1393 /**
1394 * xsltParseStylesheetDecimalFormat:
1395 * @style: the XSLT stylesheet
1396 * @cur: the "decimal-format" element
1397 *
1398 * <!-- Category: top-level-element -->
1399 * <xsl:decimal-format
1400 * name = qname, decimal-separator = char, grouping-separator = char,
1401 * infinity = string, minus-sign = char, NaN = string, percent = char
1402 * per-mille = char, zero-digit = char, digit = char,
1403 * pattern-separator = char />
1404 *
1405 * parse an XSLT stylesheet decimal-format element and
1406 * and record the formatting characteristics
1407 */
1408 static void
1409 xsltParseStylesheetDecimalFormat(xsltStylesheetPtr style, xmlNodePtr cur)
1410 {
1411 xmlChar *prop;
1412 xsltDecimalFormatPtr format;
1413 xsltDecimalFormatPtr iter;
1414
1415 if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
1416 return;
1417
1418 format = style->decimalFormat;
1419
1420 prop = xmlGetNsProp(cur, BAD_CAST("name"), NULL);
1421 if (prop != NULL) {
1422 const xmlChar *nsUri;
1423
1424 if (xmlValidateQName(prop, 0) != 0) {
1425 xsltTransformError(NULL, style, cur,
1426 "xsl:decimal-format: Invalid QName '%s'.\n", prop);
1427 style->warnings++;
1428 xmlFree(prop);
1429 return;
1430 }
1431 /*
1432 * TODO: Don't use xsltGetQNameURI().
1433 */
1434 nsUri = xsltGetQNameURI(cur, &prop);
1435 if (prop == NULL) {
1436 style->warnings++;
1437 return;
1438 }
1439 format = xsltDecimalFormatGetByQName(style, nsUri, prop);
1440 if (format != NULL) {
1441 xsltTransformError(NULL, style, cur,
1442 "xsltParseStylestyleDecimalFormat: %s already exists\n", prop);
1443 style->warnings++;
1444 xmlFree(prop);
1445 return;
1446 }
1447 format = xsltNewDecimalFormat(nsUri, prop);
1448 if (format == NULL) {
1449 xsltTransformError(NULL, style, cur,
1450 "xsltParseStylestyleDecimalFormat: failed creating new decimal-format\n");
1451 style->errors++;
1452 xmlFree(prop);
1453 return;
1454 }
1455 /* Append new decimal-format structure */
1456 for (iter = style->decimalFormat; iter->next; iter = iter->next)
1457 ;
1458 if (iter)
1459 iter->next = format;
1460 }
1461
1462 prop = xmlGetNsProp(cur, (const xmlChar *)"decimal-separator", NULL);
1463 if (prop != NULL) {
1464 if (format->decimalPoint != NULL) xmlFree(format->decimalPoint);
1465 format->decimalPoint = prop;
1466 }
1467
1468 prop = xmlGetNsProp(cur, (const xmlChar *)"grouping-separator", NULL);
1469 if (prop != NULL) {
1470 if (format->grouping != NULL) xmlFree(format->grouping);
1471 format->grouping = prop;
1472 }
1473
1474 prop = xmlGetNsProp(cur, (const xmlChar *)"infinity", NULL);
1475 if (prop != NULL) {
1476 if (format->infinity != NULL) xmlFree(format->infinity);
1477 format->infinity = prop;
1478 }
1479
1480 prop = xmlGetNsProp(cur, (const xmlChar *)"minus-sign", NULL);
1481 if (prop != NULL) {
1482 if (format->minusSign != NULL) xmlFree(format->minusSign);
1483 format->minusSign = prop;
1484 }
1485
1486 prop = xmlGetNsProp(cur, (const xmlChar *)"NaN", NULL);
1487 if (prop != NULL) {
1488 if (format->noNumber != NULL) xmlFree(format->noNumber);
1489 format->noNumber = prop;
1490 }
1491
1492 prop = xmlGetNsProp(cur, (const xmlChar *)"percent", NULL);
1493 if (prop != NULL) {
1494 if (format->percent != NULL) xmlFree(format->percent);
1495 format->percent = prop;
1496 }
1497
1498 prop = xmlGetNsProp(cur, (const xmlChar *)"per-mille", NULL);
1499 if (prop != NULL) {
1500 if (format->permille != NULL) xmlFree(format->permille);
1501 format->permille = prop;
1502 }
1503
1504 prop = xmlGetNsProp(cur, (const xmlChar *)"zero-digit", NULL);
1505 if (prop != NULL) {
1506 if (format->zeroDigit != NULL) xmlFree(format->zeroDigit);
1507 format->zeroDigit = prop;
1508 }
1509
1510 prop = xmlGetNsProp(cur, (const xmlChar *)"digit", NULL);
1511 if (prop != NULL) {
1512 if (format->digit != NULL) xmlFree(format->digit);
1513 format->digit = prop;
1514 }
1515
1516 prop = xmlGetNsProp(cur, (const xmlChar *)"pattern-separator", NULL);
1517 if (prop != NULL) {
1518 if (format->patternSeparator != NULL) xmlFree(format->patternSeparator);
1519 format->patternSeparator = prop;
1520 }
1521 if (cur->children != NULL) {
1522 xsltParseContentError(style, cur->children);
1523 }
1524 }
1525
1526 /**
1527 * xsltParseStylesheetPreserveSpace:
1528 * @style: the XSLT stylesheet
1529 * @cur: the "preserve-space" element
1530 *
1531 * parse an XSLT stylesheet preserve-space element and record
1532 * elements needing preserving
1533 */
1534
1535 static void
1536 xsltParseStylesheetPreserveSpace(xsltStylesheetPtr style, xmlNodePtr cur) {
1537 xmlChar *elements;
1538 xmlChar *element, *end;
1539
1540 if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
1541 return;
1542
1543 elements = xmlGetNsProp(cur, (const xmlChar *)"elements", NULL);
1544 if (elements == NULL) {
1545 xsltTransformError(NULL, style, cur,
1546 "xsltParseStylesheetPreserveSpace: missing elements attribute\n");
1547 if (style != NULL) style->warnings++;
1548 return;
1549 }
1550
1551 if (style->stripSpaces == NULL)
1552 style->stripSpaces = xmlHashCreate(10);
1553 if (style->stripSpaces == NULL)
1554 return;
1555
1556 element = elements;
1557 while (*element != 0) {
1558 while (IS_BLANK(*element)) element++;
1559 if (*element == 0)
1560 break;
1561 end = element;
1562 while ((*end != 0) && (!IS_BLANK(*end))) end++;
1563 element = xmlStrndup(element, end - element);
1564 if (element) {
1565 #ifdef WITH_XSLT_DEBUG_PARSING
1566 xsltGenericDebug(xsltGenericDebugContext,
1567 "add preserved space element %s\n", element);
1568 #endif
1569 if (xmlStrEqual(element, (const xmlChar *)"*")) {
1570 style->stripAll = -1;
1571 } else {
1572 const xmlChar *URI;
1573
1574 /*
1575 * TODO: Don't use xsltGetQNameURI().
1576 */
1577 URI = xsltGetQNameURI(cur, &element);
1578
1579 xmlHashAddEntry2(style->stripSpaces, element, URI,
1580 (xmlChar *) "preserve");
1581 }
1582 xmlFree(element);
1583 }
1584 element = end;
1585 }
1586 xmlFree(elements);
1587 if (cur->children != NULL) {
1588 xsltParseContentError(style, cur->children);
1589 }
1590 }
1591
1592 #ifdef XSLT_REFACTORED
1593 #else
1594 /**
1595 * xsltParseStylesheetExtPrefix:
1596 * @style: the XSLT stylesheet
1597 * @template: the "extension-element-prefixes" prefix
1598 *
1599 * parse an XSLT stylesheet's "extension-element-prefix" attribute value
1600 * and register the namespaces of extension instruction.
1601 * SPEC "A namespace is designated as an extension namespace by using
1602 * an extension-element-prefixes attribute on:
1603 * 1) an xsl:stylesheet element
1604 * 2) an xsl:extension-element-prefixes attribute on a
1605 * literal result element
1606 * 3) an extension instruction."
1607 */
1608 static void
1609 xsltParseStylesheetExtPrefix(xsltStylesheetPtr style, xmlNodePtr cur,
1610 int isXsltElem) {
1611 xmlChar *prefixes;
1612 xmlChar *prefix, *end;
1613
1614 if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
1615 return;
1616
1617 if (isXsltElem) {
1618 /* For xsl:stylesheet/xsl:transform. */
1619 prefixes = xmlGetNsProp(cur,
1620 (const xmlChar *)"extension-element-prefixes", NULL);
1621 } else {
1622 /* For literal result elements and extension instructions. */
1623 prefixes = xmlGetNsProp(cur,
1624 (const xmlChar *)"extension-element-prefixes", XSLT_NAMESPACE);
1625 }
1626 if (prefixes == NULL) {
1627 return;
1628 }
1629
1630 prefix = prefixes;
1631 while (*prefix != 0) {
1632 while (IS_BLANK(*prefix)) prefix++;
1633 if (*prefix == 0)
1634 break;
1635 end = prefix;
1636 while ((*end != 0) && (!IS_BLANK(*end))) end++;
1637 prefix = xmlStrndup(prefix, end - prefix);
1638 if (prefix) {
1639 xmlNsPtr ns;
1640
1641 if (xmlStrEqual(prefix, (const xmlChar *)"#default"))
1642 ns = xmlSearchNs(style->doc, cur, NULL);
1643 else
1644 ns = xmlSearchNs(style->doc, cur, prefix);
1645 if (ns == NULL) {
1646 xsltTransformError(NULL, style, cur,
1647 "xsl:extension-element-prefix : undefined namespace %s\n",
1648 prefix);
1649 if (style != NULL) style->warnings++;
1650 } else {
1651 #ifdef WITH_XSLT_DEBUG_PARSING
1652 xsltGenericDebug(xsltGenericDebugContext,
1653 "add extension prefix %s\n", prefix);
1654 #endif
1655 xsltRegisterExtPrefix(style, prefix, ns->href);
1656 }
1657 xmlFree(prefix);
1658 }
1659 prefix = end;
1660 }
1661 xmlFree(prefixes);
1662 }
1663 #endif /* else of XSLT_REFACTORED */
1664
1665 /**
1666 * xsltParseStylesheetStripSpace:
1667 * @style: the XSLT stylesheet
1668 * @cur: the "strip-space" element
1669 *
1670 * parse an XSLT stylesheet's strip-space element and record
1671 * the elements needing stripping
1672 */
1673
1674 static void
1675 xsltParseStylesheetStripSpace(xsltStylesheetPtr style, xmlNodePtr cur) {
1676 xmlChar *elements;
1677 xmlChar *element, *end;
1678
1679 if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
1680 return;
1681
1682 elements = xmlGetNsProp(cur, (const xmlChar *)"elements", NULL);
1683 if (elements == NULL) {
1684 xsltTransformError(NULL, style, cur,
1685 "xsltParseStylesheetStripSpace: missing elements attribute\n");
1686 if (style != NULL) style->warnings++;
1687 return;
1688 }
1689
1690 if (style->stripSpaces == NULL)
1691 style->stripSpaces = xmlHashCreate(10);
1692 if (style->stripSpaces == NULL)
1693 return;
1694
1695 element = elements;
1696 while (*element != 0) {
1697 while (IS_BLANK(*element)) element++;
1698 if (*element == 0)
1699 break;
1700 end = element;
1701 while ((*end != 0) && (!IS_BLANK(*end))) end++;
1702 element = xmlStrndup(element, end - element);
1703 if (element) {
1704 #ifdef WITH_XSLT_DEBUG_PARSING
1705 xsltGenericDebug(xsltGenericDebugContext,
1706 "add stripped space element %s\n", element);
1707 #endif
1708 if (xmlStrEqual(element, (const xmlChar *)"*")) {
1709 style->stripAll = 1;
1710 } else {
1711 const xmlChar *URI;
1712
1713 /*
1714 * TODO: Don't use xsltGetQNameURI().
1715 */
1716 URI = xsltGetQNameURI(cur, &element);
1717
1718 xmlHashAddEntry2(style->stripSpaces, element, URI,
1719 (xmlChar *) "strip");
1720 }
1721 xmlFree(element);
1722 }
1723 element = end;
1724 }
1725 xmlFree(elements);
1726 if (cur->children != NULL) {
1727 xsltParseContentError(style, cur->children);
1728 }
1729 }
1730
1731 #ifdef XSLT_REFACTORED
1732 #else
1733 /**
1734 * xsltParseStylesheetExcludePrefix:
1735 * @style: the XSLT stylesheet
1736 * @cur: the current point in the stylesheet
1737 *
1738 * parse an XSLT stylesheet exclude prefix and record
1739 * namespaces needing stripping
1740 *
1741 * Returns the number of Excluded prefixes added at that level
1742 */
1743
1744 static int
1745 xsltParseStylesheetExcludePrefix(xsltStylesheetPtr style, xmlNodePtr cur,
1746 int isXsltElem)
1747 {
1748 int nb = 0;
1749 xmlChar *prefixes;
1750 xmlChar *prefix, *end;
1751
1752 if ((cur == NULL) || (style == NULL) || (cur->type != XML_ELEMENT_NODE))
1753 return(0);
1754
1755 if (isXsltElem)
1756 prefixes = xmlGetNsProp(cur,
1757 (const xmlChar *)"exclude-result-prefixes", NULL);
1758 else
1759 prefixes = xmlGetNsProp(cur,
1760 (const xmlChar *)"exclude-result-prefixes", XSLT_NAMESPACE);
1761
1762 if (prefixes == NULL) {
1763 return(0);
1764 }
1765
1766 prefix = prefixes;
1767 while (*prefix != 0) {
1768 while (IS_BLANK(*prefix)) prefix++;
1769 if (*prefix == 0)
1770 break;
1771 end = prefix;
1772 while ((*end != 0) && (!IS_BLANK(*end))) end++;
1773 prefix = xmlStrndup(prefix, end - prefix);
1774 if (prefix) {
1775 xmlNsPtr ns;
1776
1777 if (xmlStrEqual(prefix, (const xmlChar *)"#default"))
1778 ns = xmlSearchNs(style->doc, cur, NULL);
1779 else
1780 ns = xmlSearchNs(style->doc, cur, prefix);
1781 if (ns == NULL) {
1782 xsltTransformError(NULL, style, cur,
1783 "xsl:exclude-result-prefixes : undefined namespace %s\n",
1784 prefix);
1785 if (style != NULL) style->warnings++;
1786 } else {
1787 if (exclPrefixPush(style, (xmlChar *) ns->href) >= 0) {
1788 #ifdef WITH_XSLT_DEBUG_PARSING
1789 xsltGenericDebug(xsltGenericDebugContext,
1790 "exclude result prefix %s\n", prefix);
1791 #endif
1792 nb++;
1793 }
1794 }
1795 xmlFree(prefix);
1796 }
1797 prefix = end;
1798 }
1799 xmlFree(prefixes);
1800 return(nb);
1801 }
1802 #endif /* else of XSLT_REFACTORED */
1803
1804 #ifdef XSLT_REFACTORED
1805
1806 /*
1807 * xsltTreeEnsureXMLDecl:
1808 * @doc: the doc
1809 *
1810 * BIG NOTE:
1811 * This was copy&pasted from Libxml2's xmlTreeEnsureXMLDecl() in "tree.c".
1812 * Ensures that there is an XML namespace declaration on the doc.
1813 *
1814 * Returns the XML ns-struct or NULL on API and internal errors.
1815 */
1816 static xmlNsPtr
1817 xsltTreeEnsureXMLDecl(xmlDocPtr doc)
1818 {
1819 if (doc == NULL)
1820 return (NULL);
1821 if (doc->oldNs != NULL)
1822 return (doc->oldNs);
1823 {
1824 xmlNsPtr ns;
1825 ns = (xmlNsPtr) xmlMalloc(sizeof(xmlNs));
1826 if (ns == NULL) {
1827 xmlGenericError(xmlGenericErrorContext,
1828 "xsltTreeEnsureXMLDecl: Failed to allocate "
1829 "the XML namespace.\n");
1830 return (NULL);
1831 }
1832 memset(ns, 0, sizeof(xmlNs));
1833 ns->type = XML_LOCAL_NAMESPACE;
1834 /*
1835 * URGENT TODO: revisit this.
1836 */
1837 #ifdef LIBXML_NAMESPACE_DICT
1838 if (doc->dict)
1839 ns->href = xmlDictLookup(doc->dict, XML_XML_NAMESPACE, -1);
1840 else
1841 ns->href = xmlStrdup(XML_XML_NAMESPACE);
1842 #else
1843 ns->href = xmlStrdup(XML_XML_NAMESPACE);
1844 #endif
1845 ns->prefix = xmlStrdup((const xmlChar *)"xml");
1846 doc->oldNs = ns;
1847 return (ns);
1848 }
1849 }
1850
1851 /*
1852 * xsltTreeAcquireStoredNs:
1853 * @doc: the doc
1854 * @nsName: the namespace name
1855 * @prefix: the prefix
1856 *
1857 * BIG NOTE:
1858 * This was copy&pasted from Libxml2's xmlDOMWrapStoreNs() in "tree.c".
1859 * Creates or reuses an xmlNs struct on doc->oldNs with
1860 * the given prefix and namespace name.
1861 *
1862 * Returns the aquired ns struct or NULL in case of an API
1863 * or internal error.
1864 */
1865 static xmlNsPtr
1866 xsltTreeAcquireStoredNs(xmlDocPtr doc,
1867 const xmlChar *nsName,
1868 const xmlChar *prefix)
1869 {
1870 xmlNsPtr ns;
1871
1872 if (doc == NULL)
1873 return (NULL);
1874 if (doc->oldNs != NULL)
1875 ns = doc->oldNs;
1876 else
1877 ns = xsltTreeEnsureXMLDecl(doc);
1878 if (ns == NULL)
1879 return (NULL);
1880 if (ns->next != NULL) {
1881 /* Reuse. */
1882 ns = ns->next;
1883 while (ns != NULL) {
1884 if ((ns->prefix == NULL) != (prefix == NULL)) {
1885 /* NOP */
1886 } else if (prefix == NULL) {
1887 if (xmlStrEqual(ns->href, nsName))
1888 return (ns);
1889 } else {
1890 if ((ns->prefix[0] == prefix[0]) &&
1891 xmlStrEqual(ns->prefix, prefix) &&
1892 xmlStrEqual(ns->href, nsName))
1893 return (ns);
1894
1895 }
1896 if (ns->next == NULL)
1897 break;
1898 ns = ns->next;
1899 }
1900 }
1901 /* Create. */
1902 ns->next = xmlNewNs(NULL, nsName, prefix);
1903 return (ns->next);
1904 }
1905
1906 /**
1907 * xsltLREBuildEffectiveNs:
1908 *
1909 * Apply ns-aliasing on the namespace of the given @elem and
1910 * its attributes.
1911 */
1912 static int
1913 xsltLREBuildEffectiveNs(xsltCompilerCtxtPtr cctxt,
1914 xmlNodePtr elem)
1915 {
1916 xmlNsPtr ns;
1917 xsltNsAliasPtr alias;
1918
1919 if ((cctxt == NULL) || (elem == NULL))
1920 return(-1);
1921 if ((cctxt->nsAliases == NULL) || (! cctxt->hasNsAliases))
1922 return(0);
1923
1924 alias = cctxt->nsAliases;
1925 while (alias != NULL) {
1926 if ( /* If both namespaces are NULL... */
1927 ( (elem->ns == NULL) &&
1928 ((alias->literalNs == NULL) ||
1929 (alias->literalNs->href == NULL)) ) ||
1930 /* ... or both namespace are equal */
1931 ( (elem->ns != NULL) &&
1932 (alias->literalNs != NULL) &&
1933 xmlStrEqual(elem->ns->href, alias->literalNs->href) ) )
1934 {
1935 if ((alias->targetNs != NULL) &&
1936 (alias->targetNs->href != NULL))
1937 {
1938 /*
1939 * Convert namespace.
1940 */
1941 if (elem->doc == alias->docOfTargetNs) {
1942 /*
1943 * This is the nice case: same docs.
1944 * This will eventually assign a ns-decl which
1945 * is shadowed, but this has no negative effect on
1946 * the generation of the result tree.
1947 */
1948 elem->ns = alias->targetNs;
1949 } else {
1950 /*
1951 * This target xmlNs originates from a different
1952 * stylesheet tree. Try to locate it in the
1953 * in-scope namespaces.
1954 * OPTIMIZE TODO: Use the compiler-node-info inScopeNs.
1955 */
1956 ns = xmlSearchNs(elem->doc, elem,
1957 alias->targetNs->prefix);
1958 /*
1959 * If no matching ns-decl found, then assign a
1960 * ns-decl stored in xmlDoc.
1961 */
1962 if ((ns == NULL) ||
1963 (! xmlStrEqual(ns->href, alias->targetNs->href)))
1964 {
1965 /*
1966 * BIG NOTE: The use of xsltTreeAcquireStoredNs()
1967 * is not very efficient, but currently I don't
1968 * see an other way of *safely* changing a node's
1969 * namespace, since the xmlNs struct in
1970 * alias->targetNs might come from an other
1971 * stylesheet tree. So we need to anchor it in the
1972 * current document, without adding it to the tree,
1973 * which would otherwise change the in-scope-ns
1974 * semantic of the tree.
1975 */
1976 ns = xsltTreeAcquireStoredNs(elem->doc,
1977 alias->targetNs->href,
1978 alias->targetNs->prefix);
1979
1980 if (ns == NULL) {
1981 xsltTransformError(NULL, cctxt->style, elem,
1982 "Internal error in "
1983 "xsltLREBuildEffectiveNs(): "
1984 "failed to acquire a stored "
1985 "ns-declaration.\n");
1986 cctxt->style->errors++;
1987 return(-1);
1988
1989 }
1990 }
1991 elem->ns = ns;
1992 }
1993 } else {
1994 /*
1995 * Move into or leave in the NULL namespace.
1996 */
1997 elem->ns = NULL;
1998 }
1999 break;
2000 }
2001 alias = alias->next;
2002 }
2003 /*
2004 * Same with attributes of literal result elements.
2005 */
2006 if (elem->properties != NULL) {
2007 xmlAttrPtr attr = elem->properties;
2008
2009 while (attr != NULL) {
2010 if (attr->ns == NULL) {
2011 attr = attr->next;
2012 continue;
2013 }
2014 alias = cctxt->nsAliases;
2015 while (alias != NULL) {
2016 if ( /* If both namespaces are NULL... */
2017 ( (elem->ns == NULL) &&
2018 ((alias->literalNs == NULL) ||
2019 (alias->literalNs->href == NULL)) ) ||
2020 /* ... or both namespace are equal */
2021 ( (elem->ns != NULL) &&
2022 (alias->literalNs != NULL) &&
2023 xmlStrEqual(elem->ns->href, alias->literalNs->href) ) )
2024 {
2025 if ((alias->targetNs != NULL) &&
2026 (alias->targetNs->href != NULL))
2027 {
2028 if (elem->doc == alias->docOfTargetNs) {
2029 elem->ns = alias->targetNs;
2030 } else {
2031 ns = xmlSearchNs(elem->doc, elem,
2032 alias->targetNs->prefix);
2033 if ((ns == NULL) ||
2034 (! xmlStrEqual(ns->href, alias->targetNs->href)))
2035 {
2036 ns = xsltTreeAcquireStoredNs(elem->doc,
2037 alias->targetNs->href,
2038 alias->targetNs->prefix);
2039
2040 if (ns == NULL) {
2041 xsltTransformError(NULL, cctxt->style, elem,
2042 "Internal error in "
2043 "xsltLREBuildEffectiveNs(): "
2044 "failed to acquire a stored "
2045 "ns-declaration.\n");
2046 cctxt->style->errors++;
2047 return(-1);
2048
2049 }
2050 }
2051 elem->ns = ns;
2052 }
2053 } else {
2054 /*
2055 * Move into or leave in the NULL namespace.
2056 */
2057 elem->ns = NULL;
2058 }
2059 break;
2060 }
2061 alias = alias->next;
2062 }
2063
2064 attr = attr->next;
2065 }
2066 }
2067 return(0);
2068 }
2069
2070 /**
2071 * xsltLREBuildEffectiveNsNodes:
2072 *
2073 * Computes the effective namespaces nodes for a literal result
2074 * element.
2075 * @effectiveNs is the set of effective ns-nodes
2076 * on the literal result element, which will be added to the result
2077 * element if not already existing in the result tree.
2078 * This means that excluded namespaces (via exclude-result-prefixes,
2079 * extension-element-prefixes and the XSLT namespace) not added
2080 * to the set.
2081 * Namespace-aliasing was applied on the @effectiveNs.
2082 */
2083 static int
2084 xsltLREBuildEffectiveNsNodes(xsltCompilerCtxtPtr cctxt,
2085 xsltStyleItemLRElementInfoPtr item,
2086 xmlNodePtr elem,
2087 int isLRE)
2088 {
2089 xmlNsPtr ns, tmpns;
2090 xsltEffectiveNsPtr effNs, lastEffNs = NULL;
2091 int i, j, holdByElem;
2092 xsltPointerListPtr extElemNs = cctxt->inode->extElemNs;
2093 xsltPointerListPtr exclResultNs = cctxt->inode->exclResultNs;
2094
2095 if ((cctxt == NULL) || (cctxt->inode == NULL) || (elem == NULL) ||
2096 (item == NULL) || (item->effectiveNs != NULL))
2097 return(-1);
2098
2099 if (item->inScopeNs == NULL)
2100 return(0);
2101
2102 extElemNs = cctxt->inode->extElemNs;
2103 exclResultNs = cctxt->inode->exclResultNs;
2104
2105 for (i = 0; i < item->inScopeNs->totalNumber; i++) {
2106 ns = item->inScopeNs->list[i];
2107 /*
2108 * Skip namespaces designated as excluded namespaces
2109 * -------------------------------------------------
2110 *
2111 * XSLT-20 TODO: In XSLT 2.0 we need to keep namespaces
2112 * which are target namespaces of namespace-aliases
2113 * regardless if designated as excluded.
2114 *
2115 * Exclude the XSLT namespace.
2116 */
2117 if (xmlStrEqual(ns->href, XSLT_NAMESPACE))
2118 goto skip_ns;
2119
2120 /*
2121 * Apply namespace aliasing
2122 * ------------------------
2123 *
2124 * SPEC XSLT 2.0
2125 * "- A namespace node whose string value is a literal namespace
2126 * URI is not copied to the result tree.
2127 * - A namespace node whose string value is a target namespace URI
2128 * is copied to the result tree, whether or not the URI
2129 * identifies an excluded namespace."
2130 *
2131 * NOTE: The ns-aliasing machanism is non-cascading.
2132 * (checked with Saxon, Xalan and MSXML .NET).
2133 * URGENT TODO: is style->nsAliases the effective list of
2134 * ns-aliases, or do we need to lookup the whole
2135 * import-tree?
2136 * TODO: Get rid of import-tree lookup.
2137 */
2138 if (cctxt->hasNsAliases) {
2139 xsltNsAliasPtr alias;
2140 /*
2141 * First check for being a target namespace.
2142 */
2143 alias = cctxt->nsAliases;
2144 do {
2145 /*
2146 * TODO: Is xmlns="" handled already?
2147 */
2148 if ((alias->targetNs != NULL) &&
2149 (xmlStrEqual(alias->targetNs->href, ns->href)))
2150 {
2151 /*
2152 * Recognized as a target namespace; use it regardless
2153 * if excluded otherwise.
2154 */
2155 goto add_effective_ns;
2156 }
2157 alias = alias->next;
2158 } while (alias != NULL);
2159
2160 alias = cctxt->nsAliases;
2161 do {
2162 /*
2163 * TODO: Is xmlns="" handled already?
2164 */
2165 if ((alias->literalNs != NULL) &&
2166 (xmlStrEqual(alias->literalNs->href, ns->href)))
2167 {
2168 /*
2169 * Recognized as an namespace alias; do not use it.
2170 */
2171 goto skip_ns;
2172 }
2173 alias = alias->next;
2174 } while (alias != NULL);
2175 }
2176
2177 /*
2178 * Exclude excluded result namespaces.
2179 */
2180 if (exclResultNs) {
2181 for (j = 0; j < exclResultNs->number; j++)
2182 if (xmlStrEqual(ns->href, BAD_CAST exclResultNs->items[j]))
2183 goto skip_ns;
2184 }
2185 /*
2186 * Exclude extension-element namespaces.
2187 */
2188 if (extElemNs) {
2189 for (j = 0; j < extElemNs->number; j++)
2190 if (xmlStrEqual(ns->href, BAD_CAST extElemNs->items[j]))
2191 goto skip_ns;
2192 }
2193
2194 add_effective_ns:
2195 /*
2196 * OPTIMIZE TODO: This information may not be needed.
2197 */
2198 if (isLRE && (elem->nsDef != NULL)) {
2199 holdByElem = 0;
2200 tmpns = elem->nsDef;
2201 do {
2202 if (tmpns == ns) {
2203 holdByElem = 1;
2204 break;
2205 }
2206 tmpns = tmpns->next;
2207 } while (tmpns != NULL);
2208 } else
2209 holdByElem = 0;
2210
2211
2212 /*
2213 * Add the effective namespace declaration.
2214 */
2215 effNs = (xsltEffectiveNsPtr) xmlMalloc(sizeof(xsltEffectiveNs));
2216 if (effNs == NULL) {
2217 xsltTransformError(NULL, cctxt->style, elem,
2218 "Internal error in xsltLREBuildEffectiveNs(): "
2219 "failed to allocate memory.\n");
2220 cctxt->style->errors++;
2221 return(-1);
2222 }
2223 if (cctxt->psData->effectiveNs == NULL) {
2224 cctxt->psData->effectiveNs = effNs;
2225 effNs->nextInStore = NULL;
2226 } else {
2227 effNs->nextInStore = cctxt->psData->effectiveNs;
2228 cctxt->psData->effectiveNs = effNs;
2229 }
2230
2231 effNs->next = NULL;
2232 effNs->prefix = ns->prefix;
2233 effNs->nsName = ns->href;
2234 effNs->holdByElem = holdByElem;
2235
2236 if (lastEffNs == NULL)
2237 item->effectiveNs = effNs;
2238 else
2239 lastEffNs->next = effNs;
2240 lastEffNs = effNs;
2241
2242 skip_ns:
2243 {}
2244 }
2245 return(0);
2246 }
2247
2248
2249 /**
2250 * xsltLREInfoCreate:
2251 *
2252 * @isLRE: indicates if the given @elem is a literal result element
2253 *
2254 * Creates a new info for a literal result element.
2255 */
2256 static int
2257 xsltLREInfoCreate(xsltCompilerCtxtPtr cctxt,
2258 xmlNodePtr elem,
2259 int isLRE)
2260 {
2261 xsltStyleItemLRElementInfoPtr item;
2262
2263 if ((cctxt == NULL) || (cctxt->inode == NULL))
2264 return(-1);
2265
2266 item = (xsltStyleItemLRElementInfoPtr)
2267 xmlMalloc(sizeof(xsltStyleItemLRElementInfo));
2268 if (item == NULL) {
2269 xsltTransformError(NULL, cctxt->style, NULL,
2270 "Internal error in xsltLREInfoCreate(): "
2271 "memory allocation failed.\n");
2272 cctxt->style->errors++;
2273 return(-1);
2274 }
2275 memset(item, 0, sizeof(xsltStyleItemLRElementInfo));
2276 item->type = XSLT_FUNC_LITERAL_RESULT_ELEMENT;
2277 /*
2278 * Store it in the stylesheet.
2279 */
2280 item->next = cctxt->style->preComps;
2281 cctxt->style->preComps = (xsltElemPreCompPtr) item;
2282 /*
2283 * @inScopeNs are used for execution of XPath expressions
2284 * in AVTs.
2285 */
2286 item->inScopeNs = cctxt->inode->inScopeNs;
2287
2288 if (elem)
2289 xsltLREBuildEffectiveNsNodes(cctxt, item, elem, isLRE);
2290
2291 cctxt->inode->litResElemInfo = item;
2292 cctxt->inode->nsChanged = 0;
2293 cctxt->maxLREs++;
2294 return(0);
2295 }
2296
2297 /**
2298 * xsltCompilerVarInfoPush:
2299 * @cctxt: the compilation context
2300 *
2301 * Pushes a new var/param info onto the stack.
2302 *
2303 * Returns the acquired variable info.
2304 */
2305 static xsltVarInfoPtr
2306 xsltCompilerVarInfoPush(xsltCompilerCtxtPtr cctxt,
2307 xmlNodePtr inst,
2308 const xmlChar *name,
2309 const xmlChar *nsName)
2310 {
2311 xsltVarInfoPtr ivar;
2312
2313 if ((cctxt->ivar != NULL) && (cctxt->ivar->next != NULL)) {
2314 ivar = cctxt->ivar->next;
2315 } else if ((cctxt->ivar == NULL) && (cctxt->ivars != NULL)) {
2316 ivar = cctxt->ivars;
2317 } else {
2318 ivar = (xsltVarInfoPtr) xmlMalloc(sizeof(xsltVarInfo));
2319 if (ivar == NULL) {
2320 xsltTransformError(NULL, cctxt->style, inst,
2321 "xsltParseInScopeVarPush: xmlMalloc() failed!\n");
2322 cctxt->style->errors++;
2323 return(NULL);
2324 }
2325 /* memset(retVar, 0, sizeof(xsltInScopeVar)); */
2326 if (cctxt->ivars == NULL) {
2327 cctxt->ivars = ivar;
2328 ivar->prev = NULL;
2329 } else {
2330 cctxt->ivar->next = ivar;
2331 ivar->prev = cctxt->ivar;
2332 }
2333 cctxt->ivar = ivar;
2334 ivar->next = NULL;
2335 }
2336 ivar->depth = cctxt->depth;
2337 ivar->name = name;
2338 ivar->nsName = nsName;
2339 return(ivar);
2340 }
2341
2342 /**
2343 * xsltCompilerVarInfoPop:
2344 * @cctxt: the compilation context
2345 *
2346 * Pops all var/param infos from the stack, which
2347 * have the current depth.
2348 */
2349 static void
2350 xsltCompilerVarInfoPop(xsltCompilerCtxtPtr cctxt)
2351 {
2352
2353 while ((cctxt->ivar != NULL) &&
2354 (cctxt->ivar->depth > cctxt->depth))
2355 {
2356 cctxt->ivar = cctxt->ivar->prev;
2357 }
2358 }
2359
2360 /*
2361 * xsltCompilerNodePush:
2362 *
2363 * @cctxt: the compilation context
2364 * @node: the node to be pushed (this can also be the doc-node)
2365 *
2366 *
2367 *
2368 * Returns the current node info structure or
2369 * NULL in case of an internal error.
2370 */
2371 static xsltCompilerNodeInfoPtr
2372 xsltCompilerNodePush(xsltCompilerCtxtPtr cctxt, xmlNodePtr node)
2373 {
2374 xsltCompilerNodeInfoPtr inode, iprev;
2375
2376 if ((cctxt->inode != NULL) && (cctxt->inode->next != NULL)) {
2377 inode = cctxt->inode->next;
2378 } else if ((cctxt->inode == NULL) && (cctxt->inodeList != NULL)) {
2379 inode = cctxt->inodeList;
2380 } else {
2381 /*
2382 * Create a new node-info.
2383 */
2384 inode = (xsltCompilerNodeInfoPtr)
2385 xmlMalloc(sizeof(xsltCompilerNodeInfo));
2386 if (inode == NULL) {
2387 xsltTransformError(NULL, cctxt->style, NULL,
2388 "xsltCompilerNodePush: malloc failed.\n");
2389 return(NULL);
2390 }
2391 memset(inode, 0, sizeof(xsltCompilerNodeInfo));
2392 if (cctxt->inodeList == NULL)
2393 cctxt->inodeList = inode;
2394 else {
2395 cctxt->inodeLast->next = inode;
2396 inode->prev = cctxt->inodeLast;
2397 }
2398 cctxt->inodeLast = inode;
2399 cctxt->maxNodeInfos++;
2400 if (cctxt->inode == NULL) {
2401 cctxt->inode = inode;
2402 /*
2403 * Create an initial literal result element info for
2404 * the root of the stylesheet.
2405 */
2406 xsltLREInfoCreate(cctxt, NULL, 0);
2407 }
2408 }
2409 cctxt->depth++;
2410 cctxt->inode = inode;
2411 /*
2412 * REVISIT TODO: Keep the reset always complete.
2413 * NOTE: Be carefull with the @node, since it might be
2414 * a doc-node.
2415 */
2416 inode->node = node;
2417 inode->depth = cctxt->depth;
2418 inode->templ = NULL;
2419 inode->category = XSLT_ELEMENT_CATEGORY_XSLT;
2420 inode->type = 0;
2421 inode->item = NULL;
2422 inode->curChildType = 0;
2423 inode->extContentHandled = 0;
2424 inode->isRoot = 0;
2425
2426 if (inode->prev != NULL) {
2427 iprev = inode->prev;
2428 /*
2429 * Inherit the following information:
2430 * ---------------------------------
2431 *
2432 * In-scope namespaces
2433 */
2434 inode->inScopeNs = iprev->inScopeNs;
2435 /*
2436 * Info for literal result elements
2437 */
2438 inode->litResElemInfo = iprev->litResElemInfo;
2439 inode->nsChanged = iprev->nsChanged;
2440 /*
2441 * Excluded result namespaces
2442 */
2443 inode->exclResultNs = iprev->exclResultNs;
2444 /*
2445 * Extension instruction namespaces
2446 */
2447 inode->extElemNs = iprev->extElemNs;
2448 /*
2449 * Whitespace preservation
2450 */
2451 inode->preserveWhitespace = iprev->preserveWhitespace;
2452 /*
2453 * Forwards-compatible mode
2454 */
2455 inode->forwardsCompat = iprev->forwardsCompat;
2456 } else {
2457 inode->inScopeNs = NULL;
2458 inode->exclResultNs = NULL;
2459 inode->extElemNs = NULL;
2460 inode->preserveWhitespace = 0;
2461 inode->forwardsCompat = 0;
2462 }
2463
2464 return(inode);
2465 }
2466
2467 /*
2468 * xsltCompilerNodePop:
2469 *
2470 * @cctxt: the compilation context
2471 * @node: the node to be pushed (this can also be the doc-node)
2472 *
2473 * Pops the current node info.
2474 */
2475 static void
2476 xsltCompilerNodePop(xsltCompilerCtxtPtr cctxt, xmlNodePtr node)
2477 {
2478 if (cctxt->inode == NULL) {
2479 xmlGenericError(xmlGenericErrorContext,
2480 "xsltCompilerNodePop: Top-node mismatch.\n");
2481 return;
2482 }
2483 /*
2484 * NOTE: Be carefull with the @node, since it might be
2485 * a doc-node.
2486 */
2487 if (cctxt->inode->node != node) {
2488 xmlGenericError(xmlGenericErrorContext,
2489 "xsltCompilerNodePop: Node mismatch.\n");
2490 goto mismatch;
2491 }
2492 if (cctxt->inode->depth != cctxt->depth) {
2493 xmlGenericError(xmlGenericErrorContext,
2494 "xsltCompilerNodePop: Depth mismatch.\n");
2495 goto mismatch;
2496 }
2497 cctxt->depth--;
2498 /*
2499 * Pop information of variables.
2500 */
2501 if ((cctxt->ivar) && (cctxt->ivar->depth > cctxt->depth))
2502 xsltCompilerVarInfoPop(cctxt);
2503
2504 cctxt->inode = cctxt->inode->prev;
2505 if (cctxt->inode != NULL)
2506 cctxt->inode->curChildType = 0;
2507 return;
2508
2509 mismatch:
2510 {
2511 const xmlChar *nsName = NULL, *name = NULL;
2512 const xmlChar *infnsName = NULL, *infname = NULL;
2513
2514 if (node) {
2515 if (node->type == XML_ELEMENT_NODE) {
2516 name = node->name;
2517 if (node->ns != NULL)
2518 nsName = node->ns->href;
2519 else
2520 nsName = BAD_CAST "";
2521 } else {
2522 name = BAD_CAST "#document";
2523 nsName = BAD_CAST "";
2524 }
2525 } else
2526 name = BAD_CAST "Not given";
2527
2528 if (cctxt->inode->node) {
2529 if (node->type == XML_ELEMENT_NODE) {
2530 infname = cctxt->inode->node->name;
2531 if (cctxt->inode->node->ns != NULL)
2532 infnsName = cctxt->inode->node->ns->href;
2533 else
2534 infnsName = BAD_CAST "";
2535 } else {
2536 infname = BAD_CAST "#document";
2537 infnsName = BAD_CAST "";
2538 }
2539 } else
2540 infname = BAD_CAST "Not given";
2541
2542
2543 xmlGenericError(xmlGenericErrorContext,
2544 "xsltCompilerNodePop: Given : '%s' URI '%s'\n",
2545 name, nsName);
2546 xmlGenericError(xmlGenericErrorContext,
2547 "xsltCompilerNodePop: Expected: '%s' URI '%s'\n",
2548 infname, infnsName);
2549 }
2550 }
2551
2552 /*
2553 * xsltCompilerBuildInScopeNsList:
2554 *
2555 * Create and store the list of in-scope namespaces for the given
2556 * node in the stylesheet. If there are no changes in the in-scope
2557 * namespaces then the last ns-info of the ancestor axis will be returned.
2558 * Compilation-time only.
2559 *
2560 * Returns the ns-info or NULL if there are no namespaces in scope.
2561 */
2562 static xsltNsListContainerPtr
2563 xsltCompilerBuildInScopeNsList(xsltCompilerCtxtPtr cctxt, xmlNodePtr node)
2564 {
2565 xsltNsListContainerPtr nsi = NULL;
2566 xmlNsPtr *list = NULL, ns;
2567 int i, maxns = 5;
2568 /*
2569 * Create a new ns-list for this position in the node-tree.
2570 * xmlGetNsList() will return NULL, if there are no ns-decls in the
2571 * tree. Note that the ns-decl for the XML namespace is not added
2572 * to the resulting list; the XPath module handles the XML namespace
2573 * internally.
2574 */
2575 while (node != NULL) {
2576 if (node->type == XML_ELEMENT_NODE) {
2577 ns = node->nsDef;
2578 while (ns != NULL) {
2579 if (nsi == NULL) {
2580 nsi = (xsltNsListContainerPtr)
2581 xmlMalloc(sizeof(xsltNsListContainer));
2582 if (nsi == NULL) {
2583 xsltTransformError(NULL, cctxt->style, NULL,
2584 "xsltCompilerBuildInScopeNsList: "
2585 "malloc failed!\n");
2586 goto internal_err;
2587 }
2588 memset(nsi, 0, sizeof(xsltNsListContainer));
2589 nsi->list =
2590 (xmlNsPtr *) xmlMalloc(maxns * sizeof(xmlNsPtr));
2591 if (nsi->list == NULL) {
2592 xsltTransformError(NULL, cctxt->style, NULL,
2593 "xsltCompilerBuildInScopeNsList: "
2594 "malloc failed!\n");
2595 goto internal_err;
2596 }
2597 nsi->list[0] = NULL;
2598 }
2599 /*
2600 * Skip shadowed namespace bindings.
2601 */
2602 for (i = 0; i < nsi->totalNumber; i++) {
2603 if ((ns->prefix == nsi->list[i]->prefix) ||
2604 (xmlStrEqual(ns->prefix, nsi->list[i]->prefix)))
2605 break;
2606 }
2607 if (i >= nsi->totalNumber) {
2608 if (nsi->totalNumber +1 >= maxns) {
2609 maxns *= 2;
2610 nsi->list =
2611 (xmlNsPtr *) xmlRealloc(nsi->list,
2612 maxns * sizeof(xmlNsPtr));
2613 if (nsi->list == NULL) {
2614 xsltTransformError(NULL, cctxt->style, NULL,
2615 "xsltCompilerBuildInScopeNsList: "
2616 "realloc failed!\n");
2617 goto internal_err;
2618 }
2619 }
2620 nsi->list[nsi->totalNumber++] = ns;
2621 nsi->list[nsi->totalNumber] = NULL;
2622 }
2623
2624 ns = ns->next;
2625 }
2626 }
2627 node = node->parent;
2628 }
2629 if (nsi == NULL)
2630 return(NULL);
2631 /*
2632 * Move the default namespace to last position.
2633 */
2634 nsi->xpathNumber = nsi->totalNumber;
2635 for (i = 0; i < nsi->totalNumber; i++) {
2636 if (nsi->list[i]->prefix == NULL) {
2637 ns = nsi->list[i];
2638 nsi->list[i] = nsi->list[nsi->totalNumber-1];
2639 nsi->list[nsi->totalNumber-1] = ns;
2640 nsi->xpathNumber--;
2641 break;
2642 }
2643 }
2644 /*
2645 * Store the ns-list in the stylesheet.
2646 */
2647 if (xsltPointerListAddSize(
2648 (xsltPointerListPtr)cctxt->psData->inScopeNamespaces,
2649 (void *) nsi, 5) == -1)
2650 {
2651 xmlFree(nsi);
2652 nsi = NULL;
2653 xsltTransformError(NULL, cctxt->style, NULL,
2654 "xsltCompilerBuildInScopeNsList: failed to add ns-info.\n");
2655 goto internal_err;
2656 }
2657 /*
2658 * Notify of change in status wrt namespaces.
2659 */
2660 if (cctxt->inode != NULL)
2661 cctxt->inode->nsChanged = 1;
2662
2663 return(nsi);
2664
2665 internal_err:
2666 if (list != NULL)
2667 xmlFree(list);
2668 cctxt->style->errors++;
2669 return(NULL);
2670 }
2671
2672 static int
2673 xsltParseNsPrefixList(xsltCompilerCtxtPtr cctxt,
2674 xsltPointerListPtr list,
2675 xmlNodePtr node,
2676 const xmlChar *value)
2677 {
2678 xmlChar *cur, *end;
2679 xmlNsPtr ns;
2680
2681 if ((cctxt == NULL) || (value == NULL) || (list == NULL))
2682 return(-1);
2683
2684 list->number = 0;
2685
2686 cur = (xmlChar *) value;
2687 while (*cur != 0) {
2688 while (IS_BLANK(*cur)) cur++;
2689 if (*cur == 0)
2690 break;
2691 end = cur;
2692 while ((*end != 0) && (!IS_BLANK(*end))) end++;
2693 cur = xmlStrndup(cur, end - cur);
2694 if (cur == NULL) {
2695 cur = end;
2696 continue;
2697 }
2698 /*
2699 * TODO: Export and use xmlSearchNsByPrefixStrict()
2700 * in Libxml2, tree.c, since xmlSearchNs() is in most
2701 * cases not efficient and in some cases not correct.
2702 *
2703 * XSLT-2 TODO: XSLT 2.0 allows an additional "#all" value.
2704 */
2705 if ((cur[0] == '#') &&
2706 xmlStrEqual(cur, (const xmlChar *)"#default"))
2707 ns = xmlSearchNs(cctxt->style->doc, node, NULL);
2708 else
2709 ns = xmlSearchNs(cctxt->style->doc, node, cur);
2710
2711 if (ns == NULL) {
2712 /*
2713 * TODO: Better to report the attr-node, otherwise
2714 * the user won't know which attribute was invalid.
2715 */
2716 xsltTransformError(NULL, cctxt->style, node,
2717 "No namespace binding in scope for prefix '%s'.\n", cur);
2718 /*
2719 * XSLT-1.0: "It is an error if there is no namespace
2720 * bound to the prefix on the element bearing the
2721 * exclude-result-prefixes or xsl:exclude-result-prefixes
2722 * attribute."
2723 */
2724 cctxt->style->errors++;
2725 } else {
2726 #ifdef WITH_XSLT_DEBUG_PARSING
2727 xsltGenericDebug(xsltGenericDebugContext,
2728 "resolved prefix '%s'\n", cur);
2729 #endif
2730 /*
2731 * Note that we put the namespace name into the dict.
2732 */
2733 if (xsltPointerListAddSize(list,
2734 (void *) xmlDictLookup(cctxt->style->dict,
2735 ns->href, -1), 5) == -1)
2736 {
2737 xmlFree(cur);
2738 goto internal_err;
2739 }
2740 }
2741 xmlFree(cur);
2742
2743 cur = end;
2744 }
2745 return(0);
2746
2747 internal_err:
2748 cctxt->style->errors++;
2749 return(-1);
2750 }
2751
2752 /**
2753 * xsltCompilerUtilsCreateMergedList:
2754 * @dest: the destination list (optional)
2755 * @first: the first list
2756 * @second: the second list (optional)
2757 *
2758 * Appends the content of @second to @first into @destination.
2759 * If @destination is NULL a new list will be created.
2760 *
2761 * Returns the merged list of items or NULL if there's nothing to merge.
2762 */
2763 static xsltPointerListPtr
2764 xsltCompilerUtilsCreateMergedList(xsltPointerListPtr first,
2765 xsltPointerListPtr second)
2766 {
2767 xsltPointerListPtr ret;
2768 size_t num;
2769
2770 if (first)
2771 num = first->number;
2772 else
2773 num = 0;
2774 if (second)
2775 num += second->number;
2776 if (num == 0)
2777 return(NULL);
2778 ret = xsltPointerListCreate(num);
2779 if (ret == NULL)
2780 return(NULL);
2781 /*
2782 * Copy contents.
2783 */
2784 if ((first != NULL) && (first->number != 0)) {
2785 memcpy(ret->items, first->items,
2786 first->number * sizeof(void *));
2787 if ((second != NULL) && (second->number != 0))
2788 memcpy(ret->items + first->number, second->items,
2789 second->number * sizeof(void *));
2790 } else if ((second != NULL) && (second->number != 0))
2791 memcpy(ret->items, (void *) second->items,
2792 second->number * sizeof(void *));
2793 ret->number = num;
2794 return(ret);
2795 }
2796
2797 /*
2798 * xsltParseExclResultPrefixes:
2799 *
2800 * Create and store the list of in-scope namespaces for the given
2801 * node in the stylesheet. If there are no changes in the in-scope
2802 * namespaces then the last ns-info of the ancestor axis will be returned.
2803 * Compilation-time only.
2804 *
2805 * Returns the ns-info or NULL if there are no namespaces in scope.
2806 */
2807 static xsltPointerListPtr
2808 xsltParseExclResultPrefixes(xsltCompilerCtxtPtr cctxt, xmlNodePtr node,
2809 xsltPointerListPtr def,
2810 int instrCategory)
2811 {
2812 xsltPointerListPtr list = NULL;
2813 xmlChar *value;
2814 xmlAttrPtr attr;
2815
2816 if ((cctxt == NULL) || (node == NULL))
2817 return(NULL);
2818
2819 if (instrCategory == XSLT_ELEMENT_CATEGORY_XSLT)
2820 attr = xmlHasNsProp(node, BAD_CAST "exclude-result-prefixes", NULL);
2821 else
2822 attr = xmlHasNsProp(node, BAD_CAST "exclude-result-prefixes",
2823 XSLT_NAMESPACE);
2824 if (attr == NULL)
2825 return(def);
2826
2827 if (attr && (instrCategory == XSLT_ELEMENT_CATEGORY_LRE)) {
2828 /*
2829 * Mark the XSLT attr.
2830 */
2831 attr->psvi = (void *) xsltXSLTAttrMarker;
2832 }
2833
2834 if ((attr->children != NULL) &&
2835 (attr->children->content != NULL))
2836 value = attr->children->content;
2837 else {
2838 xsltTransformError(NULL, cctxt->style, node,
2839 "Attribute 'exclude-result-prefixes': Invalid value.\n");
2840 cctxt->style->errors++;
2841 return(def);
2842 }
2843
2844 if (xsltParseNsPrefixList(cctxt, cctxt->tmpList, node,
2845 BAD_CAST value) != 0)
2846 goto exit;
2847 if (cctxt->tmpList->number == 0)
2848 goto exit;
2849 /*
2850 * Merge the list with the inherited list.
2851 */
2852 list = xsltCompilerUtilsCreateMergedList(def, cctxt->tmpList);
2853 if (list == NULL)
2854 goto exit;
2855 /*
2856 * Store the list in the stylesheet/compiler context.
2857 */
2858 if (xsltPointerListAddSize(
2859 cctxt->psData->exclResultNamespaces, list, 5) == -1)
2860 {
2861 xsltPointerListFree(list);
2862 list = NULL;
2863 goto exit;
2864 }
2865 /*
2866 * Notify of change in status wrt namespaces.
2867 */
2868 if (cctxt->inode != NULL)
2869 cctxt->inode->nsChanged = 1;
2870
2871 exit:
2872 if (list != NULL)
2873 return(list);
2874 else
2875 return(def);
2876 }
2877
2878 /*
2879 * xsltParseExtElemPrefixes:
2880 *
2881 * Create and store the list of in-scope namespaces for the given
2882 * node in the stylesheet. If there are no changes in the in-scope
2883 * namespaces then the last ns-info of the ancestor axis will be returned.
2884 * Compilation-time only.
2885 *
2886 * Returns the ns-info or NULL if there are no namespaces in scope.
2887 */
2888 static xsltPointerListPtr
2889 xsltParseExtElemPrefixes(xsltCompilerCtxtPtr cctxt, xmlNodePtr node,
2890 xsltPointerListPtr def,
2891 int instrCategory)
2892 {
2893 xsltPointerListPtr list = NULL;
2894 xmlAttrPtr attr;
2895 xmlChar *value;
2896 int i;
2897
2898 if ((cctxt == NULL) || (node == NULL))
2899 return(NULL);
2900
2901 if (instrCategory == XSLT_ELEMENT_CATEGORY_XSLT)
2902 attr = xmlHasNsProp(node, BAD_CAST "extension-element-prefixes", NULL);
2903 else
2904 attr = xmlHasNsProp(node, BAD_CAST "extension-element-prefixes",
2905 XSLT_NAMESPACE);
2906 if (attr == NULL)
2907 return(def);
2908
2909 if (attr && (instrCategory == XSLT_ELEMENT_CATEGORY_LRE)) {
2910 /*
2911 * Mark the XSLT attr.
2912 */
2913 attr->psvi = (void *) xsltXSLTAttrMarker;
2914 }
2915
2916 if ((attr->children != NULL) &&
2917 (attr->children->content != NULL))
2918 value = attr->children->content;
2919 else {
2920 xsltTransformError(NULL, cctxt->style, node,
2921 "Attribute 'extension-element-prefixes': Invalid value.\n");
2922 cctxt->style->errors++;
2923 return(def);
2924 }
2925
2926
2927 if (xsltParseNsPrefixList(cctxt, cctxt->tmpList, node,
2928 BAD_CAST value) != 0)
2929 goto exit;
2930
2931 if (cctxt->tmpList->number == 0)
2932 goto exit;
2933 /*
2934 * REVISIT: Register the extension namespaces.
2935 */
2936 for (i = 0; i < cctxt->tmpList->number; i++)
2937 xsltRegisterExtPrefix(cctxt->style, NULL,
2938 BAD_CAST cctxt->tmpList->items[i]);
2939 /*
2940 * Merge the list with the inherited list.
2941 */
2942 list = xsltCompilerUtilsCreateMergedList(def, cctxt->tmpList);
2943 if (list == NULL)
2944 goto exit;
2945 /*
2946 * Store the list in the stylesheet.
2947 */
2948 if (xsltPointerListAddSize(
2949 cctxt->psData->extElemNamespaces, list, 5) == -1)
2950 {
2951 xsltPointerListFree(list);
2952 list = NULL;
2953 goto exit;
2954 }
2955 /*
2956 * Notify of change in status wrt namespaces.
2957 */
2958 if (cctxt->inode != NULL)
2959 cctxt->inode->nsChanged = 1;
2960
2961 exit:
2962 if (list != NULL)
2963 return(list);
2964 else
2965 return(def);
2966 }
2967
2968 /*
2969 * xsltParseAttrXSLTVersion:
2970 *
2971 * @cctxt: the compilation context
2972 * @node: the element-node
2973 * @isXsltElem: whether this is an XSLT element
2974 *
2975 * Parses the attribute xsl:version.
2976 *
2977 * Returns 1 if there was such an attribute, 0 if not and
2978 * -1 if an internal or API error occured.
2979 */
2980 static int
2981 xsltParseAttrXSLTVersion(xsltCompilerCtxtPtr cctxt, xmlNodePtr node,
2982 int instrCategory)
2983 {
2984 xmlChar *value;
2985 xmlAttrPtr attr;
2986
2987 if ((cctxt == NULL) || (node == NULL))
2988 return(-1);
2989
2990 if (instrCategory == XSLT_ELEMENT_CATEGORY_XSLT)
2991 attr = xmlHasNsProp(node, BAD_CAST "version", NULL);
2992 else
2993 attr = xmlHasNsProp(node, BAD_CAST "version", XSLT_NAMESPACE);
2994
2995 if (attr == NULL)
2996 return(0);
2997
2998 attr->psvi = (void *) xsltXSLTAttrMarker;
2999
3000 if ((attr->children != NULL) &&
3001 (attr->children->content != NULL))
3002 value = attr->children->content;
3003 else {
3004 xsltTransformError(NULL, cctxt->style, node,
3005 "Attribute 'version': Invalid value.\n");
3006 cctxt->style->errors++;
3007 return(1);
3008 }
3009
3010 if (! xmlStrEqual(value, (const xmlChar *)"1.0")) {
3011 cctxt->inode->forwardsCompat = 1;
3012 /*
3013 * TODO: To what extent do we support the
3014 * forwards-compatible mode?
3015 */
3016 /*
3017 * Report this only once per compilation episode.
3018 */
3019 if (! cctxt->hasForwardsCompat) {
3020 cctxt->hasForwardsCompat = 1;
3021 cctxt->errSeverity = XSLT_ERROR_SEVERITY_WARNING;
3022 xsltTransformError(NULL, cctxt->style, node,
3023 "Warning: the attribute xsl:version specifies a value "
3024 "different from '1.0'. Switching to forwards-compatible "
3025 "mode. Only features of XSLT 1.0 are supported by this "
3026 "processor.\n");
3027 cctxt->style->warnings++;
3028 cctxt->errSeverity = XSLT_ERROR_SEVERITY_ERROR;
3029 }
3030 } else {
3031 cctxt->inode->forwardsCompat = 0;
3032 }
3033
3034 if (attr && (instrCategory == XSLT_ELEMENT_CATEGORY_LRE)) {
3035 /*
3036 * Set a marker on XSLT attributes.
3037 */
3038 attr->psvi = (void *) xsltXSLTAttrMarker;
3039 }
3040 return(1);
3041 }
3042
3043 static int
3044 xsltParsePreprocessStylesheetTree(xsltCompilerCtxtPtr cctxt, xmlNodePtr node)
3045 {
3046 xmlNodePtr deleteNode, cur, txt, textNode = NULL;
3047 xmlDocPtr doc;
3048 xsltStylesheetPtr style;
3049 int internalize = 0, findSpaceAttr;
3050 int xsltStylesheetElemDepth;
3051 xmlAttrPtr attr;
3052 xmlChar *value;
3053 const xmlChar *name, *nsNameXSLT = NULL;
3054 int strictWhitespace, inXSLText = 0;
3055 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
3056 xsltNsMapPtr nsMapItem;
3057 #endif
3058
3059 if ((cctxt == NULL) || (cctxt->style == NULL) ||
3060 (node == NULL) || (node->type != XML_ELEMENT_NODE))
3061 return(-1);
3062
3063 doc = node->doc;
3064 if (doc == NULL)
3065 goto internal_err;
3066
3067 style = cctxt->style;
3068 if ((style->dict != NULL) && (doc->dict == style->dict))
3069 internalize = 1;
3070 else
3071 style->internalized = 0;
3072
3073 /*
3074 * Init value of xml:space. Since this might be an embedded
3075 * stylesheet, this is needed to be performed on the element
3076 * where the stylesheet is rooted at, taking xml:space of
3077 * ancestors into account.
3078 */
3079 if (! cctxt->simplified)
3080 xsltStylesheetElemDepth = cctxt->depth +1;
3081 else
3082 xsltStylesheetElemDepth = 0;
3083
3084 if (xmlNodeGetSpacePreserve(node) != 1)
3085 cctxt->inode->preserveWhitespace = 0;
3086 else
3087 cctxt->inode->preserveWhitespace = 1;
3088
3089 /*
3090 * Eval if we should keep the old incorrect behaviour.
3091 */
3092 strictWhitespace = (cctxt->strict != 0) ? 1 : 0;
3093
3094 nsNameXSLT = xsltConstNamespaceNameXSLT;
3095
3096 deleteNode = NULL;
3097 cur = node;
3098 while (cur != NULL) {
3099 if (deleteNode != NULL) {
3100
3101 #ifdef WITH_XSLT_DEBUG_BLANKS
3102 xsltGenericDebug(xsltGenericDebugContext,
3103 "xsltParsePreprocessStylesheetTree: removing node\n");
3104 #endif
3105 xmlUnlinkNode(deleteNode);
3106 xmlFreeNode(deleteNode);
3107 deleteNode = NULL;
3108 }
3109 if (cur->type == XML_ELEMENT_NODE) {
3110
3111 /*
3112 * Clear the PSVI field.
3113 */
3114 cur->psvi = NULL;
3115
3116 xsltCompilerNodePush(cctxt, cur);
3117
3118 inXSLText = 0;
3119 textNode = NULL;
3120 findSpaceAttr = 1;
3121 cctxt->inode->stripWhitespace = 0;
3122 /*
3123 * TODO: I'd love to use a string pointer comparison here :-/
3124 */
3125 if (IS_XSLT_ELEM(cur)) {
3126 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
3127 if (cur->ns->href != nsNameXSLT) {
3128 nsMapItem = xsltNewNamespaceMapItem(cctxt,
3129 doc, cur->ns, cur);
3130 if (nsMapItem == NULL)
3131 goto internal_err;
3132 cur->ns->href = nsNameXSLT;
3133 }
3134 #endif
3135
3136 if (cur->name == NULL)
3137 goto process_attributes;
3138 /*
3139 * Mark the XSLT element for later recognition.
3140 * TODO: Using the marker is still too dangerous, since if
3141 * the parsing mechanism leaves out an XSLT element, then
3142 * this might hit the transformation-mechanism, which
3143 * will break if it doesn't expect such a marker.
3144 */
3145 /* cur->psvi = (void *) xsltXSLTElemMarker; */
3146
3147 /*
3148 * XSLT 2.0: "Any whitespace text node whose parent is
3149 * one of the following elements is removed from the "
3150 * tree, regardless of any xml:space attributes:..."
3151 * xsl:apply-imports,
3152 * xsl:apply-templates,
3153 * xsl:attribute-set,
3154 * xsl:call-template,
3155 * xsl:choose,
3156 * xsl:stylesheet, xsl:transform.
3157 * XSLT 2.0: xsl:analyze-string,
3158 * xsl:character-map,
3159 * xsl:next-match
3160 *
3161 * TODO: I'd love to use a string pointer comparison here :-/
3162 */
3163 name = cur->name;
3164 switch (*name) {
3165 case 't':
3166 if ((name[0] == 't') && (name[1] == 'e') &&
3167 (name[2] == 'x') && (name[3] == 't') &&
3168 (name[4] == 0))
3169 {
3170 /*
3171 * Process the xsl:text element.
3172 * ----------------------------
3173 * Mark it for later recognition.
3174 */
3175 cur->psvi = (void *) xsltXSLTTextMarker;
3176 /*
3177 * For stylesheets, the set of
3178 * whitespace-preserving element names
3179 * consists of just xsl:text.
3180 */
3181 findSpaceAttr = 0;
3182 cctxt->inode->preserveWhitespace = 1;
3183 inXSLText = 1;
3184 }
3185 break;
3186 case 'c':
3187 if (xmlStrEqual(name, BAD_CAST "choose") ||
3188 xmlStrEqual(name, BAD_CAST "call-template"))
3189 cctxt->inode->stripWhitespace = 1;
3190 break;
3191 case 'a':
3192 if (xmlStrEqual(name, BAD_CAST "apply-templates") ||
3193 xmlStrEqual(name, BAD_CAST "apply-imports") ||
3194 xmlStrEqual(name, BAD_CAST "attribute-set"))
3195
3196 cctxt->inode->stripWhitespace = 1;
3197 break;
3198 default:
3199 if (xsltStylesheetElemDepth == cctxt->depth) {
3200 /*
3201 * This is a xsl:stylesheet/xsl:transform.
3202 */
3203 cctxt->inode->stripWhitespace = 1;
3204 break;
3205 }
3206
3207 if ((cur->prev != NULL) &&
3208 (cur->prev->type == XML_TEXT_NODE))
3209 {
3210 /*
3211 * XSLT 2.0 : "Any whitespace text node whose
3212 * following-sibling node is an xsl:param or
3213 * xsl:sort element is removed from the tree,
3214 * regardless of any xml:space attributes."
3215 */
3216 if (((*name == 'p') || (*name == 's')) &&
3217 (xmlStrEqual(name, BAD_CAST "param") ||
3218 xmlStrEqual(name, BAD_CAST "sort")))
3219 {
3220 do {
3221 if (IS_BLANK_NODE(cur->prev)) {
3222 txt = cur->prev;
3223 xmlUnlinkNode(txt);
3224 xmlFreeNode(txt);
3225 } else {
3226 /*
3227 * This will result in a content
3228 * error, when hitting the parsing
3229 * functions.
3230 */
3231 break;
3232 }
3233 } while (cur->prev);
3234 }
3235 }
3236 break;
3237 }
3238 }
3239
3240 process_attributes:
3241 /*
3242 * Process attributes.
3243 * ------------------
3244 */
3245 if (cur->properties != NULL) {
3246 if (cur->children == NULL)
3247 findSpaceAttr = 0;
3248 attr = cur->properties;
3249 do {
3250 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
3251 if ((attr->ns) && (attr->ns->href != nsNameXSLT) &&
3252 xmlStrEqual(attr->ns->href, nsNameXSLT))
3253 {
3254 nsMapItem = xsltNewNamespaceMapItem(cctxt,
3255 doc, attr->ns, cur);
3256 if (nsMapItem == NULL)
3257 goto internal_err;
3258 attr->ns->href = nsNameXSLT;
3259 }
3260 #endif
3261 if (internalize) {
3262 /*
3263 * Internalize the attribute's value; the goal is to
3264 * speed up operations and minimize used space by
3265 * compiled stylesheets.
3266 */
3267 txt = attr->children;
3268 /*
3269 * NOTE that this assumes only one
3270 * text-node in the attribute's content.
3271 */
3272 if ((txt != NULL) && (txt->content != NULL) &&
3273 (!xmlDictOwns(style->dict, txt->content)))
3274 {
3275 value = (xmlChar *) xmlDictLookup(style->dict,
3276 txt->content, -1);
3277 xmlNodeSetContent(txt, NULL);
3278 txt->content = value;
3279 }
3280 }
3281 /*
3282 * Process xml:space attributes.
3283 * ----------------------------
3284 */
3285 if ((findSpaceAttr != 0) &&
3286 (attr->ns != NULL) &&
3287 (attr->name != NULL) &&
3288 (attr->name[0] == 's') &&
3289 (attr->ns->prefix != NULL) &&
3290 (attr->ns->prefix[0] == 'x') &&
3291 (attr->ns->prefix[1] == 'm') &&
3292 (attr->ns->prefix[2] == 'l') &&
3293 (attr->ns->prefix[3] == 0))
3294 {
3295 value = xmlGetNsProp(cur, BAD_CAST "space",
3296 XML_XML_NAMESPACE);
3297 if (value != NULL) {
3298 if (xmlStrEqual(value, BAD_CAST "preserve")) {
3299 cctxt->inode->preserveWhitespace = 1;
3300 } else if (xmlStrEqual(value, BAD_CAST "default")) {
3301 cctxt->inode->preserveWhitespace = 0;
3302 } else {
3303 /* Invalid value for xml:space. */
3304 xsltTransformError(NULL, style, cur,
3305 "Attribute xml:space: Invalid value.\n");
3306 cctxt->style->warnings++;
3307 }
3308 findSpaceAttr = 0;
3309 xmlFree(value);
3310 }
3311
3312 }
3313 attr = attr->next;
3314 } while (attr != NULL);
3315 }
3316 /*
3317 * We'll descend into the children of element nodes only.
3318 */
3319 if (cur->children != NULL) {
3320 cur = cur->children;
3321 continue;
3322 }
3323 } else if ((cur->type == XML_TEXT_NODE) ||
3324 (cur->type == XML_CDATA_SECTION_NODE))
3325 {
3326 /*
3327 * Merge adjacent text/CDATA-section-nodes
3328 * ---------------------------------------
3329 * In order to avoid breaking of existing stylesheets,
3330 * if the old behaviour is wanted (strictWhitespace == 0),
3331 * then we *won't* merge adjacent text-nodes
3332 * (except in xsl:text); this will ensure that whitespace-only
3333 * text nodes are (incorrectly) not stripped in some cases.
3334 *
3335 * Example: : <foo> <!-- bar -->zoo</foo>
3336 * Corrent (strict) result: <foo> zoo</foo>
3337 * Incorrect (old) result : <foo>zoo</foo>
3338 *
3339 * NOTE that we *will* merge adjacent text-nodes if
3340 * they are in xsl:text.
3341 * Example, the following:
3342 * <xsl:text> <!-- bar -->zoo<xsl:text>
3343 * will result in both cases in:
3344 * <xsl:text> zoo<xsl:text>
3345 */
3346 cur->type = XML_TEXT_NODE;
3347 if ((strictWhitespace != 0) || (inXSLText != 0)) {
3348 /*
3349 * New behaviour; merge nodes.
3350 */
3351 if (textNode == NULL)
3352 textNode = cur;
3353 else {
3354 if (cur->content != NULL)
3355 xmlNodeAddContent(textNode, cur->content);
3356 deleteNode = cur;
3357 }
3358 if ((cur->next == NULL) ||
3359 (cur->next->type == XML_ELEMENT_NODE))
3360 goto end_of_text;
3361 else
3362 goto next_sibling;
3363 } else {
3364 /*
3365 * Old behaviour.
3366 */
3367 if (textNode == NULL)
3368 textNode = cur;
3369 goto end_of_text;
3370 }
3371 } else if ((cur->type == XML_COMMENT_NODE) ||
3372 (cur->type == XML_PI_NODE))
3373 {
3374 /*
3375 * Remove processing instructions and comments.
3376 */
3377 deleteNode = cur;
3378 if ((cur->next == NULL) ||
3379 (cur->next->type == XML_ELEMENT_NODE))
3380 goto end_of_text;
3381 else
3382 goto next_sibling;
3383 } else {
3384 textNode = NULL;
3385 /*
3386 * Invalid node-type for this data-model.
3387 */
3388 xsltTransformError(NULL, style, cur,
3389 "Invalid type of node for the XSLT data model.\n");
3390 cctxt->style->errors++;
3391 goto next_sibling;
3392 }
3393
3394 end_of_text:
3395 if (textNode) {
3396 value = textNode->content;
3397 /*
3398 * At this point all adjacent text/CDATA-section nodes
3399 * have been merged.
3400 *
3401 * Strip whitespace-only text-nodes.
3402 * (cctxt->inode->stripWhitespace)
3403 */
3404 if ((value == NULL) || (*value == 0) ||
3405 (((cctxt->inode->stripWhitespace) ||
3406 (! cctxt->inode->preserveWhitespace)) &&
3407 IS_BLANK(*value) &&
3408 xsltIsBlank(value)))
3409 {
3410 if (textNode != cur) {
3411 xmlUnlinkNode(textNode);
3412 xmlFreeNode(textNode);
3413 } else
3414 deleteNode = textNode;
3415 textNode = NULL;
3416 goto next_sibling;
3417 }
3418 /*
3419 * Convert CDATA-section nodes to text-nodes.
3420 * TODO: Can this produce problems?
3421 */
3422 if (textNode->type != XML_TEXT_NODE) {
3423 textNode->type = XML_TEXT_NODE;
3424 textNode->name = xmlStringText;
3425 }
3426 if (internalize &&
3427 (textNode->content != NULL) &&
3428 (!xmlDictOwns(style->dict, textNode->content)))
3429 {
3430 /*
3431 * Internalize the string.
3432 */
3433 value = (xmlChar *) xmlDictLookup(style->dict,
3434 textNode->content, -1);
3435 xmlNodeSetContent(textNode, NULL);
3436 textNode->content = value;
3437 }
3438 textNode = NULL;
3439 /*
3440 * Note that "disable-output-escaping" of the xsl:text
3441 * element will be applied at a later level, when
3442 * XSLT elements are processed.
3443 */
3444 }
3445
3446 next_sibling:
3447 if (cur->type == XML_ELEMENT_NODE) {
3448 xsltCompilerNodePop(cctxt, cur);
3449 }
3450 if (cur == node)
3451 break;
3452 if (cur->next != NULL) {
3453 cur = cur->next;
3454 } else {
3455 cur = cur->parent;
3456 inXSLText = 0;
3457 goto next_sibling;
3458 };
3459 }
3460 if (deleteNode != NULL) {
3461 #ifdef WITH_XSLT_DEBUG_PARSING
3462 xsltGenericDebug(xsltGenericDebugContext,
3463 "xsltParsePreprocessStylesheetTree: removing node\n");
3464 #endif
3465 xmlUnlinkNode(deleteNode);
3466 xmlFreeNode(deleteNode);
3467 }
3468 return(0);
3469
3470 internal_err:
3471 return(-1);
3472 }
3473
3474 #endif /* XSLT_REFACTORED */
3475
3476 #ifdef XSLT_REFACTORED
3477 #else
3478 static void
3479 xsltPreprocessStylesheet(xsltStylesheetPtr style, xmlNodePtr cur)
3480 {
3481 xmlNodePtr deleteNode, styleelem;
3482 int internalize = 0;
3483
3484 if ((style == NULL) || (cur == NULL))
3485 return;
3486
3487 if ((cur->doc != NULL) && (style->dict != NULL) &&
3488 (cur->doc->dict == style->dict))
3489 internalize = 1;
3490 else
3491 style->internalized = 0;
3492
3493 if ((cur != NULL) && (IS_XSLT_ELEM(cur)) &&
3494 (IS_XSLT_NAME(cur, "stylesheet"))) {
3495 styleelem = cur;
3496 } else {
3497 styleelem = NULL;
3498 }
3499
3500 /*
3501 * This content comes from the stylesheet
3502 * For stylesheets, the set of whitespace-preserving
3503 * element names consists of just xsl:text.
3504 */
3505 deleteNode = NULL;
3506 while (cur != NULL) {
3507 if (deleteNode != NULL) {
3508 #ifdef WITH_XSLT_DEBUG_BLANKS
3509 xsltGenericDebug(xsltGenericDebugContext,
3510 "xsltPreprocessStylesheet: removing ignorable blank node\n");
3511 #endif
3512 xmlUnlinkNode(deleteNode);
3513 xmlFreeNode(deleteNode);
3514 deleteNode = NULL;
3515 }
3516 if (cur->type == XML_ELEMENT_NODE) {
3517 int exclPrefixes;
3518 /*
3519 * Internalize attributes values.
3520 */
3521 if ((internalize) && (cur->properties != NULL)) {
3522 xmlAttrPtr attr = cur->properties;
3523 xmlNodePtr txt;
3524
3525 while (attr != NULL) {
3526 txt = attr->children;
3527 if ((txt != NULL) && (txt->type == XML_TEXT_NODE) &&
3528 (txt->content != NULL) &&
3529 (!xmlDictOwns(style->dict, txt->content)))
3530 {
3531 xmlChar *tmp;
3532
3533 /*
3534 * internalize the text string, goal is to speed
3535 * up operations and minimize used space by compiled
3536 * stylesheets.
3537 */
3538 tmp = (xmlChar *) xmlDictLookup(style->dict,
3539 txt->content, -1);
3540 if (tmp != txt->content) {
3541 xmlNodeSetContent(txt, NULL);
3542 txt->content = tmp;
3543 }
3544 }
3545 attr = attr->next;
3546 }
3547 }
3548 if (IS_XSLT_ELEM(cur)) {
3549 exclPrefixes = 0;
3550 if (IS_XSLT_NAME(cur, "text")) {
3551 for (;exclPrefixes > 0;exclPrefixes--)
3552 exclPrefixPop(style);
3553 goto skip_children;
3554 }
3555 } else {
3556 exclPrefixes = xsltParseStylesheetExcludePrefix(style, cur, 0);
3557 }
3558
3559 if ((cur->nsDef != NULL) && (style->exclPrefixNr > 0)) {
3560 xmlNsPtr ns = cur->nsDef, prev = NULL, next;
3561 xmlNodePtr root = NULL;
3562 int i, moved;
3563
3564 root = xmlDocGetRootElement(cur->doc);
3565 if ((root != NULL) && (root != cur)) {
3566 while (ns != NULL) {
3567 moved = 0;
3568 next = ns->next;
3569 for (i = 0;i < style->exclPrefixNr;i++) {
3570 if ((ns->prefix != NULL) &&
3571 (xmlStrEqual(ns->href,
3572 style->exclPrefixTab[i]))) {
3573 /*
3574 * Move the namespace definition on the root
3575 * element to avoid duplicating it without
3576 * loosing it.
3577 */
3578 if (prev == NULL) {
3579 cur->nsDef = ns->next;
3580 } else {
3581 prev->next = ns->next;
3582 }
3583 ns->next = root->nsDef;
3584 root->nsDef = ns;
3585 moved = 1;
3586 break;
3587 }
3588 }
3589 if (moved == 0)
3590 prev = ns;
3591 ns = next;
3592 }
3593 }
3594 }
3595 /*
3596 * If we have prefixes locally, recurse and pop them up when
3597 * going back
3598 */
3599 if (exclPrefixes > 0) {
3600 xsltPreprocessStylesheet(style, cur->children);
3601 for (;exclPrefixes > 0;exclPrefixes--)
3602 exclPrefixPop(style);
3603 goto skip_children;
3604 }
3605 } else if (cur->type == XML_TEXT_NODE) {
3606 if (IS_BLANK_NODE(cur)) {
3607 if (xmlNodeGetSpacePreserve(cur->parent) != 1) {
3608 deleteNode = cur;
3609 }
3610 } else if ((cur->content != NULL) && (internalize) &&
3611 (!xmlDictOwns(style->dict, cur->content))) {
3612 xmlChar *tmp;
3613
3614 /*
3615 * internalize the text string, goal is to speed
3616 * up operations and minimize used space by compiled
3617 * stylesheets.
3618 */
3619 tmp = (xmlChar *) xmlDictLookup(style->dict, cur->content, -1);
3620 xmlNodeSetContent(cur, NULL);
3621 cur->content = tmp;
3622 }
3623 } else if ((cur->type != XML_ELEMENT_NODE) &&
3624 (cur->type != XML_CDATA_SECTION_NODE)) {
3625 deleteNode = cur;
3626 goto skip_children;
3627 }
3628
3629 /*
3630 * Skip to next node. In case of a namespaced element children of
3631 * the stylesheet and not in the XSLT namespace and not an extension
3632 * element, ignore its content.
3633 */
3634 if ((cur->type == XML_ELEMENT_NODE) && (cur->ns != NULL) &&
3635 (styleelem != NULL) && (cur->parent == styleelem) &&
3636 (!xmlStrEqual(cur->ns->href, XSLT_NAMESPACE)) &&
3637 (!xsltCheckExtURI(style, cur->ns->href))) {
3638 goto skip_children;
3639 } else if (cur->children != NULL) {
3640 if ((cur->children->type != XML_ENTITY_DECL) &&
3641 (cur->children->type != XML_ENTITY_REF_NODE) &&
3642 (cur->children->type != XML_ENTITY_NODE)) {
3643 cur = cur->children;
3644 continue;
3645 }
3646 }
3647
3648 skip_children:
3649 if (cur->next != NULL) {
3650 cur = cur->next;
3651 continue;
3652 }
3653 do {
3654
3655 cur = cur->parent;
3656 if (cur == NULL)
3657 break;
3658 if (cur == (xmlNodePtr) style->doc) {
3659 cur = NULL;
3660 break;
3661 }
3662 if (cur->next != NULL) {
3663 cur = cur->next;
3664 break;
3665 }
3666 } while (cur != NULL);
3667 }
3668 if (deleteNode != NULL) {
3669 #ifdef WITH_XSLT_DEBUG_PARSING
3670 xsltGenericDebug(xsltGenericDebugContext,
3671 "xsltPreprocessStylesheet: removing ignorable blank node\n");
3672 #endif
3673 xmlUnlinkNode(deleteNode);
3674 xmlFreeNode(deleteNode);
3675 }
3676 }
3677 #endif /* end of else XSLT_REFACTORED */
3678
3679 /**
3680 * xsltGatherNamespaces:
3681 * @style: the XSLT stylesheet
3682 *
3683 * Browse the stylesheet and build the namspace hash table which
3684 * will be used for XPath interpretation. If needed do a bit of normalization
3685 */
3686
3687 static void
3688 xsltGatherNamespaces(xsltStylesheetPtr style) {
3689 xmlNodePtr cur;
3690 const xmlChar *URI;
3691
3692 if (style == NULL)
3693 return;
3694 /*
3695 * TODO: basically if the stylesheet uses the same prefix for different
3696 * patterns, well they may be in problem, hopefully they will get
3697 * a warning first.
3698 */
3699 /*
3700 * TODO: Eliminate the use of the hash for XPath expressions.
3701 * An expression should be evaluated in the context of the in-scope
3702 * namespaces; eliminate the restriction of an XML document to contain
3703 * no duplicate prefixes for different namespace names.
3704 *
3705 */
3706 cur = xmlDocGetRootElement(style->doc);
3707 while (cur != NULL) {
3708 if (cur->type == XML_ELEMENT_NODE) {
3709 xmlNsPtr ns = cur->nsDef;
3710 while (ns != NULL) {
3711 if (ns->prefix != NULL) {
3712 if (style->nsHash == NULL) {
3713 style->nsHash = xmlHashCreate(10);
3714 if (style->nsHash == NULL) {
3715 xsltTransformError(NULL, style, cur,
3716 "xsltGatherNamespaces: failed to create hash table\n");
3717 style->errors++;
3718 return;
3719 }
3720 }
3721 URI = xmlHashLookup(style->nsHash, ns->prefix);
3722 if ((URI != NULL) && (!xmlStrEqual(URI, ns->href))) {
3723 xsltTransformError(NULL, style, cur,
3724 "Namespaces prefix %s used for multiple namespaces\n",ns->prefix);
3725 style->warnings++;
3726 } else if (URI == NULL) {
3727 xmlHashUpdateEntry(style->nsHash, ns->prefix,
3728 (void *) ns->href, NULL);
3729
3730 #ifdef WITH_XSLT_DEBUG_PARSING
3731 xsltGenericDebug(xsltGenericDebugContext,
3732 "Added namespace: %s mapped to %s\n", ns->prefix, ns->href);
3733 #endif
3734 }
3735 }
3736 ns = ns->next;
3737 }
3738 }
3739
3740 /*
3741 * Skip to next node
3742 */
3743 if (cur->children != NULL) {
3744 if (cur->children->type != XML_ENTITY_DECL) {
3745 cur = cur->children;
3746 continue;
3747 }
3748 }
3749 if (cur->next != NULL) {
3750 cur = cur->next;
3751 continue;
3752 }
3753
3754 do {
3755 cur = cur->parent;
3756 if (cur == NULL)
3757 break;
3758 if (cur == (xmlNodePtr) style->doc) {
3759 cur = NULL;
3760 break;
3761 }
3762 if (cur->next != NULL) {
3763 cur = cur->next;
3764 break;
3765 }
3766 } while (cur != NULL);
3767 }
3768 }
3769
3770 #ifdef XSLT_REFACTORED
3771
3772 static xsltStyleType
3773 xsltGetXSLTElementTypeByNode(xsltCompilerCtxtPtr cctxt,
3774 xmlNodePtr node)
3775 {
3776 if ((node == NULL) || (node->type != XML_ELEMENT_NODE) ||
3777 (node->name == NULL))
3778 return(0);
3779
3780 if (node->name[0] == 'a') {
3781 if (IS_XSLT_NAME(node, "apply-templates"))
3782 return(XSLT_FUNC_APPLYTEMPLATES);
3783 else if (IS_XSLT_NAME(node, "attribute"))
3784 return(XSLT_FUNC_ATTRIBUTE);
3785 else if (IS_XSLT_NAME(node, "apply-imports"))
3786 return(XSLT_FUNC_APPLYIMPORTS);
3787 else if (IS_XSLT_NAME(node, "attribute-set"))
3788 return(0);
3789
3790 } else if (node->name[0] == 'c') {
3791 if (IS_XSLT_NAME(node, "choose"))
3792 return(XSLT_FUNC_CHOOSE);
3793 else if (IS_XSLT_NAME(node, "copy"))
3794 return(XSLT_FUNC_COPY);
3795 else if (IS_XSLT_NAME(node, "copy-of"))
3796 return(XSLT_FUNC_COPYOF);
3797 else if (IS_XSLT_NAME(node, "call-template"))
3798 return(XSLT_FUNC_CALLTEMPLATE);
3799 else if (IS_XSLT_NAME(node, "comment"))
3800 return(XSLT_FUNC_COMMENT);
3801
3802 } else if (node->name[0] == 'd') {
3803 if (IS_XSLT_NAME(node, "document"))
3804 return(XSLT_FUNC_DOCUMENT);
3805 else if (IS_XSLT_NAME(node, "decimal-format"))
3806 return(0);
3807
3808 } else if (node->name[0] == 'e') {
3809 if (IS_XSLT_NAME(node, "element"))
3810 return(XSLT_FUNC_ELEMENT);
3811
3812 } else if (node->name[0] == 'f') {
3813 if (IS_XSLT_NAME(node, "for-each"))
3814 return(XSLT_FUNC_FOREACH);
3815 else if (IS_XSLT_NAME(node, "fallback"))
3816 return(XSLT_FUNC_FALLBACK);
3817
3818 } else if (*(node->name) == 'i') {
3819 if (IS_XSLT_NAME(node, "if"))
3820 return(XSLT_FUNC_IF);
3821 else if (IS_XSLT_NAME(node, "include"))
3822 return(0);
3823 else if (IS_XSLT_NAME(node, "import"))
3824 return(0);
3825
3826 } else if (*(node->name) == 'k') {
3827 if (IS_XSLT_NAME(node, "key"))
3828 return(0);
3829
3830 } else if (*(node->name) == 'm') {
3831 if (IS_XSLT_NAME(node, "message"))
3832 return(XSLT_FUNC_MESSAGE);
3833
3834 } else if (*(node->name) == 'n') {
3835 if (IS_XSLT_NAME(node, "number"))
3836 return(XSLT_FUNC_NUMBER);
3837 else if (IS_XSLT_NAME(node, "namespace-alias"))
3838 return(0);
3839
3840 } else if (*(node->name) == 'o') {
3841 if (IS_XSLT_NAME(node, "otherwise"))
3842 return(XSLT_FUNC_OTHERWISE);
3843 else if (IS_XSLT_NAME(node, "output"))
3844 return(0);
3845
3846 } else if (*(node->name) == 'p') {
3847 if (IS_XSLT_NAME(node, "param"))
3848 return(XSLT_FUNC_PARAM);
3849 else if (IS_XSLT_NAME(node, "processing-instruction"))
3850 return(XSLT_FUNC_PI);
3851 else if (IS_XSLT_NAME(node, "preserve-space"))
3852 return(0);
3853
3854 } else if (*(node->name) == 's') {
3855 if (IS_XSLT_NAME(node, "sort"))
3856 return(XSLT_FUNC_SORT);
3857 else if (IS_XSLT_NAME(node, "strip-space"))
3858 return(0);
3859 else if (IS_XSLT_NAME(node, "stylesheet"))
3860 return(0);
3861
3862 } else if (node->name[0] == 't') {
3863 if (IS_XSLT_NAME(node, "text"))
3864 return(XSLT_FUNC_TEXT);
3865 else if (IS_XSLT_NAME(node, "template"))
3866 return(0);
3867 else if (IS_XSLT_NAME(node, "transform"))
3868 return(0);
3869
3870 } else if (*(node->name) == 'v') {
3871 if (IS_XSLT_NAME(node, "value-of"))
3872 return(XSLT_FUNC_VALUEOF);
3873 else if (IS_XSLT_NAME(node, "variable"))
3874 return(XSLT_FUNC_VARIABLE);
3875
3876 } else if (*(node->name) == 'w') {
3877 if (IS_XSLT_NAME(node, "when"))
3878 return(XSLT_FUNC_WHEN);
3879 if (IS_XSLT_NAME(node, "with-param"))
3880 return(XSLT_FUNC_WITHPARAM);
3881 }
3882 return(0);
3883 }
3884
3885 /**
3886 * xsltParseAnyXSLTElem:
3887 *
3888 * @cctxt: the compilation context
3889 * @elem: the element node of the XSLT instruction
3890 *
3891 * Parses, validates the content models and compiles XSLT instructions.
3892 *
3893 * Returns 0 if everything's fine;
3894 * -1 on API or internal errors.
3895 */
3896 int
3897 xsltParseAnyXSLTElem(xsltCompilerCtxtPtr cctxt, xmlNodePtr elem)
3898 {
3899 if ((cctxt == NULL) || (elem == NULL) ||
3900 (elem->type != XML_ELEMENT_NODE))
3901 return(-1);
3902
3903 elem->psvi = NULL;
3904
3905 if (! (IS_XSLT_ELEM_FAST(elem)))
3906 return(-1);
3907 /*
3908 * Detection of handled content of extension instructions.
3909 */
3910 if (cctxt->inode->category == XSLT_ELEMENT_CATEGORY_EXTENSION) {
3911 cctxt->inode->extContentHandled = 1;
3912 }
3913
3914 xsltCompilerNodePush(cctxt, elem);
3915 /*
3916 * URGENT TODO: Find a way to speed up this annoying redundant
3917 * textual node-name and namespace comparison.
3918 */
3919 if (cctxt->inode->prev->curChildType != 0)
3920 cctxt->inode->type = cctxt->inode->prev->curChildType;
3921 else
3922 cctxt->inode->type = xsltGetXSLTElementTypeByNode(cctxt, elem);
3923 /*
3924 * Update the in-scope namespaces if needed.
3925 */
3926 if (elem->nsDef != NULL)
3927 cctxt->inode->inScopeNs =
3928 xsltCompilerBuildInScopeNsList(cctxt, elem);
3929 /*
3930 * xsltStylePreCompute():
3931 * This will compile the information found on the current
3932 * element's attributes. NOTE that this won't process the
3933 * children of the instruction.
3934 */
3935 xsltStylePreCompute(cctxt->style, elem);
3936 /*
3937 * TODO: How to react on errors in xsltStylePreCompute() ?
3938 */
3939
3940 /*
3941 * Validate the content model of the XSLT-element.
3942 */
3943 switch (cctxt->inode->type) {
3944 case XSLT_FUNC_APPLYIMPORTS:
3945 /* EMPTY */
3946 goto empty_content;
3947 case XSLT_FUNC_APPLYTEMPLATES:
3948 /* <!-- Content: (xsl:sort | xsl:with-param)* --> */
3949 goto apply_templates;
3950 case XSLT_FUNC_ATTRIBUTE:
3951 /* <!-- Content: template --> */
3952 goto sequence_constructor;
3953 case XSLT_FUNC_CALLTEMPLATE:
3954 /* <!-- Content: xsl:with-param* --> */
3955 goto call_template;
3956 case XSLT_FUNC_CHOOSE:
3957 /* <!-- Content: (xsl:when+, xsl:otherwise?) --> */
3958 goto choose;
3959 case XSLT_FUNC_COMMENT:
3960 /* <!-- Content: template --> */
3961 goto sequence_constructor;
3962 case XSLT_FUNC_COPY:
3963 /* <!-- Content: template --> */
3964 goto sequence_constructor;
3965 case XSLT_FUNC_COPYOF:
3966 /* EMPTY */
3967 goto empty_content;
3968 case XSLT_FUNC_DOCUMENT: /* Extra one */
3969 /* ?? template ?? */
3970 goto sequence_constructor;
3971 case XSLT_FUNC_ELEMENT:
3972 /* <!-- Content: template --> */
3973 goto sequence_constructor;
3974 case XSLT_FUNC_FALLBACK:
3975 /* <!-- Content: template --> */
3976 goto sequence_constructor;
3977 case XSLT_FUNC_FOREACH:
3978 /* <!-- Content: (xsl:sort*, template) --> */
3979 goto for_each;
3980 case XSLT_FUNC_IF:
3981 /* <!-- Content: template --> */
3982 goto sequence_constructor;
3983 case XSLT_FUNC_OTHERWISE:
3984 /* <!-- Content: template --> */
3985 goto sequence_constructor;
3986 case XSLT_FUNC_MESSAGE:
3987 /* <!-- Content: template --> */
3988 goto sequence_constructor;
3989 case XSLT_FUNC_NUMBER:
3990 /* EMPTY */
3991 goto empty_content;
3992 case XSLT_FUNC_PARAM:
3993 /*
3994 * Check for redefinition.
3995 */
3996 if ((elem->psvi != NULL) && (cctxt->ivar != NULL)) {
3997 xsltVarInfoPtr ivar = cctxt->ivar;
3998
3999 do {
4000 if ((ivar->name ==
4001 ((xsltStyleItemParamPtr) elem->psvi)->name) &&
4002 (ivar->nsName ==
4003 ((xsltStyleItemParamPtr) elem->psvi)->ns))
4004 {
4005 elem->psvi = NULL;
4006 xsltTransformError(NULL, cctxt->style, elem,
4007 "Redefinition of variable or parameter '%s'.\n",
4008 ivar->name);
4009 cctxt->style->errors++;
4010 goto error;
4011 }
4012 ivar = ivar->prev;
4013 } while (ivar != NULL);
4014 }
4015 /* <!-- Content: template --> */
4016 goto sequence_constructor;
4017 case XSLT_FUNC_PI:
4018 /* <!-- Content: template --> */
4019 goto sequence_constructor;
4020 case XSLT_FUNC_SORT:
4021 /* EMPTY */
4022 goto empty_content;
4023 case XSLT_FUNC_TEXT:
4024 /* <!-- Content: #PCDATA --> */
4025 goto text;
4026 case XSLT_FUNC_VALUEOF:
4027 /* EMPTY */
4028 goto empty_content;
4029 case XSLT_FUNC_VARIABLE:
4030 /*
4031 * Check for redefinition.
4032 */
4033 if ((elem->psvi != NULL) && (cctxt->ivar != NULL)) {
4034 xsltVarInfoPtr ivar = cctxt->ivar;
4035
4036 do {
4037 if ((ivar->name ==
4038 ((xsltStyleItemVariablePtr) elem->psvi)->name) &&
4039 (ivar->nsName ==
4040 ((xsltStyleItemVariablePtr) elem->psvi)->ns))
4041 {
4042 elem->psvi = NULL;
4043 xsltTransformError(NULL, cctxt->style, elem,
4044 "Redefinition of variable or parameter '%s'.\n",
4045 ivar->name);
4046 cctxt->style->errors++;
4047 goto error;
4048 }
4049 ivar = ivar->prev;
4050 } while (ivar != NULL);
4051 }
4052 /* <!-- Content: template --> */
4053 goto sequence_constructor;
4054 case XSLT_FUNC_WHEN:
4055 /* <!-- Content: template --> */
4056 goto sequence_constructor;
4057 case XSLT_FUNC_WITHPARAM:
4058 /* <!-- Content: template --> */
4059 goto sequence_constructor;
4060 default:
4061 #ifdef WITH_XSLT_DEBUG_PARSING
4062 xsltGenericDebug(xsltGenericDebugContext,
4063 "xsltParseXSLTNode: Unhandled XSLT element '%s'.\n",
4064 elem->name);
4065 #endif
4066 xsltTransformError(NULL, cctxt->style, elem,
4067 "xsltParseXSLTNode: Internal error; "
4068 "unhandled XSLT element '%s'.\n", elem->name);
4069 cctxt->style->errors++;
4070 goto internal_err;
4071 }
4072
4073 apply_templates:
4074 /* <!-- Content: (xsl:sort | xsl:with-param)* --> */
4075 if (elem->children != NULL) {
4076 xmlNodePtr child = elem->children;
4077 do {
4078 if (child->type == XML_ELEMENT_NODE) {
4079 if (IS_XSLT_ELEM_FAST(child)) {
4080 if (xmlStrEqual(child->name, BAD_CAST "with-param")) {
4081 cctxt->inode->curChildType = XSLT_FUNC_WITHPARAM;
4082 xsltParseAnyXSLTElem(cctxt, child);
4083 } else if (xmlStrEqual(child->name, BAD_CAST "sort")) {
4084 cctxt->inode->curChildType = XSLT_FUNC_SORT;
4085 xsltParseAnyXSLTElem(cctxt, child);
4086 } else
4087 xsltParseContentError(cctxt->style, child);
4088 } else
4089 xsltParseContentError(cctxt->style, child);
4090 }
4091 child = child->next;
4092 } while (child != NULL);
4093 }
4094 goto exit;
4095
4096 call_template:
4097 /* <!-- Content: xsl:with-param* --> */
4098 if (elem->children != NULL) {
4099 xmlNodePtr child = elem->children;
4100 do {
4101 if (child->type == XML_ELEMENT_NODE) {
4102 if (IS_XSLT_ELEM_FAST(child)) {
4103 xsltStyleType type;
4104
4105 type = xsltGetXSLTElementTypeByNode(cctxt, child);
4106 if (type == XSLT_FUNC_WITHPARAM) {
4107 cctxt->inode->curChildType = XSLT_FUNC_WITHPARAM;
4108 xsltParseAnyXSLTElem(cctxt, child);
4109 } else {
4110 xsltParseContentError(cctxt->style, child);
4111 }
4112 } else
4113 xsltParseContentError(cctxt->style, child);
4114 }
4115 child = child->next;
4116 } while (child != NULL);
4117 }
4118 goto exit;
4119
4120 text:
4121 if (elem->children != NULL) {
4122 xmlNodePtr child = elem->children;
4123 do {
4124 if ((child->type != XML_TEXT_NODE) &&
4125 (child->type != XML_CDATA_SECTION_NODE))
4126 {
4127 xsltTransformError(NULL, cctxt->style, elem,
4128 "The XSLT 'text' element must have only character "
4129 "data as content.\n");
4130 }
4131 child = child->next;
4132 } while (child != NULL);
4133 }
4134 goto exit;
4135
4136 empty_content:
4137 if (elem->children != NULL) {
4138 xmlNodePtr child = elem->children;
4139 /*
4140 * Relaxed behaviour: we will allow whitespace-only text-nodes.
4141 */
4142 do {
4143 if (((child->type != XML_TEXT_NODE) &&
4144 (child->type != XML_CDATA_SECTION_NODE)) ||
4145 (! IS_BLANK_NODE(child)))
4146 {
4147 xsltTransformError(NULL, cctxt->style, elem,
4148 "This XSLT element must have no content.\n");
4149 cctxt->style->errors++;
4150 break;
4151 }
4152 child = child->next;
4153 } while (child != NULL);
4154 }
4155 goto exit;
4156
4157 choose:
4158 /* <!-- Content: (xsl:when+, xsl:otherwise?) --> */
4159 /*
4160 * TODO: text-nodes in between are *not* allowed in XSLT 1.0.
4161 * The old behaviour did not check this.
4162 * NOTE: In XSLT 2.0 they are stripped beforehand
4163 * if whitespace-only (regardless of xml:space).
4164 */
4165 if (elem->children != NULL) {
4166 xmlNodePtr child = elem->children;
4167 int nbWhen = 0, nbOtherwise = 0, err = 0;
4168 do {
4169 if (child->type == XML_ELEMENT_NODE) {
4170 if (IS_XSLT_ELEM_FAST(child)) {
4171 xsltStyleType type;
4172
4173 type = xsltGetXSLTElementTypeByNode(cctxt, child);
4174 if (type == XSLT_FUNC_WHEN) {
4175 nbWhen++;
4176 if (nbOtherwise) {
4177 xsltParseContentError(cctxt->style, child);
4178 err = 1;
4179 break;
4180 }
4181 cctxt->inode->curChildType = XSLT_FUNC_WHEN;
4182 xsltParseAnyXSLTElem(cctxt, child);
4183 } else if (type == XSLT_FUNC_OTHERWISE) {
4184 if (! nbWhen) {
4185 xsltParseContentError(cctxt->style, child);
4186 err = 1;
4187 break;
4188 }
4189 if (nbOtherwise) {
4190 xsltTransformError(NULL, cctxt->style, elem,
4191 "The XSLT 'choose' element must not contain "
4192 "more than one XSLT 'otherwise' element.\n");
4193 cctxt->style->errors++;
4194 err = 1;
4195 break;
4196 }
4197 nbOtherwise++;
4198 cctxt->inode->curChildType = XSLT_FUNC_OTHERWISE;
4199 xsltParseAnyXSLTElem(cctxt, child);
4200 } else
4201 xsltParseContentError(cctxt->style, child);
4202 } else
4203 xsltParseContentError(cctxt->style, child);
4204 }
4205 /*
4206 else
4207 xsltParseContentError(cctxt, child);
4208 */
4209 child = child->next;
4210 } while (child != NULL);
4211 if ((! err) && (! nbWhen)) {
4212 xsltTransformError(NULL, cctxt->style, elem,
4213 "The XSLT element 'choose' must contain at least one "
4214 "XSLT element 'when'.\n");
4215 cctxt->style->errors++;
4216 }
4217 }
4218 goto exit;
4219
4220 for_each:
4221 /* <!-- Content: (xsl:sort*, template) --> */
4222 /*
4223 * NOTE: Text-nodes before xsl:sort are *not* allowed in XSLT 1.0.
4224 * The old behaviour did not allow this, but it catched this
4225 * only at transformation-time.
4226 * In XSLT 2.0 they are stripped beforehand if whitespace-only
4227 * (regardless of xml:space).
4228 */
4229 if (elem->children != NULL) {
4230 xmlNodePtr child = elem->children;
4231 /*
4232 * Parse xsl:sort first.
4233 */
4234 do {
4235 if ((child->type == XML_ELEMENT_NODE) &&
4236 IS_XSLT_ELEM_FAST(child))
4237 {
4238 if (xsltGetXSLTElementTypeByNode(cctxt, child) ==
4239 XSLT_FUNC_SORT)
4240 {
4241 cctxt->inode->curChildType = XSLT_FUNC_SORT;
4242 xsltParseAnyXSLTElem(cctxt, child);
4243 } else
4244 break;
4245 } else
4246 break;
4247 child = child->next;
4248 } while (child != NULL);
4249 /*
4250 * Parse the sequece constructor.
4251 */
4252 if (child != NULL)
4253 xsltParseSequenceConstructor(cctxt, child);
4254 }
4255 goto exit;
4256
4257 sequence_constructor:
4258 /*
4259 * Parse the sequence constructor.
4260 */
4261 if (elem->children != NULL)
4262 xsltParseSequenceConstructor(cctxt, elem->children);
4263
4264 /*
4265 * Register information for vars/params. Only needed if there
4266 * are any following siblings.
4267 */
4268 if ((elem->next != NULL) &&
4269 ((cctxt->inode->type == XSLT_FUNC_VARIABLE) ||
4270 (cctxt->inode->type == XSLT_FUNC_PARAM)))
4271 {
4272 if ((elem->psvi != NULL) &&
4273 (((xsltStyleBasicItemVariablePtr) elem->psvi)->name))
4274 {
4275 xsltCompilerVarInfoPush(cctxt, elem,
4276 ((xsltStyleBasicItemVariablePtr) elem->psvi)->name,
4277 ((xsltStyleBasicItemVariablePtr) elem->psvi)->ns);
4278 }
4279 }
4280
4281 error:
4282 exit:
4283 xsltCompilerNodePop(cctxt, elem);
4284 return(0);
4285
4286 internal_err:
4287 xsltCompilerNodePop(cctxt, elem);
4288 return(-1);
4289 }
4290
4291 /**
4292 * xsltForwardsCompatUnkownItemCreate:
4293 *
4294 * @cctxt: the compilation context
4295 *
4296 * Creates a compiled representation of the unknown
4297 * XSLT instruction.
4298 *
4299 * Returns the compiled representation.
4300 */
4301 static xsltStyleItemUknownPtr
4302 xsltForwardsCompatUnkownItemCreate(xsltCompilerCtxtPtr cctxt)
4303 {
4304 xsltStyleItemUknownPtr item;
4305
4306 item = (xsltStyleItemUknownPtr) xmlMalloc(sizeof(xsltStyleItemUknown));
4307 if (item == NULL) {
4308 xsltTransformError(NULL, cctxt->style, NULL,
4309 "Internal error in xsltForwardsCompatUnkownItemCreate(): "
4310 "Failed to allocate memory.\n");
4311 cctxt->style->errors++;
4312 return(NULL);
4313 }
4314 memset(item, 0, sizeof(xsltStyleItemUknown));
4315 item->type = XSLT_FUNC_UNKOWN_FORWARDS_COMPAT;
4316 /*
4317 * Store it in the stylesheet.
4318 */
4319 item->next = cctxt->style->preComps;
4320 cctxt->style->preComps = (xsltElemPreCompPtr) item;
4321 return(item);
4322 }
4323
4324 /**
4325 * xsltParseUnknownXSLTElem:
4326 *
4327 * @cctxt: the compilation context
4328 * @node: the element of the unknown XSLT instruction
4329 *
4330 * Parses an unknown XSLT element.
4331 * If forwards compatible mode is enabled this will allow
4332 * such an unknown XSLT and; otherwise it is rejected.
4333 *
4334 * Returns 1 in the unknown XSLT instruction is rejected,
4335 * 0 if everything's fine and
4336 * -1 on API or internal errors.
4337 */
4338 static int
4339 xsltParseUnknownXSLTElem(xsltCompilerCtxtPtr cctxt,
4340 xmlNodePtr node)
4341 {
4342 if ((cctxt == NULL) || (node == NULL) || (node->type != XML_ELEMENT_NODE))
4343 return(-1);
4344
4345 /*
4346 * Detection of handled content of extension instructions.
4347 */
4348 if (cctxt->inode->category == XSLT_ELEMENT_CATEGORY_EXTENSION) {
4349 cctxt->inode->extContentHandled = 1;
4350 }
4351 if (cctxt->inode->forwardsCompat == 0) {
4352 /*
4353 * We are not in forwards-compatible mode, so raise an error.
4354 */
4355 xsltTransformError(NULL, cctxt->style, node,
4356 "Unknown XSLT element '%s'.\n", node->name);
4357 cctxt->style->errors++;
4358 return(1);
4359 }
4360 /*
4361 * Forwards-compatible mode.
4362 * ------------------------
4363 *
4364 * Parse/compile xsl:fallback elements.
4365 *
4366 * QUESTION: Do we have to raise an error if there's no xsl:fallback?
4367 * ANSWER: No, since in the stylesheet the fallback behaviour might
4368 * also be provided by using the XSLT function "element-available".
4369 */
4370 if (cctxt->unknownItem == NULL) {
4371 /*
4372 * Create a singleton for all unknown XSLT instructions.
4373 */
4374 cctxt->unknownItem = xsltForwardsCompatUnkownItemCreate(cctxt);
4375 if (cctxt->unknownItem == NULL) {
4376 node->psvi = NULL;
4377 return(-1);
4378 }
4379 }
4380 node->psvi = cctxt->unknownItem;
4381 if (node->children == NULL)
4382 return(0);
4383 else {
4384 xmlNodePtr child = node->children;
4385
4386 xsltCompilerNodePush(cctxt, node);
4387 /*
4388 * Update the in-scope namespaces if needed.
4389 */
4390 if (node->nsDef != NULL)
4391 cctxt->inode->inScopeNs =
4392 xsltCompilerBuildInScopeNsList(cctxt, node);
4393 /*
4394 * Parse all xsl:fallback children.
4395 */
4396 do {
4397 if ((child->type == XML_ELEMENT_NODE) &&
4398 IS_XSLT_ELEM_FAST(child) &&
4399 IS_XSLT_NAME(child, "fallback"))
4400 {
4401 cctxt->inode->curChildType = XSLT_FUNC_FALLBACK;
4402 xsltParseAnyXSLTElem(cctxt, child);
4403 }
4404 child = child->next;
4405 } while (child != NULL);
4406
4407 xsltCompilerNodePop(cctxt, node);
4408 }
4409 return(0);
4410 }
4411
4412 /**
4413 * xsltParseSequenceConstructor:
4414 *
4415 * @cctxt: the compilation context
4416 * @cur: the start-node of the content to be parsed
4417 *
4418 * Parses a "template" content (or "sequence constructor" in XSLT 2.0 terms).
4419 * This will additionally remove xsl:text elements from the tree.
4420 */
4421 void
4422 xsltParseSequenceConstructor(xsltCompilerCtxtPtr cctxt, xmlNodePtr cur)
4423 {
4424 xsltStyleType type;
4425 xmlNodePtr deleteNode = NULL;
4426
4427 if (cctxt == NULL) {
4428 xmlGenericError(xmlGenericErrorContext,
4429 "xsltParseSequenceConstructor: Bad arguments\n");
4430 cctxt->style->errors++;
4431 return;
4432 }
4433 /*
4434 * Detection of handled content of extension instructions.
4435 */
4436 if (cctxt->inode->category == XSLT_ELEMENT_CATEGORY_EXTENSION) {
4437 cctxt->inode->extContentHandled = 1;
4438 }
4439 if ((cur == NULL) || (cur->type == XML_NAMESPACE_DECL))
4440 return;
4441 /*
4442 * This is the content reffered to as a "template".
4443 * E.g. an xsl:element has such content model:
4444 * <xsl:element
4445 * name = { qname }
4446 * namespace = { uri-reference }
4447 * use-attribute-sets = qnames>
4448 * <!-- Content: template -->
4449 *
4450 * NOTE that in XSLT-2 the term "template" was abandoned due to
4451 * confusion with xsl:template and the term "sequence constructor"
4452 * was introduced instead.
4453 *
4454 * The following XSLT-instructions are allowed to appear:
4455 * xsl:apply-templates, xsl:call-template, xsl:apply-imports,
4456 * xsl:for-each, xsl:value-of, xsl:copy-of, xsl:number,
4457 * xsl:choose, xsl:if, xsl:text, xsl:copy, xsl:variable,
4458 * xsl:message, xsl:fallback,
4459 * xsl:processing-instruction, xsl:comment, xsl:element
4460 * xsl:attribute.
4461 * Additional allowed content:
4462 * 1) extension instructions
4463 * 2) literal result elements
4464 * 3) PCDATA
4465 *
4466 * NOTE that this content model does *not* allow xsl:param.
4467 */
4468 while (cur != NULL) {
4469 if (deleteNode != NULL) {
4470 #ifdef WITH_XSLT_DEBUG_BLANKS
4471 xsltGenericDebug(xsltGenericDebugContext,
4472 "xsltParseSequenceConstructor: removing xsl:text element\n");
4473 #endif
4474 xmlUnlinkNode(deleteNode);
4475 xmlFreeNode(deleteNode);
4476 deleteNode = NULL;
4477 }
4478 if (cur->type == XML_ELEMENT_NODE) {
4479
4480 if (cur->psvi == xsltXSLTTextMarker) {
4481 /*
4482 * xsl:text elements
4483 * --------------------------------------------------------
4484 */
4485 xmlNodePtr tmp;
4486
4487 cur->psvi = NULL;
4488 /*
4489 * Mark the xsl:text element for later deletion.
4490 */
4491 deleteNode = cur;
4492 /*
4493 * Validate content.
4494 */
4495 tmp = cur->children;
4496 if (tmp) {
4497 /*
4498 * We don't expect more than one text-node in the
4499 * content, since we already merged adjacent
4500 * text/CDATA-nodes and eliminated PI/comment-nodes.
4501 */
4502 if ((tmp->type == XML_TEXT_NODE) ||
4503 (tmp->next == NULL))
4504 {
4505 /*
4506 * Leave the contained text-node in the tree.
4507 */
4508 xmlUnlinkNode(tmp);
4509 xmlAddPrevSibling(cur, tmp);
4510 } else {
4511 tmp = NULL;
4512 xsltTransformError(NULL, cctxt->style, cur,
4513 "Element 'xsl:text': Invalid type "
4514 "of node found in content.\n");
4515 cctxt->style->errors++;
4516 }
4517 }
4518 if (cur->properties) {
4519 xmlAttrPtr attr;
4520 /*
4521 * TODO: We need to report errors for
4522 * invalid attrs.
4523 */
4524 attr = cur->properties;
4525 do {
4526 if ((attr->ns == NULL) &&
4527 (attr->name != NULL) &&
4528 (attr->name[0] == 'd') &&
4529 xmlStrEqual(attr->name,
4530 BAD_CAST "disable-output-escaping"))
4531 {
4532 /*
4533 * Attr "disable-output-escaping".
4534 * XSLT-2: This attribute is deprecated.
4535 */
4536 if ((attr->children != NULL) &&
4537 xmlStrEqual(attr->children->content,
4538 BAD_CAST "yes"))
4539 {
4540 /*
4541 * Disable output escaping for this
4542 * text node.
4543 */
4544 if (tmp)
4545 tmp->name = xmlStringTextNoenc;
4546 } else if ((attr->children == NULL) ||
4547 (attr->children->content == NULL) ||
4548 (!xmlStrEqual(attr->children->content,
4549 BAD_CAST "no")))
4550 {
4551 xsltTransformError(NULL, cctxt->style,
4552 cur,
4553 "Attribute 'disable-output-escaping': "
4554 "Invalid value. Expected is "
4555 "'yes' or 'no'.\n");
4556 cctxt->style->errors++;
4557 }
4558 break;
4559 }
4560 attr = attr->next;
4561 } while (attr != NULL);
4562 }
4563 } else if (IS_XSLT_ELEM_FAST(cur)) {
4564 /*
4565 * TODO: Using the XSLT-marker is still not stable yet.
4566 */
4567 /* if (cur->psvi == xsltXSLTElemMarker) { */
4568 /*
4569 * XSLT instructions
4570 * --------------------------------------------------------
4571 */
4572 cur->psvi = NULL;
4573 type = xsltGetXSLTElementTypeByNode(cctxt, cur);
4574 switch (type) {
4575 case XSLT_FUNC_APPLYIMPORTS:
4576 case XSLT_FUNC_APPLYTEMPLATES:
4577 case XSLT_FUNC_ATTRIBUTE:
4578 case XSLT_FUNC_CALLTEMPLATE:
4579 case XSLT_FUNC_CHOOSE:
4580 case XSLT_FUNC_COMMENT:
4581 case XSLT_FUNC_COPY:
4582 case XSLT_FUNC_COPYOF:
4583 case XSLT_FUNC_DOCUMENT: /* Extra one */
4584 case XSLT_FUNC_ELEMENT:
4585 case XSLT_FUNC_FALLBACK:
4586 case XSLT_FUNC_FOREACH:
4587 case XSLT_FUNC_IF:
4588 case XSLT_FUNC_MESSAGE:
4589 case XSLT_FUNC_NUMBER:
4590 case XSLT_FUNC_PI:
4591 case XSLT_FUNC_TEXT:
4592 case XSLT_FUNC_VALUEOF:
4593 case XSLT_FUNC_VARIABLE:
4594 /*
4595 * Parse the XSLT element.
4596 */
4597 cctxt->inode->curChildType = type;
4598 xsltParseAnyXSLTElem(cctxt, cur);
4599 break;
4600 default:
4601 xsltParseUnknownXSLTElem(cctxt, cur);
4602 cur = cur->next;
4603 continue;
4604 }
4605 } else {
4606 /*
4607 * Non-XSLT elements
4608 * -----------------
4609 */
4610 xsltCompilerNodePush(cctxt, cur);
4611 /*
4612 * Update the in-scope namespaces if needed.
4613 */
4614 if (cur->nsDef != NULL)
4615 cctxt->inode->inScopeNs =
4616 xsltCompilerBuildInScopeNsList(cctxt, cur);
4617 /*
4618 * The current element is either a literal result element
4619 * or an extension instruction.
4620 *
4621 * Process attr "xsl:extension-element-prefixes".
4622 * FUTURE TODO: IIRC in XSLT 2.0 this attribute must be
4623 * processed by the implementor of the extension function;
4624 * i.e., it won't be handled by the XSLT processor.
4625 */
4626 /* SPEC 1.0:
4627 * "exclude-result-prefixes" is only allowed on literal
4628 * result elements and "xsl:exclude-result-prefixes"
4629 * on xsl:stylesheet/xsl:transform.
4630 * SPEC 2.0:
4631 * "There are a number of standard attributes
4632 * that may appear on any XSLT element: specifically
4633 * version, exclude-result-prefixes,
4634 * extension-element-prefixes, xpath-default-namespace,
4635 * default-collation, and use-when."
4636 *
4637 * SPEC 2.0:
4638 * For literal result elements:
4639 * "xsl:version, xsl:exclude-result-prefixes,
4640 * xsl:extension-element-prefixes,
4641 * xsl:xpath-default-namespace,
4642 * xsl:default-collation, or xsl:use-when."
4643 */
4644 if (cur->properties)
4645 cctxt->inode->extElemNs =
4646 xsltParseExtElemPrefixes(cctxt,
4647 cur, cctxt->inode->extElemNs,
4648 XSLT_ELEMENT_CATEGORY_LRE);
4649 /*
4650 * Eval if we have an extension instruction here.
4651 */
4652 if ((cur->ns != NULL) &&
4653 (cctxt->inode->extElemNs != NULL) &&
4654 (xsltCheckExtPrefix(cctxt->style, cur->ns->href) == 1))
4655 {
4656 /*
4657 * Extension instructions
4658 * ----------------------------------------------------
4659 * Mark the node information.
4660 */
4661 cctxt->inode->category = XSLT_ELEMENT_CATEGORY_EXTENSION;
4662 cctxt->inode->extContentHandled = 0;
4663 if (cur->psvi != NULL) {
4664 cur->psvi = NULL;
4665 /*
4666 * TODO: Temporary sanity check.
4667 */
4668 xsltTransformError(NULL, cctxt->style, cur,
4669 "Internal error in xsltParseSequenceConstructor(): "
4670 "Occupied PSVI field.\n");
4671 cctxt->style->errors++;
4672 cur = cur->next;
4673 continue;
4674 }
4675 cur->psvi = (void *)
4676 xsltPreComputeExtModuleElement(cctxt->style, cur);
4677
4678 if (cur->psvi == NULL) {
4679 /*
4680 * OLD COMMENT: "Unknown element, maybe registered
4681 * at the context level. Mark it for later
4682 * recognition."
4683 * QUESTION: What does the xsltExtMarker mean?
4684 * ANSWER: It is used in
4685 * xsltApplySequenceConstructor() at
4686 * transformation-time to look out for extension
4687 * registered in the transformation context.
4688 */
4689 cur->psvi = (void *) xsltExtMarker;
4690 }
4691 /*
4692 * BIG NOTE: Now the ugly part. In previous versions
4693 * of Libxslt (until 1.1.16), all the content of an
4694 * extension instruction was processed and compiled without
4695 * the need of the extension-author to explicitely call
4696 * such a processing;.We now need to mimic this old
4697 * behaviour in order to avoid breaking old code
4698 * on the extension-author's side.
4699 * The mechanism:
4700 * 1) If the author does *not* set the
4701 * compile-time-flag @extContentHandled, then we'll
4702 * parse the content assuming that it's a "template"
4703 * (or "sequence constructor in XSLT 2.0 terms).
4704 * NOTE: If the extension is registered at
4705 * transformation-time only, then there's no way of
4706 * knowing that content shall be valid, and we'll
4707 * process the content the same way.
4708 * 2) If the author *does* set the flag, then we'll assume
4709 * that the author has handled the parsing him/herself
4710 * (e.g. called xsltParseSequenceConstructor(), etc.
4711 * explicitely in his/her code).
4712 */
4713 if ((cur->children != NULL) &&
4714 (cctxt->inode->extContentHandled == 0))
4715 {
4716 /*
4717 * Default parsing of the content using the
4718 * sequence-constructor model.
4719 */
4720 xsltParseSequenceConstructor(cctxt, cur->children);
4721 }
4722 } else {
4723 /*
4724 * Literal result element
4725 * ----------------------------------------------------
4726 * Allowed XSLT attributes:
4727 * xsl:extension-element-prefixes CDATA #IMPLIED
4728 * xsl:exclude-result-prefixes CDATA #IMPLIED
4729 * TODO: xsl:use-attribute-sets %qnames; #IMPLIED
4730 * xsl:version NMTOKEN #IMPLIED
4731 */
4732 cur->psvi = NULL;
4733 cctxt->inode->category = XSLT_ELEMENT_CATEGORY_LRE;
4734 if (cur->properties != NULL) {
4735 xmlAttrPtr attr = cur->properties;
4736 /*
4737 * Attribute "xsl:exclude-result-prefixes".
4738 */
4739 cctxt->inode->exclResultNs =
4740 xsltParseExclResultPrefixes(cctxt, cur,
4741 cctxt->inode->exclResultNs,
4742 XSLT_ELEMENT_CATEGORY_LRE);
4743 /*
4744 * Attribute "xsl:version".
4745 */
4746 xsltParseAttrXSLTVersion(cctxt, cur,
4747 XSLT_ELEMENT_CATEGORY_LRE);
4748 /*
4749 * Report invalid XSLT attributes.
4750 * For XSLT 1.0 only xsl:use-attribute-sets is allowed
4751 * next to xsl:version, xsl:exclude-result-prefixes and
4752 * xsl:extension-element-prefixes.
4753 *
4754 * Mark all XSLT attributes, in order to skip such
4755 * attributes when instantiating the LRE.
4756 */
4757 do {
4758 if ((attr->psvi != xsltXSLTAttrMarker) &&
4759 IS_XSLT_ATTR_FAST(attr))
4760 {
4761 if (! xmlStrEqual(attr->name,
4762 BAD_CAST "use-attribute-sets"))
4763 {
4764 xsltTransformError(NULL, cctxt->style,
4765 cur,
4766 "Unknown XSLT attribute '%s'.\n",
4767 attr->name);
4768 cctxt->style->errors++;
4769 } else {
4770 /*
4771 * XSLT attr marker.
4772 */
4773 attr->psvi = (void *) xsltXSLTAttrMarker;
4774 }
4775 }
4776 attr = attr->next;
4777 } while (attr != NULL);
4778 }
4779 /*
4780 * Create/reuse info for the literal result element.
4781 */
4782 if (cctxt->inode->nsChanged)
4783 xsltLREInfoCreate(cctxt, cur, 1);
4784 cur->psvi = cctxt->inode->litResElemInfo;
4785 /*
4786 * Apply ns-aliasing on the element and on its attributes.
4787 */
4788 if (cctxt->hasNsAliases)
4789 xsltLREBuildEffectiveNs(cctxt, cur);
4790 /*
4791 * Compile attribute value templates (AVT).
4792 */
4793 if (cur->properties) {
4794 xmlAttrPtr attr = cur->properties;
4795
4796 while (attr != NULL) {
4797 xsltCompileAttr(cctxt->style, attr);
4798 attr = attr->next;
4799 }
4800 }
4801 /*
4802 * Parse the content, which is defined to be a "template"
4803 * (or "sequence constructor" in XSLT 2.0 terms).
4804 */
4805 if (cur->children != NULL) {
4806 xsltParseSequenceConstructor(cctxt, cur->children);
4807 }
4808 }
4809 /*
4810 * Leave the non-XSLT element.
4811 */
4812 xsltCompilerNodePop(cctxt, cur);
4813 }
4814 }
4815 cur = cur->next;
4816 }
4817 if (deleteNode != NULL) {
4818 #ifdef WITH_XSLT_DEBUG_BLANKS
4819 xsltGenericDebug(xsltGenericDebugContext,
4820 "xsltParseSequenceConstructor: removing xsl:text element\n");
4821 #endif
4822 xmlUnlinkNode(deleteNode);
4823 xmlFreeNode(deleteNode);
4824 deleteNode = NULL;
4825 }
4826 }
4827
4828 /**
4829 * xsltParseTemplateContent:
4830 * @style: the XSLT stylesheet
4831 * @templ: the node containing the content to be parsed
4832 *
4833 * Parses and compiles the content-model of an xsl:template element.
4834 * Note that this is *not* the "template" content model (or "sequence
4835 * constructor" in XSLT 2.0); it it allows addional xsl:param
4836 * elements as immediate children of @templ.
4837 *
4838 * Called by:
4839 * exsltFuncFunctionComp() (EXSLT, functions.c)
4840 * So this is intended to be called from extension functions.
4841 */
4842 void
4843 xsltParseTemplateContent(xsltStylesheetPtr style, xmlNodePtr templ) {
4844 if ((style == NULL) || (templ == NULL) ||
4845 (templ->type == XML_NAMESPACE_DECL))
4846 return;
4847
4848 /*
4849 * Detection of handled content of extension instructions.
4850 */
4851 if (XSLT_CCTXT(style)->inode->category == XSLT_ELEMENT_CATEGORY_EXTENSION) {
4852 XSLT_CCTXT(style)->inode->extContentHandled = 1;
4853 }
4854
4855 if (templ->children != NULL) {
4856 xmlNodePtr child = templ->children;
4857 /*
4858 * Process xsl:param elements, which can only occur as the
4859 * immediate children of xsl:template (well, and of any
4860 * user-defined extension instruction if needed).
4861 */
4862 do {
4863 if ((child->type == XML_ELEMENT_NODE) &&
4864 IS_XSLT_ELEM_FAST(child) &&
4865 IS_XSLT_NAME(child, "param"))
4866 {
4867 XSLT_CCTXT(style)->inode->curChildType = XSLT_FUNC_PARAM;
4868 xsltParseAnyXSLTElem(XSLT_CCTXT(style), child);
4869 } else
4870 break;
4871 child = child->next;
4872 } while (child != NULL);
4873 /*
4874 * Parse the content and register the pattern.
4875 */
4876 xsltParseSequenceConstructor(XSLT_CCTXT(style), child);
4877 }
4878 }
4879
4880 #else /* XSLT_REFACTORED */
4881
4882 /**
4883 * xsltParseTemplateContent:
4884 * @style: the XSLT stylesheet
4885 * @templ: the container node (can be a document for literal results)
4886 *
4887 * parse a template content-model
4888 * Clean-up the template content from unwanted ignorable blank nodes
4889 * and process xslt:text
4890 */
4891 void
4892 xsltParseTemplateContent(xsltStylesheetPtr style, xmlNodePtr templ) {
4893 xmlNodePtr cur, delete;
4894
4895 if ((style == NULL) || (templ == NULL) ||
4896 (templ->type == XML_NAMESPACE_DECL)) return;
4897
4898 /*
4899 * This content comes from the stylesheet
4900 * For stylesheets, the set of whitespace-preserving
4901 * element names consists of just xsl:text.
4902 */
4903 cur = templ->children;
4904 delete = NULL;
4905 while (cur != NULL) {
4906 if (delete != NULL) {
4907 #ifdef WITH_XSLT_DEBUG_BLANKS
4908 xsltGenericDebug(xsltGenericDebugContext,
4909 "xsltParseTemplateContent: removing text\n");
4910 #endif
4911 xmlUnlinkNode(delete);
4912 xmlFreeNode(delete);
4913 delete = NULL;
4914 }
4915 if (IS_XSLT_ELEM(cur)) {
4916 xsltStylePreCompute(style, cur);
4917
4918 if (IS_XSLT_NAME(cur, "text")) {
4919 /*
4920 * TODO: Processing of xsl:text should be moved to
4921 * xsltPreprocessStylesheet(), since otherwise this
4922 * will be performed for every multiply included
4923 * stylesheet; i.e. this here is not skipped with
4924 * the use of the style->nopreproc flag.
4925 */
4926 if (cur->children != NULL) {
4927 xmlChar *prop;
4928 xmlNodePtr text = cur->children, next;
4929 int noesc = 0;
4930
4931 prop = xmlGetNsProp(cur,
4932 (const xmlChar *)"disable-output-escaping",
4933 NULL);
4934 if (prop != NULL) {
4935 #ifdef WITH_XSLT_DEBUG_PARSING
4936 xsltGenericDebug(xsltGenericDebugContext,
4937 "Disable escaping: %s\n", text->content);
4938 #endif
4939 if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
4940 noesc = 1;
4941 } else if (!xmlStrEqual(prop,
4942 (const xmlChar *)"no")){
4943 xsltTransformError(NULL, style, cur,
4944 "xsl:text: disable-output-escaping allows only yes or no\n");
4945 style->warnings++;
4946
4947 }
4948 xmlFree(prop);
4949 }
4950
4951 while (text != NULL) {
4952 if (text->type == XML_COMMENT_NODE) {
4953 text = text->next;
4954 continue;
4955 }
4956 if ((text->type != XML_TEXT_NODE) &&
4957 (text->type != XML_CDATA_SECTION_NODE)) {
4958 xsltTransformError(NULL, style, cur,
4959 "xsltParseTemplateContent: xslt:text content problem\n");
4960 style->errors++;
4961 break;
4962 }
4963 if ((noesc) && (text->type != XML_CDATA_SECTION_NODE))
4964 text->name = xmlStringTextNoenc;
4965 text = text->next;
4966 }
4967
4968 /*
4969 * replace xsl:text by the list of childs
4970 */
4971 if (text == NULL) {
4972 text = cur->children;
4973 while (text != NULL) {
4974 if ((style->internalized) &&
4975 (text->content != NULL) &&
4976 (!xmlDictOwns(style->dict, text->content))) {
4977
4978 /*
4979 * internalize the text string
4980 */
4981 if (text->doc->dict != NULL) {
4982 const xmlChar *tmp;
4983
4984 tmp = xmlDictLookup(text->doc->dict,
4985 text->content, -1);
4986 if (tmp != text->content) {
4987 xmlNodeSetContent(text, NULL);
4988 text->content = (xmlChar *) tmp;
4989 }
4990 }
4991 }
4992
4993 next = text->next;
4994 xmlUnlinkNode(text);
4995 xmlAddPrevSibling(cur, text);
4996 text = next;
4997 }
4998 }
4999 }
5000 delete = cur;
5001 goto skip_children;
5002 }
5003 }
5004 else if ((cur->ns != NULL) && (style->nsDefs != NULL) &&
5005 (xsltCheckExtPrefix(style, cur->ns->prefix)))
5006 {
5007 /*
5008 * okay this is an extension element compile it too
5009 */
5010 xsltStylePreCompute(style, cur);
5011 }
5012 else if (cur->type == XML_ELEMENT_NODE)
5013 {
5014 /*
5015 * This is an element which will be output as part of the
5016 * template exectution, precompile AVT if found.
5017 */
5018 if ((cur->ns == NULL) && (style->defaultAlias != NULL)) {
5019 cur->ns = xmlSearchNsByHref(cur->doc, cur,
5020 style->defaultAlias);
5021 }
5022 if (cur->properties != NULL) {
5023 xmlAttrPtr attr = cur->properties;
5024
5025 while (attr != NULL) {
5026 xsltCompileAttr(style, attr);
5027 attr = attr->next;
5028 }
5029 }
5030 }
5031 /*
5032 * Skip to next node
5033 */
5034 if (cur->children != NULL) {
5035 if (cur->children->type != XML_ENTITY_DECL) {
5036 cur = cur->children;
5037 continue;
5038 }
5039 }
5040 skip_children:
5041 if (cur->next != NULL) {
5042 cur = cur->next;
5043 continue;
5044 }
5045
5046 do {
5047 cur = cur->parent;
5048 if (cur == NULL)
5049 break;
5050 if (cur == templ) {
5051 cur = NULL;
5052 break;
5053 }
5054 if (cur->next != NULL) {
5055 cur = cur->next;
5056 break;
5057 }
5058 } while (cur != NULL);
5059 }
5060 if (delete != NULL) {
5061 #ifdef WITH_XSLT_DEBUG_PARSING
5062 xsltGenericDebug(xsltGenericDebugContext,
5063 "xsltParseTemplateContent: removing text\n");
5064 #endif
5065 xmlUnlinkNode(delete);
5066 xmlFreeNode(delete);
5067 delete = NULL;
5068 }
5069
5070 /*
5071 * Skip the first params
5072 */
5073 cur = templ->children;
5074 while (cur != NULL) {
5075 if ((IS_XSLT_ELEM(cur)) && (!(IS_XSLT_NAME(cur, "param"))))
5076 break;
5077 cur = cur->next;
5078 }
5079
5080 /*
5081 * Browse the remainder of the template
5082 */
5083 while (cur != NULL) {
5084 if ((IS_XSLT_ELEM(cur)) && (IS_XSLT_NAME(cur, "param"))) {
5085 xmlNodePtr param = cur;
5086
5087 xsltTransformError(NULL, style, cur,
5088 "xsltParseTemplateContent: ignoring misplaced param element\n");
5089 if (style != NULL) style->warnings++;
5090 cur = cur->next;
5091 xmlUnlinkNode(param);
5092 xmlFreeNode(param);
5093 } else
5094 break;
5095 }
5096 }
5097
5098 #endif /* else XSLT_REFACTORED */
5099
5100 /**
5101 * xsltParseStylesheetKey:
5102 * @style: the XSLT stylesheet
5103 * @key: the "key" element
5104 *
5105 * <!-- Category: top-level-element -->
5106 * <xsl:key name = qname, match = pattern, use = expression />
5107 *
5108 * parse an XSLT stylesheet key definition and register it
5109 */
5110
5111 static void
5112 xsltParseStylesheetKey(xsltStylesheetPtr style, xmlNodePtr key) {
5113 xmlChar *prop = NULL;
5114 xmlChar *use = NULL;
5115 xmlChar *match = NULL;
5116 xmlChar *name = NULL;
5117 xmlChar *nameURI = NULL;
5118
5119 if ((style == NULL) || (key == NULL) || (key->type != XML_ELEMENT_NODE))
5120 return;
5121
5122 /*
5123 * Get arguments
5124 */
5125 prop = xmlGetNsProp(key, (const xmlChar *)"name", NULL);
5126 if (prop != NULL) {
5127 const xmlChar *URI;
5128
5129 /*
5130 * TODO: Don't use xsltGetQNameURI().
5131 */
5132 URI = xsltGetQNameURI(key, &prop);
5133 if (prop == NULL) {
5134 if (style != NULL) style->errors++;
5135 goto error;
5136 } else {
5137 name = prop;
5138 if (URI != NULL)
5139 nameURI = xmlStrdup(URI);
5140 }
5141 #ifdef WITH_XSLT_DEBUG_PARSING
5142 xsltGenericDebug(xsltGenericDebugContext,
5143 "xsltParseStylesheetKey: name %s\n", name);
5144 #endif
5145 } else {
5146 xsltTransformError(NULL, style, key,
5147 "xsl:key : error missing name\n");
5148 if (style != NULL) style->errors++;
5149 goto error;
5150 }
5151
5152 match = xmlGetNsProp(key, (const xmlChar *)"match", NULL);
5153 if (match == NULL) {
5154 xsltTransformError(NULL, style, key,
5155 "xsl:key : error missing match\n");
5156 if (style != NULL) style->errors++;
5157 goto error;
5158 }
5159
5160 use = xmlGetNsProp(key, (const xmlChar *)"use", NULL);
5161 if (use == NULL) {
5162 xsltTransformError(NULL, style, key,
5163 "xsl:key : error missing use\n");
5164 if (style != NULL) style->errors++;
5165 goto error;
5166 }
5167
5168 /*
5169 * register the keys
5170 */
5171 xsltAddKey(style, name, nameURI, match, use, key);
5172
5173
5174 error:
5175 if (use != NULL)
5176 xmlFree(use);
5177 if (match != NULL)
5178 xmlFree(match);
5179 if (name != NULL)
5180 xmlFree(name);
5181 if (nameURI != NULL)
5182 xmlFree(nameURI);
5183
5184 if (key->children != NULL) {
5185 xsltParseContentError(style, key->children);
5186 }
5187 }
5188
5189 #ifdef XSLT_REFACTORED
5190 /**
5191 * xsltParseXSLTTemplate:
5192 * @style: the XSLT stylesheet
5193 * @template: the "template" element
5194 *
5195 * parse an XSLT stylesheet template building the associated structures
5196 * TODO: Is @style ever expected to be NULL?
5197 *
5198 * Called from:
5199 * xsltParseXSLTStylesheet()
5200 * xsltParseStylesheetTop()
5201 */
5202
5203 static void
5204 xsltParseXSLTTemplate(xsltCompilerCtxtPtr cctxt, xmlNodePtr templNode) {
5205 xsltTemplatePtr templ;
5206 xmlChar *prop;
5207 double priority;
5208
5209 if ((cctxt == NULL) || (templNode == NULL) ||
5210 (templNode->type != XML_ELEMENT_NODE))
5211 return;
5212
5213 /*
5214 * Create and link the structure
5215 */
5216 templ = xsltNewTemplate();
5217 if (templ == NULL)
5218 return;
5219
5220 xsltCompilerNodePush(cctxt, templNode);
5221 if (templNode->nsDef != NULL)
5222 cctxt->inode->inScopeNs =
5223 xsltCompilerBuildInScopeNsList(cctxt, templNode);
5224
5225 templ->next = cctxt->style->templates;
5226 cctxt->style->templates = templ;
5227 templ->style = cctxt->style;
5228
5229 /*
5230 * Attribute "mode".
5231 */
5232 prop = xmlGetNsProp(templNode, (const xmlChar *)"mode", NULL);
5233 if (prop != NULL) {
5234 const xmlChar *modeURI;
5235
5236 /*
5237 * TODO: We need a standardized function for extraction
5238 * of namespace names and local names from QNames.
5239 * Don't use xsltGetQNameURI() as it cannot channe�
5240 * reports through the context.
5241 */
5242 modeURI = xsltGetQNameURI(templNode, &prop);
5243 if (prop == NULL) {
5244 cctxt->style->errors++;
5245 goto error;
5246 }
5247 templ->mode = xmlDictLookup(cctxt->style->dict, prop, -1);
5248 xmlFree(prop);
5249 prop = NULL;
5250 if (xmlValidateNCName(templ->mode, 0)) {
5251 xsltTransformError(NULL, cctxt->style, templNode,
5252 "xsl:template: Attribute 'mode': The local part '%s' "
5253 "of the value is not a valid NCName.\n", templ->name);
5254 cctxt->style->errors++;
5255 goto error;
5256 }
5257 if (modeURI != NULL)
5258 templ->modeURI = xmlDictLookup(cctxt->style->dict, modeURI, -1);
5259 #ifdef WITH_XSLT_DEBUG_PARSING
5260 xsltGenericDebug(xsltGenericDebugContext,
5261 "xsltParseXSLTTemplate: mode %s\n", templ->mode);
5262 #endif
5263 }
5264 /*
5265 * Attribute "match".
5266 */
5267 prop = xmlGetNsProp(templNode, (const xmlChar *)"match", NULL);
5268 if (prop != NULL) {
5269 templ->match = prop;
5270 prop = NULL;
5271 }
5272 /*
5273 * Attribute "priority".
5274 */
5275 prop = xmlGetNsProp(templNode, (const xmlChar *)"priority", NULL);
5276 if (prop != NULL) {
5277 priority = xmlXPathStringEvalNumber(prop);
5278 templ->priority = (float) priority;
5279 xmlFree(prop);
5280 prop = NULL;
5281 }
5282 /*
5283 * Attribute "name".
5284 */
5285 prop = xmlGetNsProp(templNode, (const xmlChar *)"name", NULL);
5286 if (prop != NULL) {
5287 const xmlChar *nameURI;
5288 xsltTemplatePtr curTempl;
5289
5290 /*
5291 * TODO: Don't use xsltGetQNameURI().
5292 */
5293 nameURI = xsltGetQNameURI(templNode, &prop);
5294 if (prop == NULL) {
5295 cctxt->style->errors++;
5296 goto error;
5297 }
5298 templ->name = xmlDictLookup(cctxt->style->dict, prop, -1);
5299 xmlFree(prop);
5300 prop = NULL;
5301 if (xmlValidateNCName(templ->name, 0)) {
5302 xsltTransformError(NULL, cctxt->style, templNode,
5303 "xsl:template: Attribute 'name': The local part '%s' of "
5304 "the value is not a valid NCName.\n", templ->name);
5305 cctxt->style->errors++;
5306 goto error;
5307 }
5308 if (nameURI != NULL)
5309 templ->nameURI = xmlDictLookup(cctxt->style->dict, nameURI, -1);
5310 curTempl = templ->next;
5311 while (curTempl != NULL) {
5312 if ((nameURI != NULL && xmlStrEqual(curTempl->name, templ->name) &&
5313 xmlStrEqual(curTempl->nameURI, nameURI) ) ||
5314 (nameURI == NULL && curTempl->nameURI == NULL &&
5315 xmlStrEqual(curTempl->name, templ->name)))
5316 {
5317 xsltTransformError(NULL, cctxt->style, templNode,
5318 "xsl:template: error duplicate name '%s'\n", templ->name);
5319 cctxt->style->errors++;
5320 goto error;
5321 }
5322 curTempl = curTempl->next;
5323 }
5324 }
5325 if (templNode->children != NULL) {
5326 xsltParseTemplateContent(cctxt->style, templNode);
5327 /*
5328 * MAYBE TODO: Custom behaviour: In order to stay compatible with
5329 * Xalan and MSXML(.NET), we could allow whitespace
5330 * to appear before an xml:param element; this whitespace
5331 * will additionally become part of the "template".
5332 * NOTE that this is totally deviates from the spec, but
5333 * is the de facto behaviour of Xalan and MSXML(.NET).
5334 * Personally I wouldn't allow this, since if we have:
5335 * <xsl:template ...xml:space="preserve">
5336 * <xsl:param name="foo"/>
5337 * <xsl:param name="bar"/>
5338 * <xsl:param name="zoo"/>
5339 * ... the whitespace between every xsl:param would be
5340 * added to the result tree.
5341 */
5342 }
5343
5344 templ->elem = templNode;
5345 templ->content = templNode->children;
5346 xsltAddTemplate(cctxt->style, templ, templ->mode, templ->modeURI);
5347
5348 error:
5349 xsltCompilerNodePop(cctxt, templNode);
5350 return;
5351 }
5352
5353 #else /* XSLT_REFACTORED */
5354
5355 /**
5356 * xsltParseStylesheetTemplate:
5357 * @style: the XSLT stylesheet
5358 * @template: the "template" element
5359 *
5360 * parse an XSLT stylesheet template building the associated structures
5361 */
5362
5363 static void
5364 xsltParseStylesheetTemplate(xsltStylesheetPtr style, xmlNodePtr template) {
5365 xsltTemplatePtr ret;
5366 xmlChar *prop;
5367 xmlChar *mode = NULL;
5368 xmlChar *modeURI = NULL;
5369 double priority;
5370
5371 if ((style == NULL) || (template == NULL) ||
5372 (template->type != XML_ELEMENT_NODE))
5373 return;
5374
5375 /*
5376 * Create and link the structure
5377 */
5378 ret = xsltNewTemplate();
5379 if (ret == NULL)
5380 return;
5381 ret->next = style->templates;
5382 style->templates = ret;
5383 ret->style = style;
5384
5385 /*
5386 * Get inherited namespaces
5387 */
5388 /*
5389 * TODO: Apply the optimized in-scope-namespace mechanism
5390 * as for the other XSLT instructions.
5391 */
5392 xsltGetInheritedNsList(style, ret, template);
5393
5394 /*
5395 * Get arguments
5396 */
5397 prop = xmlGetNsProp(template, (const xmlChar *)"mode", NULL);
5398 if (prop != NULL) {
5399 const xmlChar *URI;
5400
5401 /*
5402 * TODO: Don't use xsltGetQNameURI().
5403 */
5404 URI = xsltGetQNameURI(template, &prop);
5405 if (prop == NULL) {
5406 if (style != NULL) style->errors++;
5407 goto error;
5408 } else {
5409 mode = prop;
5410 if (URI != NULL)
5411 modeURI = xmlStrdup(URI);
5412 }
5413 ret->mode = xmlDictLookup(style->dict, mode, -1);
5414 ret->modeURI = xmlDictLookup(style->dict, modeURI, -1);
5415 #ifdef WITH_XSLT_DEBUG_PARSING
5416 xsltGenericDebug(xsltGenericDebugContext,
5417 "xsltParseStylesheetTemplate: mode %s\n", mode);
5418 #endif
5419 if (mode != NULL) xmlFree(mode);
5420 if (modeURI != NULL) xmlFree(modeURI);
5421 }
5422 prop = xmlGetNsProp(template, (const xmlChar *)"match", NULL);
5423 if (prop != NULL) {
5424 if (ret->match != NULL) xmlFree(ret->match);
5425 ret->match = prop;
5426 }
5427
5428 prop = xmlGetNsProp(template, (const xmlChar *)"priority", NULL);
5429 if (prop != NULL) {
5430 priority = xmlXPathStringEvalNumber(prop);
5431 ret->priority = (float) priority;
5432 xmlFree(prop);
5433 }
5434
5435 prop = xmlGetNsProp(template, (const xmlChar *)"name", NULL);
5436 if (prop != NULL) {
5437 const xmlChar *URI;
5438
5439 /*
5440 * TODO: Don't use xsltGetQNameURI().
5441 */
5442 URI = xsltGetQNameURI(template, &prop);
5443 if (prop == NULL) {
5444 if (style != NULL) style->errors++;
5445 goto error;
5446 } else {
5447 if (xmlValidateNCName(prop,0)) {
5448 xsltTransformError(NULL, style, template,
5449 "xsl:template : error invalid name '%s'\n", prop);
5450 if (style != NULL) style->errors++;
5451 xmlFree(prop);
5452 goto error;
5453 }
5454 ret->name = xmlDictLookup(style->dict, BAD_CAST prop, -1);
5455 xmlFree(prop);
5456 prop = NULL;
5457 if (URI != NULL)
5458 ret->nameURI = xmlDictLookup(style->dict, BAD_CAST URI, -1);
5459 else
5460 ret->nameURI = NULL;
5461 }
5462 }
5463
5464 /*
5465 * parse the content and register the pattern
5466 */
5467 xsltParseTemplateContent(style, template);
5468 ret->elem = template;
5469 ret->content = template->children;
5470 xsltAddTemplate(style, ret, ret->mode, ret->modeURI);
5471
5472 error:
5473 return;
5474 }
5475
5476 #endif /* else XSLT_REFACTORED */
5477
5478 #ifdef XSLT_REFACTORED
5479
5480 /**
5481 * xsltIncludeComp:
5482 * @cctxt: the compilation contenxt
5483 * @node: the xsl:include node
5484 *
5485 * Process the xslt include node on the source node
5486 */
5487 static xsltStyleItemIncludePtr
5488 xsltCompileXSLTIncludeElem(xsltCompilerCtxtPtr cctxt, xmlNodePtr node) {
5489 xsltStyleItemIncludePtr item;
5490
5491 if ((cctxt == NULL) || (node == NULL) || (node->type != XML_ELEMENT_NODE))
5492 return(NULL);
5493
5494 node->psvi = NULL;
5495 item = (xsltStyleItemIncludePtr) xmlMalloc(sizeof(xsltStyleItemInclude));
5496 if (item == NULL) {
5497 xsltTransformError(NULL, cctxt->style, node,
5498 "xsltIncludeComp : malloc failed\n");
5499 cctxt->style->errors++;
5500 return(NULL);
5501 }
5502 memset(item, 0, sizeof(xsltStyleItemInclude));
5503
5504 node->psvi = item;
5505 item->inst = node;
5506 item->type = XSLT_FUNC_INCLUDE;
5507
5508 item->next = cctxt->style->preComps;
5509 cctxt->style->preComps = (xsltElemPreCompPtr) item;
5510
5511 return(item);
5512 }
5513
5514 /**
5515 * xsltParseFindTopLevelElem:
5516 */
5517 static int
5518 xsltParseFindTopLevelElem(xsltCompilerCtxtPtr cctxt,
5519 xmlNodePtr cur,
5520 const xmlChar *name,
5521 const xmlChar *namespaceURI,
5522 int breakOnOtherElem,
5523 xmlNodePtr *resultNode)
5524 {
5525 if (name == NULL)
5526 return(-1);
5527
5528 *resultNode = NULL;
5529 while (cur != NULL) {
5530 if (cur->type == XML_ELEMENT_NODE) {
5531 if ((cur->ns != NULL) && (cur->name != NULL)) {
5532 if ((*(cur->name) == *name) &&
5533 xmlStrEqual(cur->name, name) &&
5534 xmlStrEqual(cur->ns->href, namespaceURI))
5535 {
5536 *resultNode = cur;
5537 return(1);
5538 }
5539 }
5540 if (breakOnOtherElem)
5541 break;
5542 }
5543 cur = cur->next;
5544 }
5545 *resultNode = cur;
5546 return(0);
5547 }
5548
5549 static int
5550 xsltParseTopLevelXSLTElem(xsltCompilerCtxtPtr cctxt,
5551 xmlNodePtr node,
5552 xsltStyleType type)
5553 {
5554 int ret = 0;
5555
5556 /*
5557 * TODO: The reason why this function exists:
5558 * due to historical reasons some of the
5559 * top-level declarations are processed by functions
5560 * in other files. Since we need still to set
5561 * up the node-info and generate information like
5562 * in-scope namespaces, this is a wrapper around
5563 * those old parsing functions.
5564 */
5565 xsltCompilerNodePush(cctxt, node);
5566 if (node->nsDef != NULL)
5567 cctxt->inode->inScopeNs =
5568 xsltCompilerBuildInScopeNsList(cctxt, node);
5569 cctxt->inode->type = type;
5570
5571 switch (type) {
5572 case XSLT_FUNC_INCLUDE:
5573 {
5574 int oldIsInclude;
5575
5576 if (xsltCompileXSLTIncludeElem(cctxt, node) == NULL)
5577 goto exit;
5578 /*
5579 * Mark this stylesheet tree as being currently included.
5580 */
5581 oldIsInclude = cctxt->isInclude;
5582 cctxt->isInclude = 1;
5583
5584 if (xsltParseStylesheetInclude(cctxt->style, node) != 0) {
5585 cctxt->style->errors++;
5586 }
5587 cctxt->isInclude = oldIsInclude;
5588 }
5589 break;
5590 case XSLT_FUNC_PARAM:
5591 xsltStylePreCompute(cctxt->style, node);
5592 xsltParseGlobalParam(cctxt->style, node);
5593 break;
5594 case XSLT_FUNC_VARIABLE:
5595 xsltStylePreCompute(cctxt->style, node);
5596 xsltParseGlobalVariable(cctxt->style, node);
5597 break;
5598 case XSLT_FUNC_ATTRSET:
5599 xsltParseStylesheetAttributeSet(cctxt->style, node);
5600 break;
5601 default:
5602 xsltTransformError(NULL, cctxt->style, node,
5603 "Internal error: (xsltParseTopLevelXSLTElem) "
5604 "Cannot handle this top-level declaration.\n");
5605 cctxt->style->errors++;
5606 ret = -1;
5607 }
5608
5609 exit:
5610 xsltCompilerNodePop(cctxt, node);
5611
5612 return(ret);
5613 }
5614
5615 #if 0
5616 static int
5617 xsltParseRemoveWhitespace(xmlNodePtr node)
5618 {
5619 if ((node == NULL) || (node->children == NULL))
5620 return(0);
5621 else {
5622 xmlNodePtr delNode = NULL, child = node->children;
5623
5624 do {
5625 if (delNode) {
5626 xmlUnlinkNode(delNode);
5627 xmlFreeNode(delNode);
5628 delNode = NULL;
5629 }
5630 if (((child->type == XML_TEXT_NODE) ||
5631 (child->type == XML_CDATA_SECTION_NODE)) &&
5632 (IS_BLANK_NODE(child)))
5633 delNode = child;
5634 child = child->next;
5635 } while (child != NULL);
5636 if (delNode) {
5637 xmlUnlinkNode(delNode);
5638 xmlFreeNode(delNode);
5639 delNode = NULL;
5640 }
5641 }
5642 return(0);
5643 }
5644 #endif
5645
5646 static int
5647 xsltParseXSLTStylesheetElemCore(xsltCompilerCtxtPtr cctxt, xmlNodePtr node)
5648 {
5649 #ifdef WITH_XSLT_DEBUG_PARSING
5650 int templates = 0;
5651 #endif
5652 xmlNodePtr cur, start = NULL;
5653 xsltStylesheetPtr style;
5654
5655 if ((cctxt == NULL) || (node == NULL) ||
5656 (node->type != XML_ELEMENT_NODE))
5657 return(-1);
5658
5659 style = cctxt->style;
5660 /*
5661 * At this stage all import declarations of all stylesheet modules
5662 * with the same stylesheet level have been processed.
5663 * Now we can safely parse the rest of the declarations.
5664 */
5665 if (IS_XSLT_ELEM_FAST(node) && IS_XSLT_NAME(node, "include"))
5666 {
5667 xsltDocumentPtr include;
5668 /*
5669 * URGENT TODO: Make this work with simplified stylesheets!
5670 * I.e., when we won't find an xsl:stylesheet element.
5671 */
5672 /*
5673 * This is as include declaration.
5674 */
5675 include = ((xsltStyleItemIncludePtr) node->psvi)->include;
5676 if (include == NULL) {
5677 /* TODO: raise error? */
5678 return(-1);
5679 }
5680 /*
5681 * TODO: Actually an xsl:include should locate an embedded
5682 * stylesheet as well; so the document-element won't always
5683 * be the element where the actual stylesheet is rooted at.
5684 * But such embedded stylesheets are not supported by Libxslt yet.
5685 */
5686 node = xmlDocGetRootElement(include->doc);
5687 if (node == NULL) {
5688 return(-1);
5689 }
5690 }
5691
5692 if (node->children == NULL)
5693 return(0);
5694 /*
5695 * Push the xsl:stylesheet/xsl:transform element.
5696 */
5697 xsltCompilerNodePush(cctxt, node);
5698 cctxt->inode->isRoot = 1;
5699 cctxt->inode->nsChanged = 0;
5700 /*
5701 * Start with the naked dummy info for literal result elements.
5702 */
5703 cctxt->inode->litResElemInfo = cctxt->inodeList->litResElemInfo;
5704
5705 /*
5706 * In every case, we need to have
5707 * the in-scope namespaces of the element, where the
5708 * stylesheet is rooted at, regardless if it's an XSLT
5709 * instruction or a literal result instruction (or if
5710 * this is an embedded stylesheet).
5711 */
5712 cctxt->inode->inScopeNs =
5713 xsltCompilerBuildInScopeNsList(cctxt, node);
5714
5715 /*
5716 * Process attributes of xsl:stylesheet/xsl:transform.
5717 * --------------------------------------------------
5718 * Allowed are:
5719 * id = id
5720 * extension-element-prefixes = tokens
5721 * exclude-result-prefixes = tokens
5722 * version = number (mandatory)
5723 */
5724 if (xsltParseAttrXSLTVersion(cctxt, node,
5725 XSLT_ELEMENT_CATEGORY_XSLT) == 0)
5726 {
5727 /*
5728 * Attribute "version".
5729 * XSLT 1.0: "An xsl:stylesheet element *must* have a version
5730 * attribute, indicating the version of XSLT that the
5731 * stylesheet requires".
5732 * The root element of a simplified stylesheet must also have
5733 * this attribute.
5734 */
5735 #ifdef XSLT_REFACTORED_MANDATORY_VERSION
5736 if (isXsltElem)
5737 xsltTransformError(NULL, cctxt->style, node,
5738 "The attribute 'version' is missing.\n");
5739 cctxt->style->errors++;
5740 #else
5741 /* OLD behaviour. */
5742 xsltTransformError(NULL, cctxt->style, node,
5743 "xsl:version is missing: document may not be a stylesheet\n");
5744 cctxt->style->warnings++;
5745 #endif
5746 }
5747 /*
5748 * The namespaces declared by the attributes
5749 * "extension-element-prefixes" and
5750 * "exclude-result-prefixes" are local to *this*
5751 * stylesheet tree; i.e., they are *not* visible to
5752 * other stylesheet-modules, whether imported or included.
5753 *
5754 * Attribute "extension-element-prefixes".
5755 */
5756 cctxt->inode->extElemNs =
5757 xsltParseExtElemPrefixes(cctxt, node, NULL,
5758 XSLT_ELEMENT_CATEGORY_XSLT);
5759 /*
5760 * Attribute "exclude-result-prefixes".
5761 */
5762 cctxt->inode->exclResultNs =
5763 xsltParseExclResultPrefixes(cctxt, node, NULL,
5764 XSLT_ELEMENT_CATEGORY_XSLT);
5765 /*
5766 * Create/reuse info for the literal result element.
5767 */
5768 if (cctxt->inode->nsChanged)
5769 xsltLREInfoCreate(cctxt, node, 0);
5770 /*
5771 * Processed top-level elements:
5772 * ----------------------------
5773 * xsl:variable, xsl:param (QName, in-scope ns,
5774 * expression (vars allowed))
5775 * xsl:attribute-set (QName, in-scope ns)
5776 * xsl:strip-space, xsl:preserve-space (XPath NameTests,
5777 * in-scope ns)
5778 * I *think* global scope, merge with includes
5779 * xsl:output (QName, in-scope ns)
5780 * xsl:key (QName, in-scope ns, pattern,
5781 * expression (vars *not* allowed))
5782 * xsl:decimal-format (QName, needs in-scope ns)
5783 * xsl:namespace-alias (in-scope ns)
5784 * global scope, merge with includes
5785 * xsl:template (last, QName, pattern)
5786 *
5787 * (whitespace-only text-nodes have *not* been removed
5788 * yet; this will be done in xsltParseSequenceConstructor)
5789 *
5790 * Report misplaced child-nodes first.
5791 */
5792 cur = node->children;
5793 while (cur != NULL) {
5794 if (cur->type == XML_TEXT_NODE) {
5795 xsltTransformError(NULL, style, cur,
5796 "Misplaced text node (content: '%s').\n",
5797 (cur->content != NULL) ? cur->content : BAD_CAST "");
5798 style->errors++;
5799 } else if (cur->type != XML_ELEMENT_NODE) {
5800 xsltTransformError(NULL, style, cur, "Misplaced node.\n");
5801 style->errors++;
5802 }
5803 cur = cur->next;
5804 }
5805 /*
5806 * Skip xsl:import elements; they have been processed
5807 * already.
5808 */
5809 cur = node->children;
5810 while ((cur != NULL) && xsltParseFindTopLevelElem(cctxt, cur,
5811 BAD_CAST "import", XSLT_NAMESPACE, 1, &cur) == 1)
5812 cur = cur->next;
5813 if (cur == NULL)
5814 goto exit;
5815
5816 start = cur;
5817 /*
5818 * Process all top-level xsl:param elements.
5819 */
5820 while ((cur != NULL) &&
5821 xsltParseFindTopLevelElem(cctxt, cur,
5822 BAD_CAST "param", XSLT_NAMESPACE, 0, &cur) == 1)
5823 {
5824 xsltParseTopLevelXSLTElem(cctxt, cur, XSLT_FUNC_PARAM);
5825 cur = cur->next;
5826 }
5827 /*
5828 * Process all top-level xsl:variable elements.
5829 */
5830 cur = start;
5831 while ((cur != NULL) &&
5832 xsltParseFindTopLevelElem(cctxt, cur,
5833 BAD_CAST "variable", XSLT_NAMESPACE, 0, &cur) == 1)
5834 {
5835 xsltParseTopLevelXSLTElem(cctxt, cur, XSLT_FUNC_VARIABLE);
5836 cur = cur->next;
5837 }
5838 /*
5839 * Process all the rest of top-level elements.
5840 */
5841 cur = start;
5842 while (cur != NULL) {
5843 /*
5844 * Process element nodes.
5845 */
5846 if (cur->type == XML_ELEMENT_NODE) {
5847 if (cur->ns == NULL) {
5848 xsltTransformError(NULL, style, cur,
5849 "Unexpected top-level element in no namespace.\n");
5850 style->errors++;
5851 cur = cur->next;
5852 continue;
5853 }
5854 /*
5855 * Process all XSLT elements.
5856 */
5857 if (IS_XSLT_ELEM_FAST(cur)) {
5858 /*
5859 * xsl:import is only allowed at the beginning.
5860 */
5861 if (IS_XSLT_NAME(cur, "import")) {
5862 xsltTransformError(NULL, style, cur,
5863 "Misplaced xsl:import element.\n");
5864 style->errors++;
5865 cur = cur->next;
5866 continue;
5867 }
5868 /*
5869 * TODO: Change the return type of the parsing functions
5870 * to int.
5871 */
5872 if (IS_XSLT_NAME(cur, "template")) {
5873 #ifdef WITH_XSLT_DEBUG_PARSING
5874 templates++;
5875 #endif
5876 /*
5877 * TODO: Is the position of xsl:template in the
5878 * tree significant? If not it would be easier to
5879 * parse them at a later stage.
5880 */
5881 xsltParseXSLTTemplate(cctxt, cur);
5882 } else if (IS_XSLT_NAME(cur, "variable")) {
5883 /* NOP; done already */
5884 } else if (IS_XSLT_NAME(cur, "param")) {
5885 /* NOP; done already */
5886 } else if (IS_XSLT_NAME(cur, "include")) {
5887 if (cur->psvi != NULL)
5888 xsltParseXSLTStylesheetElemCore(cctxt, cur);
5889 else {
5890 xsltTransformError(NULL, style, cur,
5891 "Internal error: "
5892 "(xsltParseXSLTStylesheetElemCore) "
5893 "The xsl:include element was not compiled.\n");
5894 style->errors++;
5895 }
5896 } else if (IS_XSLT_NAME(cur, "strip-space")) {
5897 /* No node info needed. */
5898 xsltParseStylesheetStripSpace(style, cur);
5899 } else if (IS_XSLT_NAME(cur, "preserve-space")) {
5900 /* No node info needed. */
5901 xsltParseStylesheetPreserveSpace(style, cur);
5902 } else if (IS_XSLT_NAME(cur, "output")) {
5903 /* No node-info needed. */
5904 xsltParseStylesheetOutput(style, cur);
5905 } else if (IS_XSLT_NAME(cur, "key")) {
5906 /* TODO: node-info needed for expressions ? */
5907 xsltParseStylesheetKey(style, cur);
5908 } else if (IS_XSLT_NAME(cur, "decimal-format")) {
5909 /* No node-info needed. */
5910 xsltParseStylesheetDecimalFormat(style, cur);
5911 } else if (IS_XSLT_NAME(cur, "attribute-set")) {
5912 xsltParseTopLevelXSLTElem(cctxt, cur,
5913 XSLT_FUNC_ATTRSET);
5914 } else if (IS_XSLT_NAME(cur, "namespace-alias")) {
5915 /* NOP; done already */
5916 } else {
5917 if (cctxt->inode->forwardsCompat) {
5918 /*
5919 * Forwards-compatible mode:
5920 *
5921 * XSLT-1: "if it is a top-level element and
5922 * XSLT 1.0 does not allow such elements as top-level
5923 * elements, then the element must be ignored along
5924 * with its content;"
5925 */
5926 /*
5927 * TODO: I don't think we should generate a warning.
5928 */
5929 xsltTransformError(NULL, style, cur,
5930 "Forwards-compatible mode: Ignoring unknown XSLT "
5931 "element '%s'.\n", cur->name);
5932 style->warnings++;
5933 } else {
5934 xsltTransformError(NULL, style, cur,
5935 "Unknown XSLT element '%s'.\n", cur->name);
5936 style->errors++;
5937 }
5938 }
5939 } else {
5940 xsltTopLevelFunction function;
5941
5942 /*
5943 * Process non-XSLT elements, which are in a
5944 * non-NULL namespace.
5945 */
5946 /*
5947 * QUESTION: What does xsltExtModuleTopLevelLookup()
5948 * do exactly?
5949 */
5950 function = xsltExtModuleTopLevelLookup(cur->name,
5951 cur->ns->href);
5952 if (function != NULL)
5953 function(style, cur);
5954 #ifdef WITH_XSLT_DEBUG_PARSING
5955 xsltGenericDebug(xsltGenericDebugContext,
5956 "xsltParseXSLTStylesheetElemCore : User-defined "
5957 "data element '%s'.\n", cur->name);
5958 #endif
5959 }
5960 }
5961 cur = cur->next;
5962 }
5963
5964 exit:
5965
5966 #ifdef WITH_XSLT_DEBUG_PARSING
5967 xsltGenericDebug(xsltGenericDebugContext,
5968 "### END of parsing top-level elements of doc '%s'.\n",
5969 node->doc->URL);
5970 xsltGenericDebug(xsltGenericDebugContext,
5971 "### Templates: %d\n", templates);
5972 #ifdef XSLT_REFACTORED
5973 xsltGenericDebug(xsltGenericDebugContext,
5974 "### Max inodes: %d\n", cctxt->maxNodeInfos);
5975 xsltGenericDebug(xsltGenericDebugContext,
5976 "### Max LREs : %d\n", cctxt->maxLREs);
5977 #endif /* XSLT_REFACTORED */
5978 #endif /* WITH_XSLT_DEBUG_PARSING */
5979
5980 xsltCompilerNodePop(cctxt, node);
5981 return(0);
5982 }
5983
5984 /**
5985 * xsltParseXSLTStylesheet:
5986 * @cctxt: the compiler context
5987 * @node: the xsl:stylesheet/xsl:transform element-node
5988 *
5989 * Parses the xsl:stylesheet and xsl:transform element.
5990 *
5991 * <xsl:stylesheet
5992 * id = id
5993 * extension-element-prefixes = tokens
5994 * exclude-result-prefixes = tokens
5995 * version = number>
5996 * <!-- Content: (xsl:import*, top-level-elements) -->
5997 * </xsl:stylesheet>
5998 *
5999 * BIG TODO: The xsl:include stuff.
6000 *
6001 * Called by xsltParseStylesheetTree()
6002 *
6003 * Returns 0 on success, a positive result on errors and
6004 * -1 on API or internal errors.
6005 */
6006 static int
6007 xsltParseXSLTStylesheetElem(xsltCompilerCtxtPtr cctxt, xmlNodePtr node)
6008 {
6009 xmlNodePtr cur, start;
6010
6011 if ((cctxt == NULL) || (node == NULL) || (node->type != XML_ELEMENT_NODE))
6012 return(-1);
6013
6014 if (node->children == NULL)
6015 goto exit;
6016
6017 /*
6018 * Process top-level elements:
6019 * xsl:import (must be first)
6020 * xsl:include (this is just a pre-processing)
6021 */
6022 cur = node->children;
6023 /*
6024 * Process xsl:import elements.
6025 * XSLT 1.0: "The xsl:import element children must precede all
6026 * other element children of an xsl:stylesheet element,
6027 * including any xsl:include element children."
6028 */
6029 while ((cur != NULL) &&
6030 xsltParseFindTopLevelElem(cctxt, cur,
6031 BAD_CAST "import", XSLT_NAMESPACE, 1, &cur) == 1)
6032 {
6033 if (xsltParseStylesheetImport(cctxt->style, cur) != 0) {
6034 cctxt->style->errors++;
6035 }
6036 cur = cur->next;
6037 }
6038 if (cur == NULL)
6039 goto exit;
6040 start = cur;
6041 /*
6042 * Pre-process all xsl:include elements.
6043 */
6044 cur = start;
6045 while ((cur != NULL) &&
6046 xsltParseFindTopLevelElem(cctxt, cur,
6047 BAD_CAST "include", XSLT_NAMESPACE, 0, &cur) == 1)
6048 {
6049 xsltParseTopLevelXSLTElem(cctxt, cur, XSLT_FUNC_INCLUDE);
6050 cur = cur->next;
6051 }
6052 /*
6053 * Pre-process all xsl:namespace-alias elements.
6054 * URGENT TODO: This won't work correctly: the order of included
6055 * aliases and aliases defined here is significant.
6056 */
6057 cur = start;
6058 while ((cur != NULL) &&
6059 xsltParseFindTopLevelElem(cctxt, cur,
6060 BAD_CAST "namespace-alias", XSLT_NAMESPACE, 0, &cur) == 1)
6061 {
6062 xsltNamespaceAlias(cctxt->style, cur);
6063 cur = cur->next;
6064 }
6065
6066 if (cctxt->isInclude) {
6067 /*
6068 * If this stylesheet is intended for inclusion, then
6069 * we will process only imports and includes.
6070 */
6071 goto exit;
6072 }
6073 /*
6074 * Now parse the rest of the top-level elements.
6075 */
6076 xsltParseXSLTStylesheetElemCore(cctxt, node);
6077 exit:
6078
6079 return(0);
6080 }
6081
6082 #else /* XSLT_REFACTORED */
6083
6084 /**
6085 * xsltParseStylesheetTop:
6086 * @style: the XSLT stylesheet
6087 * @top: the top level "stylesheet" or "transform" element
6088 *
6089 * scan the top level elements of an XSL stylesheet
6090 */
6091 static void
6092 xsltParseStylesheetTop(xsltStylesheetPtr style, xmlNodePtr top) {
6093 xmlNodePtr cur;
6094 xmlChar *prop;
6095 #ifdef WITH_XSLT_DEBUG_PARSING
6096 int templates = 0;
6097 #endif
6098
6099 if ((top == NULL) || (top->type != XML_ELEMENT_NODE))
6100 return;
6101
6102 prop = xmlGetNsProp(top, (const xmlChar *)"version", NULL);
6103 if (prop == NULL) {
6104 xsltTransformError(NULL, style, top,
6105 "xsl:version is missing: document may not be a stylesheet\n");
6106 if (style != NULL) style->warnings++;
6107 } else {
6108 if ((!xmlStrEqual(prop, (const xmlChar *)"1.0")) &&
6109 (!xmlStrEqual(prop, (const xmlChar *)"1.1"))) {
6110 xsltTransformError(NULL, style, top,
6111 "xsl:version: only 1.1 features are supported\n");
6112 if (style != NULL) {
6113 style->forwards_compatible = 1;
6114 style->warnings++;
6115 }
6116 }
6117 xmlFree(prop);
6118 }
6119
6120 /*
6121 * process xsl:import elements
6122 */
6123 cur = top->children;
6124 while (cur != NULL) {
6125 if (IS_BLANK_NODE(cur)) {
6126 cur = cur->next;
6127 continue;
6128 }
6129 if (IS_XSLT_ELEM(cur) && IS_XSLT_NAME(cur, "import")) {
6130 if (xsltParseStylesheetImport(style, cur) != 0)
6131 if (style != NULL) style->errors++;
6132 } else
6133 break;
6134 cur = cur->next;
6135 }
6136
6137 /*
6138 * process other top-level elements
6139 */
6140 while (cur != NULL) {
6141 if (IS_BLANK_NODE(cur)) {
6142 cur = cur->next;
6143 continue;
6144 }
6145 if (cur->type == XML_TEXT_NODE) {
6146 if (cur->content != NULL) {
6147 xsltTransformError(NULL, style, cur,
6148 "misplaced text node: '%s'\n", cur->content);
6149 }
6150 if (style != NULL) style->errors++;
6151 cur = cur->next;
6152 continue;
6153 }
6154 if ((cur->type == XML_ELEMENT_NODE) && (cur->ns == NULL)) {
6155 xsltGenericError(xsltGenericErrorContext,
6156 "Found a top-level element %s with null namespace URI\n",
6157 cur->name);
6158 if (style != NULL) style->errors++;
6159 cur = cur->next;
6160 continue;
6161 }
6162 if ((cur->type == XML_ELEMENT_NODE) && (!(IS_XSLT_ELEM(cur)))) {
6163 xsltTopLevelFunction function;
6164
6165 function = xsltExtModuleTopLevelLookup(cur->name,
6166 cur->ns->href);
6167 if (function != NULL)
6168 function(style, cur);
6169
6170 #ifdef WITH_XSLT_DEBUG_PARSING
6171 xsltGenericDebug(xsltGenericDebugContext,
6172 "xsltParseStylesheetTop : found foreign element %s\n",
6173 cur->name);
6174 #endif
6175 cur = cur->next;
6176 continue;
6177 }
6178 if (IS_XSLT_NAME(cur, "import")) {
6179 xsltTransformError(NULL, style, cur,
6180 "xsltParseStylesheetTop: ignoring misplaced import element\n");
6181 if (style != NULL) style->errors++;
6182 } else if (IS_XSLT_NAME(cur, "include")) {
6183 if (xsltParseStylesheetInclude(style, cur) != 0)
6184 if (style != NULL) style->errors++;
6185 } else if (IS_XSLT_NAME(cur, "strip-space")) {
6186 xsltParseStylesheetStripSpace(style, cur);
6187 } else if (IS_XSLT_NAME(cur, "preserve-space")) {
6188 xsltParseStylesheetPreserveSpace(style, cur);
6189 } else if (IS_XSLT_NAME(cur, "output")) {
6190 xsltParseStylesheetOutput(style, cur);
6191 } else if (IS_XSLT_NAME(cur, "key")) {
6192 xsltParseStylesheetKey(style, cur);
6193 } else if (IS_XSLT_NAME(cur, "decimal-format")) {
6194 xsltParseStylesheetDecimalFormat(style, cur);
6195 } else if (IS_XSLT_NAME(cur, "attribute-set")) {
6196 xsltParseStylesheetAttributeSet(style, cur);
6197 } else if (IS_XSLT_NAME(cur, "variable")) {
6198 xsltParseGlobalVariable(style, cur);
6199 } else if (IS_XSLT_NAME(cur, "param")) {
6200 xsltParseGlobalParam(style, cur);
6201 } else if (IS_XSLT_NAME(cur, "template")) {
6202 #ifdef WITH_XSLT_DEBUG_PARSING
6203 templates++;
6204 #endif
6205 xsltParseStylesheetTemplate(style, cur);
6206 } else if (IS_XSLT_NAME(cur, "namespace-alias")) {
6207 xsltNamespaceAlias(style, cur);
6208 } else {
6209 if ((style != NULL) && (style->forwards_compatible == 0)) {
6210 xsltTransformError(NULL, style, cur,
6211 "xsltParseStylesheetTop: unknown %s element\n",
6212 cur->name);
6213 if (style != NULL) style->errors++;
6214 }
6215 }
6216 cur = cur->next;
6217 }
6218 #ifdef WITH_XSLT_DEBUG_PARSING
6219 xsltGenericDebug(xsltGenericDebugContext,
6220 "parsed %d templates\n", templates);
6221 #endif
6222 }
6223
6224 #endif /* else of XSLT_REFACTORED */
6225
6226 #ifdef XSLT_REFACTORED
6227 /**
6228 * xsltParseSimplifiedStylesheetTree:
6229 *
6230 * @style: the stylesheet (TODO: Change this to the compiler context)
6231 * @doc: the document containing the stylesheet.
6232 * @node: the node where the stylesheet is rooted at
6233 *
6234 * Returns 0 in case of success, a positive result if an error occurred
6235 * and -1 on API and internal errors.
6236 */
6237 static int
6238 xsltParseSimplifiedStylesheetTree(xsltCompilerCtxtPtr cctxt,
6239 xmlDocPtr doc,
6240 xmlNodePtr node)
6241 {
6242 xsltTemplatePtr templ;
6243
6244 if ((cctxt == NULL) || (node == NULL))
6245 return(-1);
6246
6247 if (xsltParseAttrXSLTVersion(cctxt, node, 0) == XSLT_ELEMENT_CATEGORY_LRE)
6248 {
6249 /*
6250 * TODO: Adjust report, since this might be an
6251 * embedded stylesheet.
6252 */
6253 xsltTransformError(NULL, cctxt->style, node,
6254 "The attribute 'xsl:version' is missing; cannot identify "
6255 "this document as an XSLT stylesheet document.\n");
6256 cctxt->style->errors++;
6257 return(1);
6258 }
6259
6260 #ifdef WITH_XSLT_DEBUG_PARSING
6261 xsltGenericDebug(xsltGenericDebugContext,
6262 "xsltParseSimplifiedStylesheetTree: document is stylesheet\n");
6263 #endif
6264
6265 /*
6266 * Create and link the template
6267 */
6268 templ = xsltNewTemplate();
6269 if (templ == NULL) {
6270 return(-1);
6271 }
6272 templ->next = cctxt->style->templates;
6273 cctxt->style->templates = templ;
6274 templ->match = xmlStrdup(BAD_CAST "/");
6275
6276 /*
6277 * Note that we push the document-node in this special case.
6278 */
6279 xsltCompilerNodePush(cctxt, (xmlNodePtr) doc);
6280 /*
6281 * In every case, we need to have
6282 * the in-scope namespaces of the element, where the
6283 * stylesheet is rooted at, regardless if it's an XSLT
6284 * instruction or a literal result instruction (or if
6285 * this is an embedded stylesheet).
6286 */
6287 cctxt->inode->inScopeNs =
6288 xsltCompilerBuildInScopeNsList(cctxt, node);
6289 /*
6290 * Parse the content and register the match-pattern.
6291 */
6292 xsltParseSequenceConstructor(cctxt, node);
6293 xsltCompilerNodePop(cctxt, (xmlNodePtr) doc);
6294
6295 templ->elem = (xmlNodePtr) doc;
6296 templ->content = node;
6297 xsltAddTemplate(cctxt->style, templ, NULL, NULL);
6298 cctxt->style->literal_result = 1;
6299 return(0);
6300 }
6301
6302 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
6303 /**
6304 * xsltRestoreDocumentNamespaces:
6305 * @ns: map of namespaces
6306 * @doc: the document
6307 *
6308 * Restore the namespaces for the document
6309 *
6310 * Returns 0 in case of success, -1 in case of failure
6311 */
6312 int
6313 xsltRestoreDocumentNamespaces(xsltNsMapPtr ns, xmlDocPtr doc)
6314 {
6315 if (doc == NULL)
6316 return(-1);
6317 /*
6318 * Revert the changes we have applied to the namespace-URIs of
6319 * ns-decls.
6320 */
6321 while (ns != NULL) {
6322 if ((ns->doc == doc) && (ns->ns != NULL)) {
6323 ns->ns->href = ns->origNsName;
6324 ns->origNsName = NULL;
6325 ns->ns = NULL;
6326 }
6327 ns = ns->next;
6328 }
6329 return(0);
6330 }
6331 #endif /* XSLT_REFACTORED_XSLT_NSCOMP */
6332
6333 /**
6334 * xsltParseStylesheetProcess:
6335 * @style: the XSLT stylesheet (the current stylesheet-level)
6336 * @doc: and xmlDoc parsed XML
6337 *
6338 * Parses an XSLT stylesheet, adding the associated structures.
6339 * Called by:
6340 * xsltParseStylesheetImportedDoc() (xslt.c)
6341 * xsltParseStylesheetInclude() (imports.c)
6342 *
6343 * Returns the value of the @style parameter if everything
6344 * went right, NULL if something went amiss.
6345 */
6346 xsltStylesheetPtr
6347 xsltParseStylesheetProcess(xsltStylesheetPtr style, xmlDocPtr doc)
6348 {
6349 xsltCompilerCtxtPtr cctxt;
6350 xmlNodePtr cur;
6351 int oldIsSimplifiedStylesheet;
6352
6353 xsltInitGlobals();
6354
6355 if ((style == NULL) || (doc == NULL))
6356 return(NULL);
6357
6358 cctxt = XSLT_CCTXT(style);
6359
6360 cur = xmlDocGetRootElement(doc);
6361 if (cur == NULL) {
6362 xsltTransformError(NULL, style, (xmlNodePtr) doc,
6363 "xsltParseStylesheetProcess : empty stylesheet\n");
6364 return(NULL);
6365 }
6366 oldIsSimplifiedStylesheet = cctxt->simplified;
6367
6368 if ((IS_XSLT_ELEM(cur)) &&
6369 ((IS_XSLT_NAME(cur, "stylesheet")) ||
6370 (IS_XSLT_NAME(cur, "transform")))) {
6371 #ifdef WITH_XSLT_DEBUG_PARSING
6372 xsltGenericDebug(xsltGenericDebugContext,
6373 "xsltParseStylesheetProcess : found stylesheet\n");
6374 #endif
6375 cctxt->simplified = 0;
6376 style->literal_result = 0;
6377 } else {
6378 cctxt->simplified = 1;
6379 style->literal_result = 1;
6380 }
6381 /*
6382 * Pre-process the stylesheet if not already done before.
6383 * This will remove PIs and comments, merge adjacent
6384 * text nodes, internalize strings, etc.
6385 */
6386 if (! style->nopreproc)
6387 xsltParsePreprocessStylesheetTree(cctxt, cur);
6388 /*
6389 * Parse and compile the stylesheet.
6390 */
6391 if (style->literal_result == 0) {
6392 if (xsltParseXSLTStylesheetElem(cctxt, cur) != 0)
6393 return(NULL);
6394 } else {
6395 if (xsltParseSimplifiedStylesheetTree(cctxt, doc, cur) != 0)
6396 return(NULL);
6397 }
6398
6399 cctxt->simplified = oldIsSimplifiedStylesheet;
6400
6401 return(style);
6402 }
6403
6404 #else /* XSLT_REFACTORED */
6405
6406 /**
6407 * xsltParseStylesheetProcess:
6408 * @ret: the XSLT stylesheet (the current stylesheet-level)
6409 * @doc: and xmlDoc parsed XML
6410 *
6411 * Parses an XSLT stylesheet, adding the associated structures.
6412 * Called by:
6413 * xsltParseStylesheetImportedDoc() (xslt.c)
6414 * xsltParseStylesheetInclude() (imports.c)
6415 *
6416 * Returns the value of the @style parameter if everything
6417 * went right, NULL if something went amiss.
6418 */
6419 xsltStylesheetPtr
6420 xsltParseStylesheetProcess(xsltStylesheetPtr ret, xmlDocPtr doc) {
6421 xmlNodePtr cur;
6422
6423 xsltInitGlobals();
6424
6425 if (doc == NULL)
6426 return(NULL);
6427 if (ret == NULL)
6428 return(ret);
6429
6430 /*
6431 * First steps, remove blank nodes,
6432 * locate the xsl:stylesheet element and the
6433 * namespace declaration.
6434 */
6435 cur = xmlDocGetRootElement(doc);
6436 if (cur == NULL) {
6437 xsltTransformError(NULL, ret, (xmlNodePtr) doc,
6438 "xsltParseStylesheetProcess : empty stylesheet\n");
6439 return(NULL);
6440 }
6441
6442 if ((IS_XSLT_ELEM(cur)) &&
6443 ((IS_XSLT_NAME(cur, "stylesheet")) ||
6444 (IS_XSLT_NAME(cur, "transform")))) {
6445 #ifdef WITH_XSLT_DEBUG_PARSING
6446 xsltGenericDebug(xsltGenericDebugContext,
6447 "xsltParseStylesheetProcess : found stylesheet\n");
6448 #endif
6449 ret->literal_result = 0;
6450 xsltParseStylesheetExcludePrefix(ret, cur, 1);
6451 xsltParseStylesheetExtPrefix(ret, cur, 1);
6452 } else {
6453 xsltParseStylesheetExcludePrefix(ret, cur, 0);
6454 xsltParseStylesheetExtPrefix(ret, cur, 0);
6455 ret->literal_result = 1;
6456 }
6457 if (!ret->nopreproc) {
6458 xsltPreprocessStylesheet(ret, cur);
6459 }
6460 if (ret->literal_result == 0) {
6461 xsltParseStylesheetTop(ret, cur);
6462 } else {
6463 xmlChar *prop;
6464 xsltTemplatePtr template;
6465
6466 /*
6467 * the document itself might be the template, check xsl:version
6468 */
6469 prop = xmlGetNsProp(cur, (const xmlChar *)"version", XSLT_NAMESPACE);
6470 if (prop == NULL) {
6471 xsltTransformError(NULL, ret, cur,
6472 "xsltParseStylesheetProcess : document is not a stylesheet\n");
6473 return(NULL);
6474 }
6475
6476 #ifdef WITH_XSLT_DEBUG_PARSING
6477 xsltGenericDebug(xsltGenericDebugContext,
6478 "xsltParseStylesheetProcess : document is stylesheet\n");
6479 #endif
6480
6481 if ((!xmlStrEqual(prop, (const xmlChar *)"1.0")) &&
6482 (!xmlStrEqual(prop, (const xmlChar *)"1.1"))) {
6483 xsltTransformError(NULL, ret, cur,
6484 "xsl:version: only 1.1 features are supported\n");
6485 ret->forwards_compatible = 1;
6486 ret->warnings++;
6487 }
6488 xmlFree(prop);
6489
6490 /*
6491 * Create and link the template
6492 */
6493 template = xsltNewTemplate();
6494 if (template == NULL) {
6495 return(NULL);
6496 }
6497 template->next = ret->templates;
6498 ret->templates = template;
6499 template->match = xmlStrdup((const xmlChar *)"/");
6500
6501 /*
6502 * parse the content and register the pattern
6503 */
6504 xsltParseTemplateContent(ret, (xmlNodePtr) doc);
6505 template->elem = (xmlNodePtr) doc;
6506 template->content = doc->children;
6507 xsltAddTemplate(ret, template, NULL, NULL);
6508 ret->literal_result = 1;
6509 }
6510
6511 return(ret);
6512 }
6513
6514 #endif /* else of XSLT_REFACTORED */
6515
6516 /**
6517 * xsltParseStylesheetImportedDoc:
6518 * @doc: an xmlDoc parsed XML
6519 * @parentStyle: pointer to the parent stylesheet (if it exists)
6520 *
6521 * parse an XSLT stylesheet building the associated structures
6522 * except the processing not needed for imported documents.
6523 *
6524 * Returns a new XSLT stylesheet structure.
6525 */
6526
6527 xsltStylesheetPtr
6528 xsltParseStylesheetImportedDoc(xmlDocPtr doc,
6529 xsltStylesheetPtr parentStyle) {
6530 xsltStylesheetPtr retStyle;
6531
6532 if (doc == NULL)
6533 return(NULL);
6534
6535 retStyle = xsltNewStylesheet();
6536 if (retStyle == NULL)
6537 return(NULL);
6538 /*
6539 * Set the importing stylesheet module; also used to detect recursion.
6540 */
6541 retStyle->parent = parentStyle;
6542 /*
6543 * Adjust the string dict.
6544 */
6545 if (doc->dict != NULL) {
6546 xmlDictFree(retStyle->dict);
6547 retStyle->dict = doc->dict;
6548 #ifdef WITH_XSLT_DEBUG
6549 xsltGenericDebug(xsltGenericDebugContext,
6550 "reusing dictionary from %s for stylesheet\n",
6551 doc->URL);
6552 #endif
6553 xmlDictReference(retStyle->dict);
6554 }
6555
6556 /*
6557 * TODO: Eliminate xsltGatherNamespaces(); we must not restrict
6558 * the stylesheet to containt distinct namespace prefixes.
6559 */
6560 xsltGatherNamespaces(retStyle);
6561
6562 #ifdef XSLT_REFACTORED
6563 {
6564 xsltCompilerCtxtPtr cctxt;
6565 xsltStylesheetPtr oldCurSheet;
6566
6567 if (parentStyle == NULL) {
6568 xsltPrincipalStylesheetDataPtr principalData;
6569 /*
6570 * Principal stylesheet
6571 * --------------------
6572 */
6573 retStyle->principal = retStyle;
6574 /*
6575 * Create extra data for the principal stylesheet.
6576 */
6577 principalData = xsltNewPrincipalStylesheetData();
6578 if (principalData == NULL) {
6579 xsltFreeStylesheet(retStyle);
6580 return(NULL);
6581 }
6582 retStyle->principalData = principalData;
6583 /*
6584 * Create the compilation context
6585 * ------------------------------
6586 * (only once; for the principal stylesheet).
6587 * This is currently the only function where the
6588 * compilation context is created.
6589 */
6590 cctxt = xsltCompilationCtxtCreate(retStyle);
6591 if (cctxt == NULL) {
6592 xsltFreeStylesheet(retStyle);
6593 return(NULL);
6594 }
6595 retStyle->compCtxt = (void *) cctxt;
6596 cctxt->style = retStyle;
6597 cctxt->dict = retStyle->dict;
6598 cctxt->psData = principalData;
6599 /*
6600 * Push initial dummy node info.
6601 */
6602 cctxt->depth = -1;
6603 xsltCompilerNodePush(cctxt, (xmlNodePtr) doc);
6604 } else {
6605 /*
6606 * Imported stylesheet.
6607 */
6608 retStyle->principal = parentStyle->principal;
6609 cctxt = parentStyle->compCtxt;
6610 retStyle->compCtxt = cctxt;
6611 }
6612 /*
6613 * Save the old and set the current stylesheet structure in the
6614 * compilation context.
6615 */
6616 oldCurSheet = cctxt->style;
6617 cctxt->style = retStyle;
6618
6619 retStyle->doc = doc;
6620 xsltParseStylesheetProcess(retStyle, doc);
6621
6622 cctxt->style = oldCurSheet;
6623 if (parentStyle == NULL) {
6624 /*
6625 * Pop the initial dummy node info.
6626 */
6627 xsltCompilerNodePop(cctxt, (xmlNodePtr) doc);
6628 } else {
6629 /*
6630 * Clear the compilation context of imported
6631 * stylesheets.
6632 * TODO: really?
6633 */
6634 /* retStyle->compCtxt = NULL; */
6635 }
6636 /*
6637 * Free the stylesheet if there were errors.
6638 */
6639 if (retStyle != NULL) {
6640 if (retStyle->errors != 0) {
6641 #ifdef XSLT_REFACTORED_XSLT_NSCOMP
6642 /*
6643 * Restore all changes made to namespace URIs of ns-decls.
6644 */
6645 if (cctxt->psData->nsMap)
6646 xsltRestoreDocumentNamespaces(cctxt->psData->nsMap, doc);
6647 #endif
6648 /*
6649 * Detach the doc from the stylesheet; otherwise the doc
6650 * will be freed in xsltFreeStylesheet().
6651 */
6652 retStyle->doc = NULL;
6653 /*
6654 * Cleanup the doc if its the main stylesheet.
6655 */
6656 if (parentStyle == NULL) {
6657 xsltCleanupStylesheetTree(doc, xmlDocGetRootElement(doc));
6658 if (retStyle->compCtxt != NULL) {
6659 xsltCompilationCtxtFree(retStyle->compCtxt);
6660 retStyle->compCtxt = NULL;
6661 }
6662 }
6663
6664 xsltFreeStylesheet(retStyle);
6665 retStyle = NULL;
6666 }
6667 }
6668 }
6669
6670 #else /* XSLT_REFACTORED */
6671 /*
6672 * Old behaviour.
6673 */
6674 retStyle->doc = doc;
6675 if (xsltParseStylesheetProcess(retStyle, doc) == NULL) {
6676 retStyle->doc = NULL;
6677 xsltFreeStylesheet(retStyle);
6678 retStyle = NULL;
6679 }
6680 if (retStyle != NULL) {
6681 if (retStyle->errors != 0) {
6682 retStyle->doc = NULL;
6683 if (parentStyle == NULL)
6684 xsltCleanupStylesheetTree(doc,
6685 xmlDocGetRootElement(doc));
6686 xsltFreeStylesheet(retStyle);
6687 retStyle = NULL;
6688 }
6689 }
6690 #endif /* else of XSLT_REFACTORED */
6691
6692 return(retStyle);
6693 }
6694
6695 /**
6696 * xsltParseStylesheetDoc:
6697 * @doc: and xmlDoc parsed XML
6698 *
6699 * parse an XSLT stylesheet, building the associated structures. doc
6700 * is kept as a reference within the returned stylesheet, so changes
6701 * to doc after the parsing will be reflected when the stylesheet
6702 * is applied, and the doc is automatically freed when the
6703 * stylesheet is closed.
6704 *
6705 * Returns a new XSLT stylesheet structure.
6706 */
6707
6708 xsltStylesheetPtr
6709 xsltParseStylesheetDoc(xmlDocPtr doc) {
6710 xsltStylesheetPtr ret;
6711
6712 xsltInitGlobals();
6713
6714 ret = xsltParseStylesheetImportedDoc(doc, NULL);
6715 if (ret == NULL)
6716 return(NULL);
6717
6718 xsltResolveStylesheetAttributeSet(ret);
6719 #ifdef XSLT_REFACTORED
6720 /*
6721 * Free the compilation context.
6722 * TODO: Check if it's better to move this cleanup to
6723 * xsltParseStylesheetImportedDoc().
6724 */
6725 if (ret->compCtxt != NULL) {
6726 xsltCompilationCtxtFree(XSLT_CCTXT(ret));
6727 ret->compCtxt = NULL;
6728 }
6729 #endif
6730 return(ret);
6731 }
6732
6733 /**
6734 * xsltParseStylesheetFile:
6735 * @filename: the filename/URL to the stylesheet
6736 *
6737 * Load and parse an XSLT stylesheet
6738 *
6739 * Returns a new XSLT stylesheet structure.
6740 */
6741
6742 xsltStylesheetPtr
6743 xsltParseStylesheetFile(const xmlChar* filename) {
6744 xsltSecurityPrefsPtr sec;
6745 xsltStylesheetPtr ret;
6746 xmlDocPtr doc;
6747
6748 xsltInitGlobals();
6749
6750 if (filename == NULL)
6751 return(NULL);
6752
6753 #ifdef WITH_XSLT_DEBUG_PARSING
6754 xsltGenericDebug(xsltGenericDebugContext,
6755 "xsltParseStylesheetFile : parse %s\n", filename);
6756 #endif
6757
6758 /*
6759 * Security framework check
6760 */
6761 sec = xsltGetDefaultSecurityPrefs();
6762 if (sec != NULL) {
6763 int res;
6764
6765 res = xsltCheckRead(sec, NULL, filename);
6766 if (res == 0) {
6767 xsltTransformError(NULL, NULL, NULL,
6768 "xsltParseStylesheetFile: read rights for %s denied\n",
6769 filename);
6770 return(NULL);
6771 }
6772 }
6773
6774 doc = xsltDocDefaultLoader(filename, NULL, XSLT_PARSE_OPTIONS,
6775 NULL, XSLT_LOAD_START);
6776 if (doc == NULL) {
6777 xsltTransformError(NULL, NULL, NULL,
6778 "xsltParseStylesheetFile : cannot parse %s\n", filename);
6779 return(NULL);
6780 }
6781 ret = xsltParseStylesheetDoc(doc);
6782 if (ret == NULL) {
6783 xmlFreeDoc(doc);
6784 return(NULL);
6785 }
6786
6787 return(ret);
6788 }
6789
6790 /************************************************************************
6791 * *
6792 * Handling of Stylesheet PI *
6793 * *
6794 ************************************************************************/
6795
6796 #define CUR (*cur)
6797 #define SKIP(val) cur += (val)
6798 #define NXT(val) cur[(val)]
6799 #define SKIP_BLANKS \
6800 while (IS_BLANK(CUR)) NEXT
6801 #define NEXT ((*cur) ? cur++ : cur)
6802
6803 /**
6804 * xsltParseStylesheetPI:
6805 * @value: the value of the PI
6806 *
6807 * This function checks that the type is text/xml and extracts
6808 * the URI-Reference for the stylesheet
6809 *
6810 * Returns the URI-Reference for the stylesheet or NULL (it need to
6811 * be freed by the caller)
6812 */
6813 static xmlChar *
6814 xsltParseStylesheetPI(const xmlChar *value) {
6815 const xmlChar *cur;
6816 const xmlChar *start;
6817 xmlChar *val;
6818 xmlChar tmp;
6819 xmlChar *href = NULL;
6820 int isXml = 0;
6821
6822 if (value == NULL)
6823 return(NULL);
6824
6825 cur = value;
6826 while (CUR != 0) {
6827 SKIP_BLANKS;
6828 if ((CUR == 't') && (NXT(1) == 'y') && (NXT(2) == 'p') &&
6829 (NXT(3) == 'e')) {
6830 SKIP(4);
6831 SKIP_BLANKS;
6832 if (CUR != '=')
6833 continue;
6834 NEXT;
6835 if ((CUR != '\'') && (CUR != '"'))
6836 continue;
6837 tmp = CUR;
6838 NEXT;
6839 start = cur;
6840 while ((CUR != 0) && (CUR != tmp))
6841 NEXT;
6842 if (CUR != tmp)
6843 continue;
6844 val = xmlStrndup(start, cur - start);
6845 NEXT;
6846 if (val == NULL)
6847 return(NULL);
6848 if ((xmlStrcasecmp(val, BAD_CAST "text/xml")) &&
6849 (xmlStrcasecmp(val, BAD_CAST "text/xsl"))) {
6850 xmlFree(val);
6851 break;
6852 }
6853 isXml = 1;
6854 xmlFree(val);
6855 } else if ((CUR == 'h') && (NXT(1) == 'r') && (NXT(2) == 'e') &&
6856 (NXT(3) == 'f')) {
6857 SKIP(4);
6858 SKIP_BLANKS;
6859 if (CUR != '=')
6860 continue;
6861 NEXT;
6862 if ((CUR != '\'') && (CUR != '"'))
6863 continue;
6864 tmp = CUR;
6865 NEXT;
6866 start = cur;
6867 while ((CUR != 0) && (CUR != tmp))
6868 NEXT;
6869 if (CUR != tmp)
6870 continue;
6871 if (href == NULL)
6872 href = xmlStrndup(start, cur - start);
6873 NEXT;
6874 } else {
6875 while ((CUR != 0) && (!IS_BLANK(CUR)))
6876 NEXT;
6877 }
6878
6879 }
6880
6881 if (!isXml) {
6882 if (href != NULL)
6883 xmlFree(href);
6884 href = NULL;
6885 }
6886 return(href);
6887 }
6888
6889 /**
6890 * xsltLoadStylesheetPI:
6891 * @doc: a document to process
6892 *
6893 * This function tries to locate the stylesheet PI in the given document
6894 * If found, and if contained within the document, it will extract
6895 * that subtree to build the stylesheet to process @doc (doc itself will
6896 * be modified). If found but referencing an external document it will
6897 * attempt to load it and generate a stylesheet from it. In both cases,
6898 * the resulting stylesheet and the document need to be freed once the
6899 * transformation is done.
6900 *
6901 * Returns a new XSLT stylesheet structure or NULL if not found.
6902 */
6903 xsltStylesheetPtr
6904 xsltLoadStylesheetPI(xmlDocPtr doc) {
6905 xmlNodePtr child;
6906 xsltStylesheetPtr ret = NULL;
6907 xmlChar *href = NULL;
6908 xmlURIPtr URI;
6909
6910 xsltInitGlobals();
6911
6912 if (doc == NULL)
6913 return(NULL);
6914
6915 /*
6916 * Find the text/xml stylesheet PI id any before the root
6917 */
6918 child = doc->children;
6919 while ((child != NULL) && (child->type != XML_ELEMENT_NODE)) {
6920 if ((child->type == XML_PI_NODE) &&
6921 (xmlStrEqual(child->name, BAD_CAST "xml-stylesheet"))) {
6922 href = xsltParseStylesheetPI(child->content);
6923 if (href != NULL)
6924 break;
6925 }
6926 child = child->next;
6927 }
6928
6929 /*
6930 * If found check the href to select processing
6931 */
6932 if (href != NULL) {
6933 #ifdef WITH_XSLT_DEBUG_PARSING
6934 xsltGenericDebug(xsltGenericDebugContext,
6935 "xsltLoadStylesheetPI : found PI href=%s\n", href);
6936 #endif
6937 URI = xmlParseURI((const char *) href);
6938 if (URI == NULL) {
6939 xsltTransformError(NULL, NULL, child,
6940 "xml-stylesheet : href %s is not valid\n", href);
6941 xmlFree(href);
6942 return(NULL);
6943 }
6944 if ((URI->fragment != NULL) && (URI->scheme == NULL) &&
6945 (URI->opaque == NULL) && (URI->authority == NULL) &&
6946 (URI->server == NULL) && (URI->user == NULL) &&
6947 (URI->path == NULL) && (URI->query == NULL)) {
6948 xmlAttrPtr ID;
6949
6950 #ifdef WITH_XSLT_DEBUG_PARSING
6951 xsltGenericDebug(xsltGenericDebugContext,
6952 "xsltLoadStylesheetPI : Reference to ID %s\n", href);
6953 #endif
6954 if (URI->fragment[0] == '#')
6955 ID = xmlGetID(doc, (const xmlChar *) &(URI->fragment[1]));
6956 else
6957 ID = xmlGetID(doc, (const xmlChar *) URI->fragment);
6958 if (ID == NULL) {
6959 xsltTransformError(NULL, NULL, child,
6960 "xml-stylesheet : no ID %s found\n", URI->fragment);
6961 } else {
6962 xmlDocPtr fake;
6963 xmlNodePtr subtree, newtree;
6964 xmlNsPtr ns;
6965
6966 #ifdef WITH_XSLT_DEBUG
6967 xsltGenericDebug(xsltGenericDebugContext,
6968 "creating new document from %s for embedded stylesheet\n",
6969 doc->URL);
6970 #endif
6971 /*
6972 * move the subtree in a new document passed to
6973 * the stylesheet analyzer
6974 */
6975 subtree = ID->parent;
6976 fake = xmlNewDoc(NULL);
6977 if (fake != NULL) {
6978 /*
6979 * Should the dictionary still be shared even though
6980 * the nodes are being copied rather than moved?
6981 */
6982 fake->dict = doc->dict;
6983 xmlDictReference(doc->dict);
6984 #ifdef WITH_XSLT_DEBUG
6985 xsltGenericDebug(xsltGenericDebugContext,
6986 "reusing dictionary from %s for embedded stylesheet\n",
6987 doc->URL);
6988 #endif
6989
6990 newtree = xmlDocCopyNode(subtree, fake, 1);
6991
6992 fake->URL = xmlNodeGetBase(doc, subtree->parent);
6993 #ifdef WITH_XSLT_DEBUG
6994 xsltGenericDebug(xsltGenericDebugContext,
6995 "set base URI for embedded stylesheet as %s\n",
6996 fake->URL);
6997 #endif
6998
6999 /*
7000 * Add all namespaces in scope of embedded stylesheet to
7001 * root element of newly created stylesheet document
7002 */
7003 while ((subtree = subtree->parent) != (xmlNodePtr)doc) {
7004 for (ns = subtree->ns; ns; ns = ns->next) {
7005 xmlNewNs(newtree, ns->href, ns->prefix);
7006 }
7007 }
7008
7009 xmlAddChild((xmlNodePtr)fake, newtree);
7010 ret = xsltParseStylesheetDoc(fake);
7011 if (ret == NULL)
7012 xmlFreeDoc(fake);
7013 }
7014 }
7015 } else {
7016 xmlChar *URL, *base;
7017
7018 /*
7019 * Reference to an external stylesheet
7020 */
7021
7022 base = xmlNodeGetBase(doc, (xmlNodePtr) doc);
7023 URL = xmlBuildURI(href, base);
7024 if (URL != NULL) {
7025 #ifdef WITH_XSLT_DEBUG_PARSING
7026 xsltGenericDebug(xsltGenericDebugContext,
7027 "xsltLoadStylesheetPI : fetching %s\n", URL);
7028 #endif
7029 ret = xsltParseStylesheetFile(URL);
7030 xmlFree(URL);
7031 } else {
7032 #ifdef WITH_XSLT_DEBUG_PARSING
7033 xsltGenericDebug(xsltGenericDebugContext,
7034 "xsltLoadStylesheetPI : fetching %s\n", href);
7035 #endif
7036 ret = xsltParseStylesheetFile(href);
7037 }
7038 if (base != NULL)
7039 xmlFree(base);
7040 }
7041 xmlFreeURI(URI);
7042 xmlFree(href);
7043 }
7044 return(ret);
7045 }