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