Synchronize with trunk revision 59636 (just before Alex's CreateProcess revamp).
[reactos.git] / dll / 3rdparty / libxslt / preproc.c
1 /*
2 * preproc.c: Preprocessing of style operations
3 *
4 * References:
5 * http://www.w3.org/TR/1999/REC-xslt-19991116
6 *
7 * Michael Kay "XSLT Programmer's Reference" pp 637-643
8 * Writing Multiple Output Files
9 *
10 * XSLT-1.1 Working Draft
11 * http://www.w3.org/TR/xslt11#multiple-output
12 *
13 * See Copyright for the status of this software.
14 *
15 * daniel@veillard.com
16 */
17
18 #define IN_LIBXSLT
19 #include "libxslt.h"
20
21 #include <string.h>
22
23 #include <libxml/xmlmemory.h>
24 #include <libxml/parser.h>
25 #include <libxml/tree.h>
26 #include <libxml/valid.h>
27 #include <libxml/hash.h>
28 #include <libxml/uri.h>
29 #include <libxml/encoding.h>
30 #include <libxml/xmlerror.h>
31 #include "xslt.h"
32 #include "xsltutils.h"
33 #include "xsltInternals.h"
34 #include "transform.h"
35 #include "templates.h"
36 #include "variables.h"
37 #include "numbersInternals.h"
38 #include "preproc.h"
39 #include "extra.h"
40 #include "imports.h"
41 #include "extensions.h"
42 #include "pattern.h"
43
44 #ifdef WITH_XSLT_DEBUG
45 #define WITH_XSLT_DEBUG_PREPROC
46 #endif
47
48 const xmlChar *xsltExtMarker = (const xmlChar *) "Extension Element";
49
50 /************************************************************************
51 * *
52 * Grammar checks *
53 * *
54 ************************************************************************/
55
56 #ifdef XSLT_REFACTORED
57 /*
58 * Grammar checks are now performed in xslt.c.
59 */
60 #else
61 /**
62 * xsltCheckTopLevelElement:
63 * @style: the XSLT stylesheet
64 * @inst: the XSLT instruction
65 * @err: raise an error or not
66 *
67 * Check that the instruction is instanciated as a top level element.
68 *
69 * Returns -1 in case of error, 0 if failed and 1 in case of success
70 */
71 static int
72 xsltCheckTopLevelElement(xsltStylesheetPtr style, xmlNodePtr inst, int err) {
73 xmlNodePtr parent;
74 if ((style == NULL) || (inst == NULL) || (inst->ns == NULL))
75 return(-1);
76
77 parent = inst->parent;
78 if (parent == NULL) {
79 if (err) {
80 xsltTransformError(NULL, style, inst,
81 "internal problem: element has no parent\n");
82 style->errors++;
83 }
84 return(0);
85 }
86 if ((parent->ns == NULL) || (parent->type != XML_ELEMENT_NODE) ||
87 ((parent->ns != inst->ns) &&
88 (!xmlStrEqual(parent->ns->href, inst->ns->href))) ||
89 ((!xmlStrEqual(parent->name, BAD_CAST "stylesheet")) &&
90 (!xmlStrEqual(parent->name, BAD_CAST "transform")))) {
91 if (err) {
92 xsltTransformError(NULL, style, inst,
93 "element %s only allowed as child of stylesheet\n",
94 inst->name);
95 style->errors++;
96 }
97 return(0);
98 }
99 return(1);
100 }
101
102 /**
103 * xsltCheckInstructionElement:
104 * @style: the XSLT stylesheet
105 * @inst: the XSLT instruction
106 *
107 * Check that the instruction is instanciated as an instruction element.
108 */
109 static void
110 xsltCheckInstructionElement(xsltStylesheetPtr style, xmlNodePtr inst) {
111 xmlNodePtr parent;
112 int has_ext;
113
114 if ((style == NULL) || (inst == NULL) || (inst->ns == NULL) ||
115 (style->literal_result))
116 return;
117
118 has_ext = (style->extInfos != NULL);
119
120 parent = inst->parent;
121 if (parent == NULL) {
122 xsltTransformError(NULL, style, inst,
123 "internal problem: element has no parent\n");
124 style->errors++;
125 return;
126 }
127 while ((parent != NULL) && (parent->type != XML_DOCUMENT_NODE)) {
128 if (((parent->ns == inst->ns) ||
129 ((parent->ns != NULL) &&
130 (xmlStrEqual(parent->ns->href, inst->ns->href)))) &&
131 ((xmlStrEqual(parent->name, BAD_CAST "template")) ||
132 (xmlStrEqual(parent->name, BAD_CAST "param")) ||
133 (xmlStrEqual(parent->name, BAD_CAST "attribute")) ||
134 (xmlStrEqual(parent->name, BAD_CAST "variable")))) {
135 return;
136 }
137
138 /*
139 * if we are within an extension element all bets are off
140 * about the semantic there e.g. xsl:param within func:function
141 */
142 if ((has_ext) && (parent->ns != NULL) &&
143 (xmlHashLookup(style->extInfos, parent->ns->href) != NULL))
144 return;
145
146 parent = parent->parent;
147 }
148 xsltTransformError(NULL, style, inst,
149 "element %s only allowed within a template, variable or param\n",
150 inst->name);
151 style->errors++;
152 }
153
154 /**
155 * xsltCheckParentElement:
156 * @style: the XSLT stylesheet
157 * @inst: the XSLT instruction
158 * @allow1: allowed parent1
159 * @allow2: allowed parent2
160 *
161 * Check that the instruction is instanciated as the childre of one of the
162 * possible parents.
163 */
164 static void
165 xsltCheckParentElement(xsltStylesheetPtr style, xmlNodePtr inst,
166 const xmlChar *allow1, const xmlChar *allow2) {
167 xmlNodePtr parent;
168
169 if ((style == NULL) || (inst == NULL) || (inst->ns == NULL) ||
170 (style->literal_result))
171 return;
172
173 parent = inst->parent;
174 if (parent == NULL) {
175 xsltTransformError(NULL, style, inst,
176 "internal problem: element has no parent\n");
177 style->errors++;
178 return;
179 }
180 if (((parent->ns == inst->ns) ||
181 ((parent->ns != NULL) &&
182 (xmlStrEqual(parent->ns->href, inst->ns->href)))) &&
183 ((xmlStrEqual(parent->name, allow1)) ||
184 (xmlStrEqual(parent->name, allow2)))) {
185 return;
186 }
187
188 if (style->extInfos != NULL) {
189 while ((parent != NULL) && (parent->type != XML_DOCUMENT_NODE)) {
190 /*
191 * if we are within an extension element all bets are off
192 * about the semantic there e.g. xsl:param within func:function
193 */
194 if ((parent->ns != NULL) &&
195 (xmlHashLookup(style->extInfos, parent->ns->href) != NULL))
196 return;
197
198 parent = parent->parent;
199 }
200 }
201 xsltTransformError(NULL, style, inst,
202 "element %s is not allowed within that context\n",
203 inst->name);
204 style->errors++;
205 }
206 #endif
207
208 /************************************************************************
209 * *
210 * handling of precomputed data *
211 * *
212 ************************************************************************/
213
214 /**
215 * xsltNewStylePreComp:
216 * @style: the XSLT stylesheet
217 * @type: the construct type
218 *
219 * Create a new XSLT Style precomputed block
220 *
221 * Returns the newly allocated specialized structure
222 * or NULL in case of error
223 */
224 static xsltStylePreCompPtr
225 xsltNewStylePreComp(xsltStylesheetPtr style, xsltStyleType type) {
226 xsltStylePreCompPtr cur;
227 #ifdef XSLT_REFACTORED
228 size_t size;
229 #endif
230
231 if (style == NULL)
232 return(NULL);
233
234 #ifdef XSLT_REFACTORED
235 /*
236 * URGENT TODO: Use specialized factory functions in order
237 * to avoid this ugliness.
238 */
239 switch (type) {
240 case XSLT_FUNC_COPY:
241 size = sizeof(xsltStyleItemCopy); break;
242 case XSLT_FUNC_SORT:
243 size = sizeof(xsltStyleItemSort); break;
244 case XSLT_FUNC_TEXT:
245 size = sizeof(xsltStyleItemText); break;
246 case XSLT_FUNC_ELEMENT:
247 size = sizeof(xsltStyleItemElement); break;
248 case XSLT_FUNC_ATTRIBUTE:
249 size = sizeof(xsltStyleItemAttribute); break;
250 case XSLT_FUNC_COMMENT:
251 size = sizeof(xsltStyleItemComment); break;
252 case XSLT_FUNC_PI:
253 size = sizeof(xsltStyleItemPI); break;
254 case XSLT_FUNC_COPYOF:
255 size = sizeof(xsltStyleItemCopyOf); break;
256 case XSLT_FUNC_VALUEOF:
257 size = sizeof(xsltStyleItemValueOf); break;;
258 case XSLT_FUNC_NUMBER:
259 size = sizeof(xsltStyleItemNumber); break;
260 case XSLT_FUNC_APPLYIMPORTS:
261 size = sizeof(xsltStyleItemApplyImports); break;
262 case XSLT_FUNC_CALLTEMPLATE:
263 size = sizeof(xsltStyleItemCallTemplate); break;
264 case XSLT_FUNC_APPLYTEMPLATES:
265 size = sizeof(xsltStyleItemApplyTemplates); break;
266 case XSLT_FUNC_CHOOSE:
267 size = sizeof(xsltStyleItemChoose); break;
268 case XSLT_FUNC_IF:
269 size = sizeof(xsltStyleItemIf); break;
270 case XSLT_FUNC_FOREACH:
271 size = sizeof(xsltStyleItemForEach); break;
272 case XSLT_FUNC_DOCUMENT:
273 size = sizeof(xsltStyleItemDocument); break;
274 case XSLT_FUNC_WITHPARAM:
275 size = sizeof(xsltStyleItemWithParam); break;
276 case XSLT_FUNC_PARAM:
277 size = sizeof(xsltStyleItemParam); break;
278 case XSLT_FUNC_VARIABLE:
279 size = sizeof(xsltStyleItemVariable); break;
280 case XSLT_FUNC_WHEN:
281 size = sizeof(xsltStyleItemWhen); break;
282 case XSLT_FUNC_OTHERWISE:
283 size = sizeof(xsltStyleItemOtherwise); break;
284 default:
285 xsltTransformError(NULL, style, NULL,
286 "xsltNewStylePreComp : invalid type %d\n", type);
287 style->errors++;
288 return(NULL);
289 }
290 /*
291 * Create the structure.
292 */
293 cur = (xsltStylePreCompPtr) xmlMalloc(size);
294 if (cur == NULL) {
295 xsltTransformError(NULL, style, NULL,
296 "xsltNewStylePreComp : malloc failed\n");
297 style->errors++;
298 return(NULL);
299 }
300 memset(cur, 0, size);
301
302 #else /* XSLT_REFACTORED */
303 /*
304 * Old behaviour.
305 */
306 cur = (xsltStylePreCompPtr) xmlMalloc(sizeof(xsltStylePreComp));
307 if (cur == NULL) {
308 xsltTransformError(NULL, style, NULL,
309 "xsltNewStylePreComp : malloc failed\n");
310 style->errors++;
311 return(NULL);
312 }
313 memset(cur, 0, sizeof(xsltStylePreComp));
314 #endif /* XSLT_REFACTORED */
315
316 /*
317 * URGENT TODO: Better to move this to spezialized factory functions.
318 */
319 cur->type = type;
320 switch (cur->type) {
321 case XSLT_FUNC_COPY:
322 cur->func = (xsltTransformFunction) xsltCopy;break;
323 case XSLT_FUNC_SORT:
324 cur->func = (xsltTransformFunction) xsltSort;break;
325 case XSLT_FUNC_TEXT:
326 cur->func = (xsltTransformFunction) xsltText;break;
327 case XSLT_FUNC_ELEMENT:
328 cur->func = (xsltTransformFunction) xsltElement;break;
329 case XSLT_FUNC_ATTRIBUTE:
330 cur->func = (xsltTransformFunction) xsltAttribute;break;
331 case XSLT_FUNC_COMMENT:
332 cur->func = (xsltTransformFunction) xsltComment;break;
333 case XSLT_FUNC_PI:
334 cur->func = (xsltTransformFunction) xsltProcessingInstruction;
335 break;
336 case XSLT_FUNC_COPYOF:
337 cur->func = (xsltTransformFunction) xsltCopyOf;break;
338 case XSLT_FUNC_VALUEOF:
339 cur->func = (xsltTransformFunction) xsltValueOf;break;
340 case XSLT_FUNC_NUMBER:
341 cur->func = (xsltTransformFunction) xsltNumber;break;
342 case XSLT_FUNC_APPLYIMPORTS:
343 cur->func = (xsltTransformFunction) xsltApplyImports;break;
344 case XSLT_FUNC_CALLTEMPLATE:
345 cur->func = (xsltTransformFunction) xsltCallTemplate;break;
346 case XSLT_FUNC_APPLYTEMPLATES:
347 cur->func = (xsltTransformFunction) xsltApplyTemplates;break;
348 case XSLT_FUNC_CHOOSE:
349 cur->func = (xsltTransformFunction) xsltChoose;break;
350 case XSLT_FUNC_IF:
351 cur->func = (xsltTransformFunction) xsltIf;break;
352 case XSLT_FUNC_FOREACH:
353 cur->func = (xsltTransformFunction) xsltForEach;break;
354 case XSLT_FUNC_DOCUMENT:
355 cur->func = (xsltTransformFunction) xsltDocumentElem;break;
356 case XSLT_FUNC_WITHPARAM:
357 case XSLT_FUNC_PARAM:
358 case XSLT_FUNC_VARIABLE:
359 case XSLT_FUNC_WHEN:
360 break;
361 default:
362 if (cur->func == NULL) {
363 xsltTransformError(NULL, style, NULL,
364 "xsltNewStylePreComp : no function for type %d\n", type);
365 style->errors++;
366 }
367 }
368 cur->next = style->preComps;
369 style->preComps = (xsltElemPreCompPtr) cur;
370
371 return(cur);
372 }
373
374 /**
375 * xsltFreeStylePreComp:
376 * @comp: an XSLT Style precomputed block
377 *
378 * Free up the memory allocated by @comp
379 */
380 static void
381 xsltFreeStylePreComp(xsltStylePreCompPtr comp) {
382 if (comp == NULL)
383 return;
384 #ifdef XSLT_REFACTORED
385 /*
386 * URGENT TODO: Implement destructors.
387 */
388 switch (comp->type) {
389 case XSLT_FUNC_LITERAL_RESULT_ELEMENT:
390 break;
391 case XSLT_FUNC_COPY:
392 break;
393 case XSLT_FUNC_SORT: {
394 xsltStyleItemSortPtr item = (xsltStyleItemSortPtr) comp;
395 if (item->locale != (xsltLocale)0)
396 xsltFreeLocale(item->locale);
397 if (item->comp != NULL)
398 xmlXPathFreeCompExpr(item->comp);
399 }
400 break;
401 case XSLT_FUNC_TEXT:
402 break;
403 case XSLT_FUNC_ELEMENT:
404 break;
405 case XSLT_FUNC_ATTRIBUTE:
406 break;
407 case XSLT_FUNC_COMMENT:
408 break;
409 case XSLT_FUNC_PI:
410 break;
411 case XSLT_FUNC_COPYOF: {
412 xsltStyleItemCopyOfPtr item = (xsltStyleItemCopyOfPtr) comp;
413 if (item->comp != NULL)
414 xmlXPathFreeCompExpr(item->comp);
415 }
416 break;
417 case XSLT_FUNC_VALUEOF: {
418 xsltStyleItemValueOfPtr item = (xsltStyleItemValueOfPtr) comp;
419 if (item->comp != NULL)
420 xmlXPathFreeCompExpr(item->comp);
421 }
422 break;
423 case XSLT_FUNC_NUMBER: {
424 xsltStyleItemNumberPtr item = (xsltStyleItemNumberPtr) comp;
425 if (item->numdata.countPat != NULL)
426 xsltFreeCompMatchList(item->numdata.countPat);
427 if (item->numdata.fromPat != NULL)
428 xsltFreeCompMatchList(item->numdata.fromPat);
429 }
430 break;
431 case XSLT_FUNC_APPLYIMPORTS:
432 break;
433 case XSLT_FUNC_CALLTEMPLATE:
434 break;
435 case XSLT_FUNC_APPLYTEMPLATES: {
436 xsltStyleItemApplyTemplatesPtr item =
437 (xsltStyleItemApplyTemplatesPtr) comp;
438 if (item->comp != NULL)
439 xmlXPathFreeCompExpr(item->comp);
440 }
441 break;
442 case XSLT_FUNC_CHOOSE:
443 break;
444 case XSLT_FUNC_IF: {
445 xsltStyleItemIfPtr item = (xsltStyleItemIfPtr) comp;
446 if (item->comp != NULL)
447 xmlXPathFreeCompExpr(item->comp);
448 }
449 break;
450 case XSLT_FUNC_FOREACH: {
451 xsltStyleItemForEachPtr item =
452 (xsltStyleItemForEachPtr) comp;
453 if (item->comp != NULL)
454 xmlXPathFreeCompExpr(item->comp);
455 }
456 break;
457 case XSLT_FUNC_DOCUMENT:
458 break;
459 case XSLT_FUNC_WITHPARAM: {
460 xsltStyleItemWithParamPtr item =
461 (xsltStyleItemWithParamPtr) comp;
462 if (item->comp != NULL)
463 xmlXPathFreeCompExpr(item->comp);
464 }
465 break;
466 case XSLT_FUNC_PARAM: {
467 xsltStyleItemParamPtr item =
468 (xsltStyleItemParamPtr) comp;
469 if (item->comp != NULL)
470 xmlXPathFreeCompExpr(item->comp);
471 }
472 break;
473 case XSLT_FUNC_VARIABLE: {
474 xsltStyleItemVariablePtr item =
475 (xsltStyleItemVariablePtr) comp;
476 if (item->comp != NULL)
477 xmlXPathFreeCompExpr(item->comp);
478 }
479 break;
480 case XSLT_FUNC_WHEN: {
481 xsltStyleItemWhenPtr item =
482 (xsltStyleItemWhenPtr) comp;
483 if (item->comp != NULL)
484 xmlXPathFreeCompExpr(item->comp);
485 }
486 break;
487 case XSLT_FUNC_OTHERWISE:
488 case XSLT_FUNC_FALLBACK:
489 case XSLT_FUNC_MESSAGE:
490 case XSLT_FUNC_INCLUDE:
491 case XSLT_FUNC_ATTRSET:
492
493 break;
494 default:
495 /* TODO: Raise error. */
496 break;
497 }
498 #else
499 if (comp->locale != (xsltLocale)0)
500 xsltFreeLocale(comp->locale);
501 if (comp->comp != NULL)
502 xmlXPathFreeCompExpr(comp->comp);
503 if (comp->numdata.countPat != NULL)
504 xsltFreeCompMatchList(comp->numdata.countPat);
505 if (comp->numdata.fromPat != NULL)
506 xsltFreeCompMatchList(comp->numdata.fromPat);
507 if (comp->nsList != NULL)
508 xmlFree(comp->nsList);
509 #endif
510
511 xmlFree(comp);
512 }
513
514
515 /************************************************************************
516 * *
517 * XSLT-1.1 extensions *
518 * *
519 ************************************************************************/
520
521 /**
522 * xsltDocumentComp:
523 * @style: the XSLT stylesheet
524 * @inst: the instruction in the stylesheet
525 * @function: unused
526 *
527 * Pre process an XSLT-1.1 document element
528 *
529 * Returns a precompiled data structure for the element
530 */
531 xsltElemPreCompPtr
532 xsltDocumentComp(xsltStylesheetPtr style, xmlNodePtr inst,
533 xsltTransformFunction function ATTRIBUTE_UNUSED) {
534 #ifdef XSLT_REFACTORED
535 xsltStyleItemDocumentPtr comp;
536 #else
537 xsltStylePreCompPtr comp;
538 #endif
539 const xmlChar *filename = NULL;
540
541 /*
542 * As of 2006-03-30, this function is currently defined in Libxslt
543 * to be used for:
544 * (in libxslt/extra.c)
545 * "output" in XSLT_SAXON_NAMESPACE
546 * "write" XSLT_XALAN_NAMESPACE
547 * "document" XSLT_XT_NAMESPACE
548 * "document" XSLT_NAMESPACE (from the abandoned old working
549 * draft of XSLT 1.1)
550 * (in libexslt/common.c)
551 * "document" in EXSLT_COMMON_NAMESPACE
552 */
553 #ifdef XSLT_REFACTORED
554 comp = (xsltStyleItemDocumentPtr)
555 xsltNewStylePreComp(style, XSLT_FUNC_DOCUMENT);
556 #else
557 comp = xsltNewStylePreComp(style, XSLT_FUNC_DOCUMENT);
558 #endif
559
560 if (comp == NULL)
561 return (NULL);
562 comp->inst = inst;
563 comp->ver11 = 0;
564
565 if (xmlStrEqual(inst->name, (const xmlChar *) "output")) {
566 #ifdef WITH_XSLT_DEBUG_EXTRA
567 xsltGenericDebug(xsltGenericDebugContext,
568 "Found saxon:output extension\n");
569 #endif
570 /*
571 * The element "output" is in the namespace XSLT_SAXON_NAMESPACE
572 * (http://icl.com/saxon)
573 * The @file is in no namespace; it is an AVT.
574 * (http://www.computerwizards.com/saxon/doc/extensions.html#saxon:output)
575 *
576 * TODO: Do we need not to check the namespace here?
577 */
578 filename = xsltEvalStaticAttrValueTemplate(style, inst,
579 (const xmlChar *)"file",
580 NULL, &comp->has_filename);
581 } else if (xmlStrEqual(inst->name, (const xmlChar *) "write")) {
582 #ifdef WITH_XSLT_DEBUG_EXTRA
583 xsltGenericDebug(xsltGenericDebugContext,
584 "Found xalan:write extension\n");
585 #endif
586 /* the filename need to be interpreted */
587 /*
588 * TODO: Is "filename need to be interpreted" meant to be a todo?
589 * Where will be the filename of xalan:write be processed?
590 *
591 * TODO: Do we need not to check the namespace here?
592 * The extension ns is "http://xml.apache.org/xalan/redirect".
593 * See http://xml.apache.org/xalan-j/extensionslib.html.
594 */
595 } else if (xmlStrEqual(inst->name, (const xmlChar *) "document")) {
596 if (inst->ns != NULL) {
597 if (xmlStrEqual(inst->ns->href, XSLT_NAMESPACE)) {
598 /*
599 * Mark the instruction as being of
600 * XSLT version 1.1 (abandoned).
601 */
602 comp->ver11 = 1;
603 #ifdef WITH_XSLT_DEBUG_EXTRA
604 xsltGenericDebug(xsltGenericDebugContext,
605 "Found xslt11:document construct\n");
606 #endif
607 } else {
608 if (xmlStrEqual(inst->ns->href,
609 (const xmlChar *)"http://exslt.org/common")) {
610 /* EXSLT. */
611 #ifdef WITH_XSLT_DEBUG_EXTRA
612 xsltGenericDebug(xsltGenericDebugContext,
613 "Found exslt:document extension\n");
614 #endif
615 } else if (xmlStrEqual(inst->ns->href, XSLT_XT_NAMESPACE)) {
616 /* James Clark's XT. */
617 #ifdef WITH_XSLT_DEBUG_EXTRA
618 xsltGenericDebug(xsltGenericDebugContext,
619 "Found xt:document extension\n");
620 #endif
621 }
622 }
623 }
624 /*
625 * The element "document" is used in conjunction with the
626 * following namespaces:
627 *
628 * 1) XSLT_NAMESPACE (http://www.w3.org/1999/XSL/Transform version 1.1)
629 * <!ELEMENT xsl:document %template;>
630 * <!ATTLIST xsl:document
631 * href %avt; #REQUIRED
632 * @href is an AVT
633 * IMPORTANT: xsl:document was in the abandoned XSLT 1.1 draft,
634 * it was removed and isn't available in XSLT 1.1 anymore.
635 * In XSLT 2.0 it was renamed to xsl:result-document.
636 *
637 * All other attributes are identical to the attributes
638 * on xsl:output
639 *
640 * 2) EXSLT_COMMON_NAMESPACE (http://exslt.org/common)
641 * <exsl:document
642 * href = { uri-reference }
643 * TODO: is @href is an AVT?
644 *
645 * 3) XSLT_XT_NAMESPACE (http://www.jclark.com/xt)
646 * Example: <xt:document method="xml" href="myFile.xml">
647 * TODO: is @href is an AVT?
648 *
649 * In all cases @href is in no namespace.
650 */
651 filename = xsltEvalStaticAttrValueTemplate(style, inst,
652 (const xmlChar *)"href", NULL, &comp->has_filename);
653 }
654 if (!comp->has_filename) {
655 goto error;
656 }
657 comp->filename = filename;
658
659 error:
660 return ((xsltElemPreCompPtr) comp);
661 }
662
663 /************************************************************************
664 * *
665 * Most of the XSLT-1.0 transformations *
666 * *
667 ************************************************************************/
668
669 /**
670 * xsltSortComp:
671 * @style: the XSLT stylesheet
672 * @inst: the xslt sort node
673 *
674 * Process the xslt sort node on the source node
675 */
676 static void
677 xsltSortComp(xsltStylesheetPtr style, xmlNodePtr inst) {
678 #ifdef XSLT_REFACTORED
679 xsltStyleItemSortPtr comp;
680 #else
681 xsltStylePreCompPtr comp;
682 #endif
683 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
684 return;
685
686 #ifdef XSLT_REFACTORED
687 comp = (xsltStyleItemSortPtr) xsltNewStylePreComp(style, XSLT_FUNC_SORT);
688 #else
689 comp = xsltNewStylePreComp(style, XSLT_FUNC_SORT);
690 #endif
691
692 if (comp == NULL)
693 return;
694 inst->psvi = comp;
695 comp->inst = inst;
696
697 comp->stype = xsltEvalStaticAttrValueTemplate(style, inst,
698 (const xmlChar *)"data-type",
699 NULL, &comp->has_stype);
700 if (comp->stype != NULL) {
701 if (xmlStrEqual(comp->stype, (const xmlChar *) "text"))
702 comp->number = 0;
703 else if (xmlStrEqual(comp->stype, (const xmlChar *) "number"))
704 comp->number = 1;
705 else {
706 xsltTransformError(NULL, style, inst,
707 "xsltSortComp: no support for data-type = %s\n", comp->stype);
708 comp->number = 0; /* use default */
709 if (style != NULL) style->warnings++;
710 }
711 }
712 comp->order = xsltEvalStaticAttrValueTemplate(style, inst,
713 (const xmlChar *)"order",
714 NULL, &comp->has_order);
715 if (comp->order != NULL) {
716 if (xmlStrEqual(comp->order, (const xmlChar *) "ascending"))
717 comp->descending = 0;
718 else if (xmlStrEqual(comp->order, (const xmlChar *) "descending"))
719 comp->descending = 1;
720 else {
721 xsltTransformError(NULL, style, inst,
722 "xsltSortComp: invalid value %s for order\n", comp->order);
723 comp->descending = 0; /* use default */
724 if (style != NULL) style->warnings++;
725 }
726 }
727 comp->case_order = xsltEvalStaticAttrValueTemplate(style, inst,
728 (const xmlChar *)"case-order",
729 NULL, &comp->has_use);
730 if (comp->case_order != NULL) {
731 if (xmlStrEqual(comp->case_order, (const xmlChar *) "upper-first"))
732 comp->lower_first = 0;
733 else if (xmlStrEqual(comp->case_order, (const xmlChar *) "lower-first"))
734 comp->lower_first = 1;
735 else {
736 xsltTransformError(NULL, style, inst,
737 "xsltSortComp: invalid value %s for order\n", comp->order);
738 comp->lower_first = 0; /* use default */
739 if (style != NULL) style->warnings++;
740 }
741 }
742
743 comp->lang = xsltEvalStaticAttrValueTemplate(style, inst,
744 (const xmlChar *)"lang",
745 NULL, &comp->has_lang);
746 if (comp->lang != NULL) {
747 comp->locale = xsltNewLocale(comp->lang);
748 }
749 else {
750 comp->locale = (xsltLocale)0;
751 }
752
753 comp->select = xsltGetCNsProp(style, inst,(const xmlChar *)"select", XSLT_NAMESPACE);
754 if (comp->select == NULL) {
755 /*
756 * The default value of the select attribute is ., which will
757 * cause the string-value of the current node to be used as
758 * the sort key.
759 */
760 comp->select = xmlDictLookup(style->dict, BAD_CAST ".", 1);
761 }
762 comp->comp = xsltXPathCompile(style, comp->select);
763 if (comp->comp == NULL) {
764 xsltTransformError(NULL, style, inst,
765 "xsltSortComp: could not compile select expression '%s'\n",
766 comp->select);
767 if (style != NULL) style->errors++;
768 }
769 if (inst->children != NULL) {
770 xsltTransformError(NULL, style, inst,
771 "xsl:sort : is not empty\n");
772 if (style != NULL) style->errors++;
773 }
774 }
775
776 /**
777 * xsltCopyComp:
778 * @style: the XSLT stylesheet
779 * @inst: the xslt copy node
780 *
781 * Process the xslt copy node on the source node
782 */
783 static void
784 xsltCopyComp(xsltStylesheetPtr style, xmlNodePtr inst) {
785 #ifdef XSLT_REFACTORED
786 xsltStyleItemCopyPtr comp;
787 #else
788 xsltStylePreCompPtr comp;
789 #endif
790
791 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
792 return;
793 #ifdef XSLT_REFACTORED
794 comp = (xsltStyleItemCopyPtr) xsltNewStylePreComp(style, XSLT_FUNC_COPY);
795 #else
796 comp = xsltNewStylePreComp(style, XSLT_FUNC_COPY);
797 #endif
798
799 if (comp == NULL)
800 return;
801 inst->psvi = comp;
802 comp->inst = inst;
803
804
805 comp->use = xsltGetCNsProp(style, inst, (const xmlChar *)"use-attribute-sets",
806 XSLT_NAMESPACE);
807 if (comp->use == NULL)
808 comp->has_use = 0;
809 else
810 comp->has_use = 1;
811 }
812
813 #ifdef XSLT_REFACTORED
814 /* Enable if ever needed for xsl:text. */
815 #else
816 /**
817 * xsltTextComp:
818 * @style: an XSLT compiled stylesheet
819 * @inst: the xslt text node
820 *
821 * TODO: This function is obsolete, since xsl:text won't
822 * be compiled, but removed from the tree.
823 *
824 * Process the xslt text node on the source node
825 */
826 static void
827 xsltTextComp(xsltStylesheetPtr style, xmlNodePtr inst) {
828 #ifdef XSLT_REFACTORED
829 xsltStyleItemTextPtr comp;
830 #else
831 xsltStylePreCompPtr comp;
832 #endif
833 const xmlChar *prop;
834
835 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
836 return;
837
838 #ifdef XSLT_REFACTORED
839 comp = (xsltStyleItemTextPtr) xsltNewStylePreComp(style, XSLT_FUNC_TEXT);
840 #else
841 comp = xsltNewStylePreComp(style, XSLT_FUNC_TEXT);
842 #endif
843 if (comp == NULL)
844 return;
845 inst->psvi = comp;
846 comp->inst = inst;
847 comp->noescape = 0;
848
849 prop = xsltGetCNsProp(style, inst,
850 (const xmlChar *)"disable-output-escaping",
851 XSLT_NAMESPACE);
852 if (prop != NULL) {
853 if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
854 comp->noescape = 1;
855 } else if (!xmlStrEqual(prop,
856 (const xmlChar *)"no")){
857 xsltTransformError(NULL, style, inst,
858 "xsl:text: disable-output-escaping allows only yes or no\n");
859 if (style != NULL) style->warnings++;
860 }
861 }
862 }
863 #endif /* else of XSLT_REFACTORED */
864
865 /**
866 * xsltElementComp:
867 * @style: an XSLT compiled stylesheet
868 * @inst: the xslt element node
869 *
870 * Process the xslt element node on the source node
871 */
872 static void
873 xsltElementComp(xsltStylesheetPtr style, xmlNodePtr inst) {
874 #ifdef XSLT_REFACTORED
875 xsltStyleItemElementPtr comp;
876 #else
877 xsltStylePreCompPtr comp;
878 #endif
879
880 /*
881 * <xsl:element
882 * name = { qname }
883 * namespace = { uri-reference }
884 * use-attribute-sets = qnames>
885 * <!-- Content: template -->
886 * </xsl:element>
887 */
888 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
889 return;
890
891 #ifdef XSLT_REFACTORED
892 comp = (xsltStyleItemElementPtr) xsltNewStylePreComp(style, XSLT_FUNC_ELEMENT);
893 #else
894 comp = xsltNewStylePreComp(style, XSLT_FUNC_ELEMENT);
895 #endif
896
897 if (comp == NULL)
898 return;
899 inst->psvi = comp;
900 comp->inst = inst;
901
902 /*
903 * Attribute "name".
904 */
905 /*
906 * TODO: Precompile the AVT. See bug #344894.
907 */
908 comp->name = xsltEvalStaticAttrValueTemplate(style, inst,
909 (const xmlChar *)"name", NULL, &comp->has_name);
910 if (! comp->has_name) {
911 xsltTransformError(NULL, style, inst,
912 "xsl:element: The attribute 'name' is missing.\n");
913 style->errors++;
914 goto error;
915 }
916 /*
917 * Attribute "namespace".
918 */
919 /*
920 * TODO: Precompile the AVT. See bug #344894.
921 */
922 comp->ns = xsltEvalStaticAttrValueTemplate(style, inst,
923 (const xmlChar *)"namespace", NULL, &comp->has_ns);
924
925 if (comp->name != NULL) {
926 if (xmlValidateQName(comp->name, 0)) {
927 xsltTransformError(NULL, style, inst,
928 "xsl:element: The value '%s' of the attribute 'name' is "
929 "not a valid QName.\n", comp->name);
930 style->errors++;
931 } else {
932 const xmlChar *prefix = NULL, *name;
933
934 name = xsltSplitQName(style->dict, comp->name, &prefix);
935 if (comp->has_ns == 0) {
936 xmlNsPtr ns;
937
938 /*
939 * SPEC XSLT 1.0:
940 * "If the namespace attribute is not present, then the QName is
941 * expanded into an expanded-name using the namespace declarations
942 * in effect for the xsl:element element, including any default
943 * namespace declaration.
944 */
945 ns = xmlSearchNs(inst->doc, inst, prefix);
946 if (ns != NULL) {
947 comp->ns = xmlDictLookup(style->dict, ns->href, -1);
948 comp->has_ns = 1;
949 #ifdef XSLT_REFACTORED
950 comp->nsPrefix = prefix;
951 comp->name = name;
952 #endif
953 } else if (prefix != NULL) {
954 xsltTransformError(NULL, style, inst,
955 "xsl:element: The prefixed QName '%s' "
956 "has no namespace binding in scope in the "
957 "stylesheet; this is an error, since the namespace was "
958 "not specified by the instruction itself.\n", comp->name);
959 style->errors++;
960 }
961 }
962 if ((prefix != NULL) &&
963 (!xmlStrncasecmp(prefix, (xmlChar *)"xml", 3)))
964 {
965 /*
966 * Mark is to be skipped.
967 */
968 comp->has_name = 0;
969 }
970 }
971 }
972 /*
973 * Attribute "use-attribute-sets",
974 */
975 comp->use = xsltEvalStaticAttrValueTemplate(style, inst,
976 (const xmlChar *)"use-attribute-sets",
977 NULL, &comp->has_use);
978
979 error:
980 return;
981 }
982
983 /**
984 * xsltAttributeComp:
985 * @style: an XSLT compiled stylesheet
986 * @inst: the xslt attribute node
987 *
988 * Process the xslt attribute node on the source node
989 */
990 static void
991 xsltAttributeComp(xsltStylesheetPtr style, xmlNodePtr inst) {
992 #ifdef XSLT_REFACTORED
993 xsltStyleItemAttributePtr comp;
994 #else
995 xsltStylePreCompPtr comp;
996 #endif
997
998 /*
999 * <xsl:attribute
1000 * name = { qname }
1001 * namespace = { uri-reference }>
1002 * <!-- Content: template -->
1003 * </xsl:attribute>
1004 */
1005 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1006 return;
1007
1008 #ifdef XSLT_REFACTORED
1009 comp = (xsltStyleItemAttributePtr) xsltNewStylePreComp(style,
1010 XSLT_FUNC_ATTRIBUTE);
1011 #else
1012 comp = xsltNewStylePreComp(style, XSLT_FUNC_ATTRIBUTE);
1013 #endif
1014
1015 if (comp == NULL)
1016 return;
1017 inst->psvi = comp;
1018 comp->inst = inst;
1019
1020 /*
1021 * Attribute "name".
1022 */
1023 /*
1024 * TODO: Precompile the AVT. See bug #344894.
1025 */
1026 comp->name = xsltEvalStaticAttrValueTemplate(style, inst,
1027 (const xmlChar *)"name",
1028 NULL, &comp->has_name);
1029 if (! comp->has_name) {
1030 xsltTransformError(NULL, style, inst,
1031 "XSLT-attribute: The attribute 'name' is missing.\n");
1032 style->errors++;
1033 return;
1034 }
1035 /*
1036 * Attribute "namespace".
1037 */
1038 /*
1039 * TODO: Precompile the AVT. See bug #344894.
1040 */
1041 comp->ns = xsltEvalStaticAttrValueTemplate(style, inst,
1042 (const xmlChar *)"namespace",
1043 NULL, &comp->has_ns);
1044
1045 if (comp->name != NULL) {
1046 if (xmlValidateQName(comp->name, 0)) {
1047 xsltTransformError(NULL, style, inst,
1048 "xsl:attribute: The value '%s' of the attribute 'name' is "
1049 "not a valid QName.\n", comp->name);
1050 style->errors++;
1051 } else if (xmlStrEqual(comp->name, BAD_CAST "xmlns")) {
1052 xsltTransformError(NULL, style, inst,
1053 "xsl:attribute: The attribute name 'xmlns' is not allowed.\n");
1054 style->errors++;
1055 } else {
1056 const xmlChar *prefix = NULL, *name;
1057
1058 name = xsltSplitQName(style->dict, comp->name, &prefix);
1059 if (prefix != NULL) {
1060 if (comp->has_ns == 0) {
1061 xmlNsPtr ns;
1062
1063 /*
1064 * SPEC XSLT 1.0:
1065 * "If the namespace attribute is not present, then the
1066 * QName is expanded into an expanded-name using the
1067 * namespace declarations in effect for the xsl:element
1068 * element, including any default namespace declaration.
1069 */
1070 ns = xmlSearchNs(inst->doc, inst, prefix);
1071 if (ns != NULL) {
1072 comp->ns = xmlDictLookup(style->dict, ns->href, -1);
1073 comp->has_ns = 1;
1074 #ifdef XSLT_REFACTORED
1075 comp->nsPrefix = prefix;
1076 comp->name = name;
1077 #endif
1078 } else {
1079 xsltTransformError(NULL, style, inst,
1080 "xsl:attribute: The prefixed QName '%s' "
1081 "has no namespace binding in scope in the "
1082 "stylesheet; this is an error, since the "
1083 "namespace was not specified by the instruction "
1084 "itself.\n", comp->name);
1085 style->errors++;
1086 }
1087 }
1088 }
1089 }
1090 }
1091 }
1092
1093 /**
1094 * xsltCommentComp:
1095 * @style: an XSLT compiled stylesheet
1096 * @inst: the xslt comment node
1097 *
1098 * Process the xslt comment node on the source node
1099 */
1100 static void
1101 xsltCommentComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1102 #ifdef XSLT_REFACTORED
1103 xsltStyleItemCommentPtr comp;
1104 #else
1105 xsltStylePreCompPtr comp;
1106 #endif
1107
1108 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1109 return;
1110
1111 #ifdef XSLT_REFACTORED
1112 comp = (xsltStyleItemCommentPtr) xsltNewStylePreComp(style, XSLT_FUNC_COMMENT);
1113 #else
1114 comp = xsltNewStylePreComp(style, XSLT_FUNC_COMMENT);
1115 #endif
1116
1117 if (comp == NULL)
1118 return;
1119 inst->psvi = comp;
1120 comp->inst = inst;
1121 }
1122
1123 /**
1124 * xsltProcessingInstructionComp:
1125 * @style: an XSLT compiled stylesheet
1126 * @inst: the xslt processing-instruction node
1127 *
1128 * Process the xslt processing-instruction node on the source node
1129 */
1130 static void
1131 xsltProcessingInstructionComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1132 #ifdef XSLT_REFACTORED
1133 xsltStyleItemPIPtr comp;
1134 #else
1135 xsltStylePreCompPtr comp;
1136 #endif
1137
1138 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1139 return;
1140
1141 #ifdef XSLT_REFACTORED
1142 comp = (xsltStyleItemPIPtr) xsltNewStylePreComp(style, XSLT_FUNC_PI);
1143 #else
1144 comp = xsltNewStylePreComp(style, XSLT_FUNC_PI);
1145 #endif
1146
1147 if (comp == NULL)
1148 return;
1149 inst->psvi = comp;
1150 comp->inst = inst;
1151
1152 comp->name = xsltEvalStaticAttrValueTemplate(style, inst,
1153 (const xmlChar *)"name",
1154 XSLT_NAMESPACE, &comp->has_name);
1155 }
1156
1157 /**
1158 * xsltCopyOfComp:
1159 * @style: an XSLT compiled stylesheet
1160 * @inst: the xslt copy-of node
1161 *
1162 * Process the xslt copy-of node on the source node
1163 */
1164 static void
1165 xsltCopyOfComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1166 #ifdef XSLT_REFACTORED
1167 xsltStyleItemCopyOfPtr comp;
1168 #else
1169 xsltStylePreCompPtr comp;
1170 #endif
1171
1172 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1173 return;
1174
1175 #ifdef XSLT_REFACTORED
1176 comp = (xsltStyleItemCopyOfPtr) xsltNewStylePreComp(style, XSLT_FUNC_COPYOF);
1177 #else
1178 comp = xsltNewStylePreComp(style, XSLT_FUNC_COPYOF);
1179 #endif
1180
1181 if (comp == NULL)
1182 return;
1183 inst->psvi = comp;
1184 comp->inst = inst;
1185
1186 comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1187 XSLT_NAMESPACE);
1188 if (comp->select == NULL) {
1189 xsltTransformError(NULL, style, inst,
1190 "xsl:copy-of : select is missing\n");
1191 if (style != NULL) style->errors++;
1192 return;
1193 }
1194 comp->comp = xsltXPathCompile(style, comp->select);
1195 if (comp->comp == NULL) {
1196 xsltTransformError(NULL, style, inst,
1197 "xsl:copy-of : could not compile select expression '%s'\n",
1198 comp->select);
1199 if (style != NULL) style->errors++;
1200 }
1201 }
1202
1203 /**
1204 * xsltValueOfComp:
1205 * @style: an XSLT compiled stylesheet
1206 * @inst: the xslt value-of node
1207 *
1208 * Process the xslt value-of node on the source node
1209 */
1210 static void
1211 xsltValueOfComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1212 #ifdef XSLT_REFACTORED
1213 xsltStyleItemValueOfPtr comp;
1214 #else
1215 xsltStylePreCompPtr comp;
1216 #endif
1217 const xmlChar *prop;
1218
1219 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1220 return;
1221
1222 #ifdef XSLT_REFACTORED
1223 comp = (xsltStyleItemValueOfPtr) xsltNewStylePreComp(style, XSLT_FUNC_VALUEOF);
1224 #else
1225 comp = xsltNewStylePreComp(style, XSLT_FUNC_VALUEOF);
1226 #endif
1227
1228 if (comp == NULL)
1229 return;
1230 inst->psvi = comp;
1231 comp->inst = inst;
1232
1233 prop = xsltGetCNsProp(style, inst,
1234 (const xmlChar *)"disable-output-escaping",
1235 XSLT_NAMESPACE);
1236 if (prop != NULL) {
1237 if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
1238 comp->noescape = 1;
1239 } else if (!xmlStrEqual(prop,
1240 (const xmlChar *)"no")){
1241 xsltTransformError(NULL, style, inst,
1242 "xsl:value-of : disable-output-escaping allows only yes or no\n");
1243 if (style != NULL) style->warnings++;
1244 }
1245 }
1246 comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1247 XSLT_NAMESPACE);
1248 if (comp->select == NULL) {
1249 xsltTransformError(NULL, style, inst,
1250 "xsl:value-of : select is missing\n");
1251 if (style != NULL) style->errors++;
1252 return;
1253 }
1254 comp->comp = xsltXPathCompile(style, comp->select);
1255 if (comp->comp == NULL) {
1256 xsltTransformError(NULL, style, inst,
1257 "xsl:value-of : could not compile select expression '%s'\n",
1258 comp->select);
1259 if (style != NULL) style->errors++;
1260 }
1261 }
1262
1263 static void
1264 xsltGetQNameProperty(xsltStylesheetPtr style, xmlNodePtr inst,
1265 const xmlChar *propName,
1266 int mandatory,
1267 int *hasProp, const xmlChar **nsName,
1268 const xmlChar** localName)
1269 {
1270 const xmlChar *prop;
1271
1272 if (nsName)
1273 *nsName = NULL;
1274 if (localName)
1275 *localName = NULL;
1276 if (hasProp)
1277 *hasProp = 0;
1278
1279 prop = xsltGetCNsProp(style, inst, propName, XSLT_NAMESPACE);
1280 if (prop == NULL) {
1281 if (mandatory) {
1282 xsltTransformError(NULL, style, inst,
1283 "The attribute '%s' is missing.\n", propName);
1284 style->errors++;
1285 return;
1286 }
1287 } else {
1288 const xmlChar *URI;
1289
1290 if (xmlValidateQName(prop, 0)) {
1291 xsltTransformError(NULL, style, inst,
1292 "The value '%s' of the attribute "
1293 "'%s' is not a valid QName.\n", prop, propName);
1294 style->errors++;
1295 return;
1296 } else {
1297 /*
1298 * @prop will be in the string dict afterwards, @URI not.
1299 */
1300 URI = xsltGetQNameURI2(style, inst, &prop);
1301 if (prop == NULL) {
1302 style->errors++;
1303 } else {
1304 *localName = prop;
1305 if (hasProp)
1306 *hasProp = 1;
1307 if (URI != NULL) {
1308 /*
1309 * Fixes bug #308441: Put the ns-name in the dict
1310 * in order to pointer compare names during XPath's
1311 * variable lookup.
1312 */
1313 if (nsName)
1314 *nsName = xmlDictLookup(style->dict, URI, -1);
1315 /* comp->has_ns = 1; */
1316 }
1317 }
1318 }
1319 }
1320 return;
1321 }
1322
1323 /**
1324 * xsltWithParamComp:
1325 * @style: an XSLT compiled stylesheet
1326 * @inst: the xslt with-param node
1327 *
1328 * Process the xslt with-param node on the source node
1329 * Allowed parents: xsl:call-template, xsl:apply-templates.
1330 * <xsl:with-param
1331 * name = qname
1332 * select = expression>
1333 * <!-- Content: template -->
1334 * </xsl:with-param>
1335 */
1336 static void
1337 xsltWithParamComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1338 #ifdef XSLT_REFACTORED
1339 xsltStyleItemWithParamPtr comp;
1340 #else
1341 xsltStylePreCompPtr comp;
1342 #endif
1343
1344 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1345 return;
1346
1347 #ifdef XSLT_REFACTORED
1348 comp = (xsltStyleItemWithParamPtr) xsltNewStylePreComp(style, XSLT_FUNC_WITHPARAM);
1349 #else
1350 comp = xsltNewStylePreComp(style, XSLT_FUNC_WITHPARAM);
1351 #endif
1352
1353 if (comp == NULL)
1354 return;
1355 inst->psvi = comp;
1356 comp->inst = inst;
1357
1358 /*
1359 * Attribute "name".
1360 */
1361 xsltGetQNameProperty(style, inst, BAD_CAST "name",
1362 1, &(comp->has_name), &(comp->ns), &(comp->name));
1363 if (comp->ns)
1364 comp->has_ns = 1;
1365 /*
1366 * Attribute "select".
1367 */
1368 comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1369 XSLT_NAMESPACE);
1370 if (comp->select != NULL) {
1371 comp->comp = xsltXPathCompile(style, comp->select);
1372 if (comp->comp == NULL) {
1373 xsltTransformError(NULL, style, inst,
1374 "XSLT-with-param: Failed to compile select "
1375 "expression '%s'\n", comp->select);
1376 style->errors++;
1377 }
1378 if (inst->children != NULL) {
1379 xsltTransformError(NULL, style, inst,
1380 "XSLT-with-param: The content should be empty since "
1381 "the attribute select is present.\n");
1382 style->warnings++;
1383 }
1384 }
1385 }
1386
1387 /**
1388 * xsltNumberComp:
1389 * @style: an XSLT compiled stylesheet
1390 * @cur: the xslt number node
1391 *
1392 * Process the xslt number node on the source node
1393 */
1394 static void
1395 xsltNumberComp(xsltStylesheetPtr style, xmlNodePtr cur) {
1396 #ifdef XSLT_REFACTORED
1397 xsltStyleItemNumberPtr comp;
1398 #else
1399 xsltStylePreCompPtr comp;
1400 #endif
1401 const xmlChar *prop;
1402
1403 if ((style == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE))
1404 return;
1405
1406 #ifdef XSLT_REFACTORED
1407 comp = (xsltStyleItemNumberPtr) xsltNewStylePreComp(style, XSLT_FUNC_NUMBER);
1408 #else
1409 comp = xsltNewStylePreComp(style, XSLT_FUNC_NUMBER);
1410 #endif
1411
1412 if (comp == NULL)
1413 return;
1414 cur->psvi = comp;
1415
1416 if ((style == NULL) || (cur == NULL))
1417 return;
1418
1419 comp->numdata.doc = cur->doc;
1420 comp->numdata.node = cur;
1421 comp->numdata.value = xsltGetCNsProp(style, cur, (const xmlChar *)"value",
1422 XSLT_NAMESPACE);
1423
1424 prop = xsltEvalStaticAttrValueTemplate(style, cur,
1425 (const xmlChar *)"format",
1426 XSLT_NAMESPACE, &comp->numdata.has_format);
1427 if (comp->numdata.has_format == 0) {
1428 comp->numdata.format = xmlDictLookup(style->dict, BAD_CAST "" , 0);
1429 } else {
1430 comp->numdata.format = prop;
1431 }
1432
1433 comp->numdata.count = xsltGetCNsProp(style, cur, (const xmlChar *)"count",
1434 XSLT_NAMESPACE);
1435 comp->numdata.from = xsltGetCNsProp(style, cur, (const xmlChar *)"from",
1436 XSLT_NAMESPACE);
1437
1438 prop = xsltGetCNsProp(style, cur, (const xmlChar *)"count", XSLT_NAMESPACE);
1439 if (prop != NULL) {
1440 comp->numdata.countPat = xsltCompilePattern(prop, cur->doc, cur, style,
1441 NULL);
1442 }
1443
1444 prop = xsltGetCNsProp(style, cur, (const xmlChar *)"from", XSLT_NAMESPACE);
1445 if (prop != NULL) {
1446 comp->numdata.fromPat = xsltCompilePattern(prop, cur->doc, cur, style,
1447 NULL);
1448 }
1449
1450 prop = xsltGetCNsProp(style, cur, (const xmlChar *)"level", XSLT_NAMESPACE);
1451 if (prop != NULL) {
1452 if (xmlStrEqual(prop, BAD_CAST("single")) ||
1453 xmlStrEqual(prop, BAD_CAST("multiple")) ||
1454 xmlStrEqual(prop, BAD_CAST("any"))) {
1455 comp->numdata.level = prop;
1456 } else {
1457 xsltTransformError(NULL, style, cur,
1458 "xsl:number : invalid value %s for level\n", prop);
1459 if (style != NULL) style->warnings++;
1460 }
1461 }
1462
1463 prop = xsltGetCNsProp(style, cur, (const xmlChar *)"lang", XSLT_NAMESPACE);
1464 if (prop != NULL) {
1465 xsltTransformError(NULL, style, cur,
1466 "xsl:number : lang attribute not implemented\n");
1467 XSLT_TODO; /* xsl:number lang attribute */
1468 }
1469
1470 prop = xsltGetCNsProp(style, cur, (const xmlChar *)"letter-value", XSLT_NAMESPACE);
1471 if (prop != NULL) {
1472 if (xmlStrEqual(prop, BAD_CAST("alphabetic"))) {
1473 xsltTransformError(NULL, style, cur,
1474 "xsl:number : letter-value 'alphabetic' not implemented\n");
1475 if (style != NULL) style->warnings++;
1476 XSLT_TODO; /* xsl:number letter-value attribute alphabetic */
1477 } else if (xmlStrEqual(prop, BAD_CAST("traditional"))) {
1478 xsltTransformError(NULL, style, cur,
1479 "xsl:number : letter-value 'traditional' not implemented\n");
1480 if (style != NULL) style->warnings++;
1481 XSLT_TODO; /* xsl:number letter-value attribute traditional */
1482 } else {
1483 xsltTransformError(NULL, style, cur,
1484 "xsl:number : invalid value %s for letter-value\n", prop);
1485 if (style != NULL) style->warnings++;
1486 }
1487 }
1488
1489 prop = xsltGetCNsProp(style, cur, (const xmlChar *)"grouping-separator",
1490 XSLT_NAMESPACE);
1491 if (prop != NULL) {
1492 comp->numdata.groupingCharacterLen = xmlStrlen(prop);
1493 comp->numdata.groupingCharacter =
1494 xsltGetUTF8Char(prop, &(comp->numdata.groupingCharacterLen));
1495 }
1496
1497 prop = xsltGetCNsProp(style, cur, (const xmlChar *)"grouping-size", XSLT_NAMESPACE);
1498 if (prop != NULL) {
1499 sscanf((char *)prop, "%d", &comp->numdata.digitsPerGroup);
1500 } else {
1501 comp->numdata.groupingCharacter = 0;
1502 }
1503
1504 /* Set default values */
1505 if (comp->numdata.value == NULL) {
1506 if (comp->numdata.level == NULL) {
1507 comp->numdata.level = xmlDictLookup(style->dict,
1508 BAD_CAST"single", 6);
1509 }
1510 }
1511
1512 }
1513
1514 /**
1515 * xsltApplyImportsComp:
1516 * @style: an XSLT compiled stylesheet
1517 * @inst: the xslt apply-imports node
1518 *
1519 * Process the xslt apply-imports node on the source node
1520 */
1521 static void
1522 xsltApplyImportsComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1523 #ifdef XSLT_REFACTORED
1524 xsltStyleItemApplyImportsPtr comp;
1525 #else
1526 xsltStylePreCompPtr comp;
1527 #endif
1528
1529 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1530 return;
1531
1532 #ifdef XSLT_REFACTORED
1533 comp = (xsltStyleItemApplyImportsPtr) xsltNewStylePreComp(style, XSLT_FUNC_APPLYIMPORTS);
1534 #else
1535 comp = xsltNewStylePreComp(style, XSLT_FUNC_APPLYIMPORTS);
1536 #endif
1537
1538 if (comp == NULL)
1539 return;
1540 inst->psvi = comp;
1541 comp->inst = inst;
1542 }
1543
1544 /**
1545 * xsltCallTemplateComp:
1546 * @style: an XSLT compiled stylesheet
1547 * @inst: the xslt call-template node
1548 *
1549 * Process the xslt call-template node on the source node
1550 */
1551 static void
1552 xsltCallTemplateComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1553 #ifdef XSLT_REFACTORED
1554 xsltStyleItemCallTemplatePtr comp;
1555 #else
1556 xsltStylePreCompPtr comp;
1557 #endif
1558
1559 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1560 return;
1561
1562 #ifdef XSLT_REFACTORED
1563 comp = (xsltStyleItemCallTemplatePtr)
1564 xsltNewStylePreComp(style, XSLT_FUNC_CALLTEMPLATE);
1565 #else
1566 comp = xsltNewStylePreComp(style, XSLT_FUNC_CALLTEMPLATE);
1567 #endif
1568
1569 if (comp == NULL)
1570 return;
1571 inst->psvi = comp;
1572 comp->inst = inst;
1573
1574 /*
1575 * Attribute "name".
1576 */
1577 xsltGetQNameProperty(style, inst, BAD_CAST "name",
1578 1, &(comp->has_name), &(comp->ns), &(comp->name));
1579 if (comp->ns)
1580 comp->has_ns = 1;
1581 }
1582
1583 /**
1584 * xsltApplyTemplatesComp:
1585 * @style: an XSLT compiled stylesheet
1586 * @inst: the apply-templates node
1587 *
1588 * Process the apply-templates node on the source node
1589 */
1590 static void
1591 xsltApplyTemplatesComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1592 #ifdef XSLT_REFACTORED
1593 xsltStyleItemApplyTemplatesPtr comp;
1594 #else
1595 xsltStylePreCompPtr comp;
1596 #endif
1597
1598 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1599 return;
1600
1601 #ifdef XSLT_REFACTORED
1602 comp = (xsltStyleItemApplyTemplatesPtr)
1603 xsltNewStylePreComp(style, XSLT_FUNC_APPLYTEMPLATES);
1604 #else
1605 comp = xsltNewStylePreComp(style, XSLT_FUNC_APPLYTEMPLATES);
1606 #endif
1607
1608 if (comp == NULL)
1609 return;
1610 inst->psvi = comp;
1611 comp->inst = inst;
1612
1613 /*
1614 * Attribute "mode".
1615 */
1616 xsltGetQNameProperty(style, inst, BAD_CAST "mode",
1617 0, NULL, &(comp->modeURI), &(comp->mode));
1618 /*
1619 * Attribute "select".
1620 */
1621 comp->select = xsltGetCNsProp(style, inst, BAD_CAST "select",
1622 XSLT_NAMESPACE);
1623 if (comp->select != NULL) {
1624 comp->comp = xsltXPathCompile(style, comp->select);
1625 if (comp->comp == NULL) {
1626 xsltTransformError(NULL, style, inst,
1627 "XSLT-apply-templates: could not compile select "
1628 "expression '%s'\n", comp->select);
1629 style->errors++;
1630 }
1631 }
1632 /* TODO: handle (or skip) the xsl:sort and xsl:with-param */
1633 }
1634
1635 /**
1636 * xsltChooseComp:
1637 * @style: an XSLT compiled stylesheet
1638 * @inst: the xslt choose node
1639 *
1640 * Process the xslt choose node on the source node
1641 */
1642 static void
1643 xsltChooseComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1644 #ifdef XSLT_REFACTORED
1645 xsltStyleItemChoosePtr comp;
1646 #else
1647 xsltStylePreCompPtr comp;
1648 #endif
1649
1650 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1651 return;
1652
1653 #ifdef XSLT_REFACTORED
1654 comp = (xsltStyleItemChoosePtr)
1655 xsltNewStylePreComp(style, XSLT_FUNC_CHOOSE);
1656 #else
1657 comp = xsltNewStylePreComp(style, XSLT_FUNC_CHOOSE);
1658 #endif
1659
1660 if (comp == NULL)
1661 return;
1662 inst->psvi = comp;
1663 comp->inst = inst;
1664 }
1665
1666 /**
1667 * xsltIfComp:
1668 * @style: an XSLT compiled stylesheet
1669 * @inst: the xslt if node
1670 *
1671 * Process the xslt if node on the source node
1672 */
1673 static void
1674 xsltIfComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1675 #ifdef XSLT_REFACTORED
1676 xsltStyleItemIfPtr comp;
1677 #else
1678 xsltStylePreCompPtr comp;
1679 #endif
1680
1681 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1682 return;
1683
1684 #ifdef XSLT_REFACTORED
1685 comp = (xsltStyleItemIfPtr)
1686 xsltNewStylePreComp(style, XSLT_FUNC_IF);
1687 #else
1688 comp = xsltNewStylePreComp(style, XSLT_FUNC_IF);
1689 #endif
1690
1691 if (comp == NULL)
1692 return;
1693 inst->psvi = comp;
1694 comp->inst = inst;
1695
1696 comp->test = xsltGetCNsProp(style, inst, (const xmlChar *)"test", XSLT_NAMESPACE);
1697 if (comp->test == NULL) {
1698 xsltTransformError(NULL, style, inst,
1699 "xsl:if : test is not defined\n");
1700 if (style != NULL) style->errors++;
1701 return;
1702 }
1703 comp->comp = xsltXPathCompile(style, comp->test);
1704 if (comp->comp == NULL) {
1705 xsltTransformError(NULL, style, inst,
1706 "xsl:if : could not compile test expression '%s'\n",
1707 comp->test);
1708 if (style != NULL) style->errors++;
1709 }
1710 }
1711
1712 /**
1713 * xsltWhenComp:
1714 * @style: an XSLT compiled stylesheet
1715 * @inst: the xslt if node
1716 *
1717 * Process the xslt if node on the source node
1718 */
1719 static void
1720 xsltWhenComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1721 #ifdef XSLT_REFACTORED
1722 xsltStyleItemWhenPtr comp;
1723 #else
1724 xsltStylePreCompPtr comp;
1725 #endif
1726
1727 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1728 return;
1729
1730 #ifdef XSLT_REFACTORED
1731 comp = (xsltStyleItemWhenPtr)
1732 xsltNewStylePreComp(style, XSLT_FUNC_WHEN);
1733 #else
1734 comp = xsltNewStylePreComp(style, XSLT_FUNC_WHEN);
1735 #endif
1736
1737 if (comp == NULL)
1738 return;
1739 inst->psvi = comp;
1740 comp->inst = inst;
1741
1742 comp->test = xsltGetCNsProp(style, inst, (const xmlChar *)"test", XSLT_NAMESPACE);
1743 if (comp->test == NULL) {
1744 xsltTransformError(NULL, style, inst,
1745 "xsl:when : test is not defined\n");
1746 if (style != NULL) style->errors++;
1747 return;
1748 }
1749 comp->comp = xsltXPathCompile(style, comp->test);
1750 if (comp->comp == NULL) {
1751 xsltTransformError(NULL, style, inst,
1752 "xsl:when : could not compile test expression '%s'\n",
1753 comp->test);
1754 if (style != NULL) style->errors++;
1755 }
1756 }
1757
1758 /**
1759 * xsltForEachComp:
1760 * @style: an XSLT compiled stylesheet
1761 * @inst: the xslt for-each node
1762 *
1763 * Process the xslt for-each node on the source node
1764 */
1765 static void
1766 xsltForEachComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1767 #ifdef XSLT_REFACTORED
1768 xsltStyleItemForEachPtr comp;
1769 #else
1770 xsltStylePreCompPtr comp;
1771 #endif
1772
1773 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1774 return;
1775
1776 #ifdef XSLT_REFACTORED
1777 comp = (xsltStyleItemForEachPtr)
1778 xsltNewStylePreComp(style, XSLT_FUNC_FOREACH);
1779 #else
1780 comp = xsltNewStylePreComp(style, XSLT_FUNC_FOREACH);
1781 #endif
1782
1783 if (comp == NULL)
1784 return;
1785 inst->psvi = comp;
1786 comp->inst = inst;
1787
1788 comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1789 XSLT_NAMESPACE);
1790 if (comp->select == NULL) {
1791 xsltTransformError(NULL, style, inst,
1792 "xsl:for-each : select is missing\n");
1793 if (style != NULL) style->errors++;
1794 } else {
1795 comp->comp = xsltXPathCompile(style, comp->select);
1796 if (comp->comp == NULL) {
1797 xsltTransformError(NULL, style, inst,
1798 "xsl:for-each : could not compile select expression '%s'\n",
1799 comp->select);
1800 if (style != NULL) style->errors++;
1801 }
1802 }
1803 /* TODO: handle and skip the xsl:sort */
1804 }
1805
1806 /**
1807 * xsltVariableComp:
1808 * @style: an XSLT compiled stylesheet
1809 * @inst: the xslt variable node
1810 *
1811 * Process the xslt variable node on the source node
1812 */
1813 static void
1814 xsltVariableComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1815 #ifdef XSLT_REFACTORED
1816 xsltStyleItemVariablePtr comp;
1817 #else
1818 xsltStylePreCompPtr comp;
1819 #endif
1820
1821 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1822 return;
1823
1824 #ifdef XSLT_REFACTORED
1825 comp = (xsltStyleItemVariablePtr)
1826 xsltNewStylePreComp(style, XSLT_FUNC_VARIABLE);
1827 #else
1828 comp = xsltNewStylePreComp(style, XSLT_FUNC_VARIABLE);
1829 #endif
1830
1831 if (comp == NULL)
1832 return;
1833
1834 inst->psvi = comp;
1835 comp->inst = inst;
1836 /*
1837 * The full template resolution can be done statically
1838 */
1839
1840 /*
1841 * Attribute "name".
1842 */
1843 xsltGetQNameProperty(style, inst, BAD_CAST "name",
1844 1, &(comp->has_name), &(comp->ns), &(comp->name));
1845 if (comp->ns)
1846 comp->has_ns = 1;
1847 /*
1848 * Attribute "select".
1849 */
1850 comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1851 XSLT_NAMESPACE);
1852 if (comp->select != NULL) {
1853 #ifndef XSLT_REFACTORED
1854 xmlNodePtr cur;
1855 #endif
1856 comp->comp = xsltXPathCompile(style, comp->select);
1857 if (comp->comp == NULL) {
1858 xsltTransformError(NULL, style, inst,
1859 "XSLT-variable: Failed to compile the XPath expression '%s'.\n",
1860 comp->select);
1861 style->errors++;
1862 }
1863 #ifdef XSLT_REFACTORED
1864 if (inst->children != NULL) {
1865 xsltTransformError(NULL, style, inst,
1866 "XSLT-variable: There must be no child nodes, since the "
1867 "attribute 'select' was specified.\n");
1868 style->errors++;
1869 }
1870 #else
1871 for (cur = inst->children; cur != NULL; cur = cur->next) {
1872 if (cur->type != XML_COMMENT_NODE &&
1873 (cur->type != XML_TEXT_NODE || !xsltIsBlank(cur->content)))
1874 {
1875 xsltTransformError(NULL, style, inst,
1876 "XSLT-variable: There must be no child nodes, since the "
1877 "attribute 'select' was specified.\n");
1878 style->errors++;
1879 }
1880 }
1881 #endif
1882 }
1883 }
1884
1885 /**
1886 * xsltParamComp:
1887 * @style: an XSLT compiled stylesheet
1888 * @inst: the xslt param node
1889 *
1890 * Process the xslt param node on the source node
1891 */
1892 static void
1893 xsltParamComp(xsltStylesheetPtr style, xmlNodePtr inst) {
1894 #ifdef XSLT_REFACTORED
1895 xsltStyleItemParamPtr comp;
1896 #else
1897 xsltStylePreCompPtr comp;
1898 #endif
1899
1900 if ((style == NULL) || (inst == NULL) || (inst->type != XML_ELEMENT_NODE))
1901 return;
1902
1903 #ifdef XSLT_REFACTORED
1904 comp = (xsltStyleItemParamPtr)
1905 xsltNewStylePreComp(style, XSLT_FUNC_PARAM);
1906 #else
1907 comp = xsltNewStylePreComp(style, XSLT_FUNC_PARAM);
1908 #endif
1909
1910 if (comp == NULL)
1911 return;
1912 inst->psvi = comp;
1913 comp->inst = inst;
1914
1915 /*
1916 * Attribute "name".
1917 */
1918 xsltGetQNameProperty(style, inst, BAD_CAST "name",
1919 1, &(comp->has_name), &(comp->ns), &(comp->name));
1920 if (comp->ns)
1921 comp->has_ns = 1;
1922 /*
1923 * Attribute "select".
1924 */
1925 comp->select = xsltGetCNsProp(style, inst, (const xmlChar *)"select",
1926 XSLT_NAMESPACE);
1927 if (comp->select != NULL) {
1928 comp->comp = xsltXPathCompile(style, comp->select);
1929 if (comp->comp == NULL) {
1930 xsltTransformError(NULL, style, inst,
1931 "XSLT-param: could not compile select expression '%s'.\n",
1932 comp->select);
1933 style->errors++;
1934 }
1935 if (inst->children != NULL) {
1936 xsltTransformError(NULL, style, inst,
1937 "XSLT-param: The content should be empty since the "
1938 "attribute 'select' is present.\n");
1939 style->warnings++;
1940 }
1941 }
1942 }
1943
1944 /************************************************************************
1945 * *
1946 * Generic interface *
1947 * *
1948 ************************************************************************/
1949
1950 /**
1951 * xsltFreeStylePreComps:
1952 * @style: an XSLT transformation context
1953 *
1954 * Free up the memory allocated by all precomputed blocks
1955 */
1956 void
1957 xsltFreeStylePreComps(xsltStylesheetPtr style) {
1958 xsltElemPreCompPtr cur, next;
1959
1960 if (style == NULL)
1961 return;
1962
1963 cur = style->preComps;
1964 while (cur != NULL) {
1965 next = cur->next;
1966 if (cur->type == XSLT_FUNC_EXTENSION)
1967 cur->free(cur);
1968 else
1969 xsltFreeStylePreComp((xsltStylePreCompPtr) cur);
1970 cur = next;
1971 }
1972 }
1973
1974 #ifdef XSLT_REFACTORED
1975
1976 /**
1977 * xsltStylePreCompute:
1978 * @style: the XSLT stylesheet
1979 * @node: the element in the XSLT namespace
1980 *
1981 * Precompute an XSLT element.
1982 * This expects the type of the element to be already
1983 * set in style->compCtxt->inode->type;
1984 */
1985 void
1986 xsltStylePreCompute(xsltStylesheetPtr style, xmlNodePtr node) {
1987 /*
1988 * The xsltXSLTElemMarker marker was set beforehand by
1989 * the parsing mechanism for all elements in the XSLT namespace.
1990 */
1991 if (style == NULL) {
1992 if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
1993 node->psvi = NULL;
1994 return;
1995 }
1996 if (node == NULL)
1997 return;
1998 if (! IS_XSLT_ELEM_FAST(node))
1999 return;
2000
2001 node->psvi = NULL;
2002 if (XSLT_CCTXT(style)->inode->type != 0) {
2003 switch (XSLT_CCTXT(style)->inode->type) {
2004 case XSLT_FUNC_APPLYTEMPLATES:
2005 xsltApplyTemplatesComp(style, node);
2006 break;
2007 case XSLT_FUNC_WITHPARAM:
2008 xsltWithParamComp(style, node);
2009 break;
2010 case XSLT_FUNC_VALUEOF:
2011 xsltValueOfComp(style, node);
2012 break;
2013 case XSLT_FUNC_COPY:
2014 xsltCopyComp(style, node);
2015 break;
2016 case XSLT_FUNC_COPYOF:
2017 xsltCopyOfComp(style, node);
2018 break;
2019 case XSLT_FUNC_IF:
2020 xsltIfComp(style, node);
2021 break;
2022 case XSLT_FUNC_CHOOSE:
2023 xsltChooseComp(style, node);
2024 break;
2025 case XSLT_FUNC_WHEN:
2026 xsltWhenComp(style, node);
2027 break;
2028 case XSLT_FUNC_OTHERWISE:
2029 /* NOP yet */
2030 return;
2031 case XSLT_FUNC_FOREACH:
2032 xsltForEachComp(style, node);
2033 break;
2034 case XSLT_FUNC_APPLYIMPORTS:
2035 xsltApplyImportsComp(style, node);
2036 break;
2037 case XSLT_FUNC_ATTRIBUTE:
2038 xsltAttributeComp(style, node);
2039 break;
2040 case XSLT_FUNC_ELEMENT:
2041 xsltElementComp(style, node);
2042 break;
2043 case XSLT_FUNC_SORT:
2044 xsltSortComp(style, node);
2045 break;
2046 case XSLT_FUNC_COMMENT:
2047 xsltCommentComp(style, node);
2048 break;
2049 case XSLT_FUNC_NUMBER:
2050 xsltNumberComp(style, node);
2051 break;
2052 case XSLT_FUNC_PI:
2053 xsltProcessingInstructionComp(style, node);
2054 break;
2055 case XSLT_FUNC_CALLTEMPLATE:
2056 xsltCallTemplateComp(style, node);
2057 break;
2058 case XSLT_FUNC_PARAM:
2059 xsltParamComp(style, node);
2060 break;
2061 case XSLT_FUNC_VARIABLE:
2062 xsltVariableComp(style, node);
2063 break;
2064 case XSLT_FUNC_FALLBACK:
2065 /* NOP yet */
2066 return;
2067 case XSLT_FUNC_DOCUMENT:
2068 /* The extra one */
2069 node->psvi = (void *) xsltDocumentComp(style, node,
2070 (xsltTransformFunction) xsltDocumentElem);
2071 break;
2072 case XSLT_FUNC_MESSAGE:
2073 /* NOP yet */
2074 return;
2075 default:
2076 /*
2077 * NOTE that xsl:text, xsl:template, xsl:stylesheet,
2078 * xsl:transform, xsl:import, xsl:include are not expected
2079 * to be handed over to this function.
2080 */
2081 xsltTransformError(NULL, style, node,
2082 "Internal error: (xsltStylePreCompute) cannot handle "
2083 "the XSLT element '%s'.\n", node->name);
2084 style->errors++;
2085 return;
2086 }
2087 } else {
2088 /*
2089 * Fallback to string comparison.
2090 */
2091 if (IS_XSLT_NAME(node, "apply-templates")) {
2092 xsltApplyTemplatesComp(style, node);
2093 } else if (IS_XSLT_NAME(node, "with-param")) {
2094 xsltWithParamComp(style, node);
2095 } else if (IS_XSLT_NAME(node, "value-of")) {
2096 xsltValueOfComp(style, node);
2097 } else if (IS_XSLT_NAME(node, "copy")) {
2098 xsltCopyComp(style, node);
2099 } else if (IS_XSLT_NAME(node, "copy-of")) {
2100 xsltCopyOfComp(style, node);
2101 } else if (IS_XSLT_NAME(node, "if")) {
2102 xsltIfComp(style, node);
2103 } else if (IS_XSLT_NAME(node, "choose")) {
2104 xsltChooseComp(style, node);
2105 } else if (IS_XSLT_NAME(node, "when")) {
2106 xsltWhenComp(style, node);
2107 } else if (IS_XSLT_NAME(node, "otherwise")) {
2108 /* NOP yet */
2109 return;
2110 } else if (IS_XSLT_NAME(node, "for-each")) {
2111 xsltForEachComp(style, node);
2112 } else if (IS_XSLT_NAME(node, "apply-imports")) {
2113 xsltApplyImportsComp(style, node);
2114 } else if (IS_XSLT_NAME(node, "attribute")) {
2115 xsltAttributeComp(style, node);
2116 } else if (IS_XSLT_NAME(node, "element")) {
2117 xsltElementComp(style, node);
2118 } else if (IS_XSLT_NAME(node, "sort")) {
2119 xsltSortComp(style, node);
2120 } else if (IS_XSLT_NAME(node, "comment")) {
2121 xsltCommentComp(style, node);
2122 } else if (IS_XSLT_NAME(node, "number")) {
2123 xsltNumberComp(style, node);
2124 } else if (IS_XSLT_NAME(node, "processing-instruction")) {
2125 xsltProcessingInstructionComp(style, node);
2126 } else if (IS_XSLT_NAME(node, "call-template")) {
2127 xsltCallTemplateComp(style, node);
2128 } else if (IS_XSLT_NAME(node, "param")) {
2129 xsltParamComp(style, node);
2130 } else if (IS_XSLT_NAME(node, "variable")) {
2131 xsltVariableComp(style, node);
2132 } else if (IS_XSLT_NAME(node, "fallback")) {
2133 /* NOP yet */
2134 return;
2135 } else if (IS_XSLT_NAME(node, "document")) {
2136 /* The extra one */
2137 node->psvi = (void *) xsltDocumentComp(style, node,
2138 (xsltTransformFunction) xsltDocumentElem);
2139 } else if (IS_XSLT_NAME(node, "output")) {
2140 /* Top-level */
2141 return;
2142 } else if (IS_XSLT_NAME(node, "preserve-space")) {
2143 /* Top-level */
2144 return;
2145 } else if (IS_XSLT_NAME(node, "strip-space")) {
2146 /* Top-level */
2147 return;
2148 } else if (IS_XSLT_NAME(node, "key")) {
2149 /* Top-level */
2150 return;
2151 } else if (IS_XSLT_NAME(node, "message")) {
2152 return;
2153 } else if (IS_XSLT_NAME(node, "attribute-set")) {
2154 /* Top-level */
2155 return;
2156 } else if (IS_XSLT_NAME(node, "namespace-alias")) {
2157 /* Top-level */
2158 return;
2159 } else if (IS_XSLT_NAME(node, "decimal-format")) {
2160 /* Top-level */
2161 return;
2162 } else if (IS_XSLT_NAME(node, "include")) {
2163 /* Top-level */
2164 } else {
2165 /*
2166 * NOTE that xsl:text, xsl:template, xsl:stylesheet,
2167 * xsl:transform, xsl:import, xsl:include are not expected
2168 * to be handed over to this function.
2169 */
2170 xsltTransformError(NULL, style, node,
2171 "Internal error: (xsltStylePreCompute) cannot handle "
2172 "the XSLT element '%s'.\n", node->name);
2173 style->errors++;
2174 return;
2175 }
2176 }
2177 /*
2178 * Assign the current list of in-scope namespaces to the
2179 * item. This is needed for XPath expressions.
2180 */
2181 if (node->psvi != NULL) {
2182 ((xsltStylePreCompPtr) node->psvi)->inScopeNs =
2183 XSLT_CCTXT(style)->inode->inScopeNs;
2184 }
2185 }
2186
2187 #else
2188
2189 /**
2190 * xsltStylePreCompute:
2191 * @style: the XSLT stylesheet
2192 * @inst: the instruction in the stylesheet
2193 *
2194 * Precompute an XSLT stylesheet element
2195 */
2196 void
2197 xsltStylePreCompute(xsltStylesheetPtr style, xmlNodePtr inst) {
2198 /*
2199 * URGENT TODO: Normally inst->psvi Should never be reserved here,
2200 * BUT: since if we include the same stylesheet from
2201 * multiple imports, then the stylesheet will be parsed
2202 * again. We simply must not try to compute the stylesheet again.
2203 * TODO: Get to the point where we don't need to query the
2204 * namespace- and local-name of the node, but can evaluate this
2205 * using cctxt->style->inode->category;
2206 */
2207 if ((inst == NULL) || (inst->type != XML_ELEMENT_NODE) ||
2208 (inst->psvi != NULL))
2209 return;
2210
2211 if (IS_XSLT_ELEM(inst)) {
2212 xsltStylePreCompPtr cur;
2213
2214 if (IS_XSLT_NAME(inst, "apply-templates")) {
2215 xsltCheckInstructionElement(style, inst);
2216 xsltApplyTemplatesComp(style, inst);
2217 } else if (IS_XSLT_NAME(inst, "with-param")) {
2218 xsltCheckParentElement(style, inst, BAD_CAST "apply-templates",
2219 BAD_CAST "call-template");
2220 xsltWithParamComp(style, inst);
2221 } else if (IS_XSLT_NAME(inst, "value-of")) {
2222 xsltCheckInstructionElement(style, inst);
2223 xsltValueOfComp(style, inst);
2224 } else if (IS_XSLT_NAME(inst, "copy")) {
2225 xsltCheckInstructionElement(style, inst);
2226 xsltCopyComp(style, inst);
2227 } else if (IS_XSLT_NAME(inst, "copy-of")) {
2228 xsltCheckInstructionElement(style, inst);
2229 xsltCopyOfComp(style, inst);
2230 } else if (IS_XSLT_NAME(inst, "if")) {
2231 xsltCheckInstructionElement(style, inst);
2232 xsltIfComp(style, inst);
2233 } else if (IS_XSLT_NAME(inst, "when")) {
2234 xsltCheckParentElement(style, inst, BAD_CAST "choose", NULL);
2235 xsltWhenComp(style, inst);
2236 } else if (IS_XSLT_NAME(inst, "choose")) {
2237 xsltCheckInstructionElement(style, inst);
2238 xsltChooseComp(style, inst);
2239 } else if (IS_XSLT_NAME(inst, "for-each")) {
2240 xsltCheckInstructionElement(style, inst);
2241 xsltForEachComp(style, inst);
2242 } else if (IS_XSLT_NAME(inst, "apply-imports")) {
2243 xsltCheckInstructionElement(style, inst);
2244 xsltApplyImportsComp(style, inst);
2245 } else if (IS_XSLT_NAME(inst, "attribute")) {
2246 xmlNodePtr parent = inst->parent;
2247
2248 if ((parent == NULL) || (parent->ns == NULL) ||
2249 ((parent->ns != inst->ns) &&
2250 (!xmlStrEqual(parent->ns->href, inst->ns->href))) ||
2251 (!xmlStrEqual(parent->name, BAD_CAST "attribute-set"))) {
2252 xsltCheckInstructionElement(style, inst);
2253 }
2254 xsltAttributeComp(style, inst);
2255 } else if (IS_XSLT_NAME(inst, "element")) {
2256 xsltCheckInstructionElement(style, inst);
2257 xsltElementComp(style, inst);
2258 } else if (IS_XSLT_NAME(inst, "text")) {
2259 xsltCheckInstructionElement(style, inst);
2260 xsltTextComp(style, inst);
2261 } else if (IS_XSLT_NAME(inst, "sort")) {
2262 xsltCheckParentElement(style, inst, BAD_CAST "apply-templates",
2263 BAD_CAST "for-each");
2264 xsltSortComp(style, inst);
2265 } else if (IS_XSLT_NAME(inst, "comment")) {
2266 xsltCheckInstructionElement(style, inst);
2267 xsltCommentComp(style, inst);
2268 } else if (IS_XSLT_NAME(inst, "number")) {
2269 xsltCheckInstructionElement(style, inst);
2270 xsltNumberComp(style, inst);
2271 } else if (IS_XSLT_NAME(inst, "processing-instruction")) {
2272 xsltCheckInstructionElement(style, inst);
2273 xsltProcessingInstructionComp(style, inst);
2274 } else if (IS_XSLT_NAME(inst, "call-template")) {
2275 xsltCheckInstructionElement(style, inst);
2276 xsltCallTemplateComp(style, inst);
2277 } else if (IS_XSLT_NAME(inst, "param")) {
2278 if (xsltCheckTopLevelElement(style, inst, 0) == 0)
2279 xsltCheckInstructionElement(style, inst);
2280 xsltParamComp(style, inst);
2281 } else if (IS_XSLT_NAME(inst, "variable")) {
2282 if (xsltCheckTopLevelElement(style, inst, 0) == 0)
2283 xsltCheckInstructionElement(style, inst);
2284 xsltVariableComp(style, inst);
2285 } else if (IS_XSLT_NAME(inst, "otherwise")) {
2286 xsltCheckParentElement(style, inst, BAD_CAST "choose", NULL);
2287 xsltCheckInstructionElement(style, inst);
2288 return;
2289 } else if (IS_XSLT_NAME(inst, "template")) {
2290 xsltCheckTopLevelElement(style, inst, 1);
2291 return;
2292 } else if (IS_XSLT_NAME(inst, "output")) {
2293 xsltCheckTopLevelElement(style, inst, 1);
2294 return;
2295 } else if (IS_XSLT_NAME(inst, "preserve-space")) {
2296 xsltCheckTopLevelElement(style, inst, 1);
2297 return;
2298 } else if (IS_XSLT_NAME(inst, "strip-space")) {
2299 xsltCheckTopLevelElement(style, inst, 1);
2300 return;
2301 } else if ((IS_XSLT_NAME(inst, "stylesheet")) ||
2302 (IS_XSLT_NAME(inst, "transform"))) {
2303 xmlNodePtr parent = inst->parent;
2304
2305 if ((parent == NULL) || (parent->type != XML_DOCUMENT_NODE)) {
2306 xsltTransformError(NULL, style, inst,
2307 "element %s only allowed only as root element\n",
2308 inst->name);
2309 style->errors++;
2310 }
2311 return;
2312 } else if (IS_XSLT_NAME(inst, "key")) {
2313 xsltCheckTopLevelElement(style, inst, 1);
2314 return;
2315 } else if (IS_XSLT_NAME(inst, "message")) {
2316 xsltCheckInstructionElement(style, inst);
2317 return;
2318 } else if (IS_XSLT_NAME(inst, "attribute-set")) {
2319 xsltCheckTopLevelElement(style, inst, 1);
2320 return;
2321 } else if (IS_XSLT_NAME(inst, "namespace-alias")) {
2322 xsltCheckTopLevelElement(style, inst, 1);
2323 return;
2324 } else if (IS_XSLT_NAME(inst, "include")) {
2325 xsltCheckTopLevelElement(style, inst, 1);
2326 return;
2327 } else if (IS_XSLT_NAME(inst, "import")) {
2328 xsltCheckTopLevelElement(style, inst, 1);
2329 return;
2330 } else if (IS_XSLT_NAME(inst, "decimal-format")) {
2331 xsltCheckTopLevelElement(style, inst, 1);
2332 return;
2333 } else if (IS_XSLT_NAME(inst, "fallback")) {
2334 xsltCheckInstructionElement(style, inst);
2335 return;
2336 } else if (IS_XSLT_NAME(inst, "document")) {
2337 xsltCheckInstructionElement(style, inst);
2338 inst->psvi = (void *) xsltDocumentComp(style, inst,
2339 (xsltTransformFunction) xsltDocumentElem);
2340 } else {
2341 xsltTransformError(NULL, style, inst,
2342 "xsltStylePreCompute: unknown xsl:%s\n", inst->name);
2343 if (style != NULL) style->warnings++;
2344 }
2345
2346 cur = (xsltStylePreCompPtr) inst->psvi;
2347 /*
2348 * A ns-list is build for every XSLT item in the
2349 * node-tree. This is needed for XPath expressions.
2350 */
2351 if (cur != NULL) {
2352 int i = 0;
2353
2354 cur->nsList = xmlGetNsList(inst->doc, inst);
2355 if (cur->nsList != NULL) {
2356 while (cur->nsList[i] != NULL)
2357 i++;
2358 }
2359 cur->nsNr = i;
2360 }
2361 } else {
2362 inst->psvi =
2363 (void *) xsltPreComputeExtModuleElement(style, inst);
2364
2365 /*
2366 * Unknown element, maybe registered at the context
2367 * level. Mark it for later recognition.
2368 */
2369 if (inst->psvi == NULL)
2370 inst->psvi = (void *) xsltExtMarker;
2371 }
2372 }
2373 #endif /* XSLT_REFACTORED */