41a58d36c30b3cd888e44f3195a74a98f06cec08
[reactos.git] / dll / 3rdparty / libxslt / functions.c
1 /*
2 * functions.c: Implementation of the XSLT extra functions
3 *
4 * Reference:
5 * http://www.w3.org/TR/1999/REC-xslt-19991116
6 *
7 * See Copyright for the status of this software.
8 *
9 * daniel@veillard.com
10 * Bjorn Reese <breese@users.sourceforge.net> for number formatting
11 */
12
13 #include "precomp.h"
14
15 #include <libxml/xpointer.h>
16
17 #ifdef WITH_XSLT_DEBUG
18 #define WITH_XSLT_DEBUG_FUNCTION
19 #endif
20
21 /*
22 * Some versions of DocBook XSL use the vendor string to detect
23 * supporting chunking, this is a workaround to be considered
24 * in the list of decent XSLT processors <grin/>
25 */
26 #define DOCBOOK_XSL_HACK
27
28 /**
29 * xsltXPathFunctionLookup:
30 * @ctxt: a void * but the XSLT transformation context actually
31 * @name: the function name
32 * @ns_uri: the function namespace URI
33 *
34 * This is the entry point when a function is needed by the XPath
35 * interpretor.
36 *
37 * Returns the callback function or NULL if not found
38 */
39 xmlXPathFunction
40 xsltXPathFunctionLookup (xmlXPathContextPtr ctxt,
41 const xmlChar *name, const xmlChar *ns_uri) {
42 xmlXPathFunction ret;
43
44 if ((ctxt == NULL) || (name == NULL) || (ns_uri == NULL))
45 return (NULL);
46
47 #ifdef WITH_XSLT_DEBUG_FUNCTION
48 xsltGenericDebug(xsltGenericDebugContext,
49 "Lookup function {%s}%s\n", ns_uri, name);
50 #endif
51
52 /* give priority to context-level functions */
53 /*
54 ret = (xmlXPathFunction) xmlHashLookup2(ctxt->funcHash, name, ns_uri);
55 */
56 XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->funcHash, name, ns_uri);
57
58 if (ret == NULL)
59 ret = xsltExtModuleFunctionLookup(name, ns_uri);
60
61 #ifdef WITH_XSLT_DEBUG_FUNCTION
62 if (ret != NULL)
63 xsltGenericDebug(xsltGenericDebugContext,
64 "found function %s\n", name);
65 #endif
66 return(ret);
67 }
68
69
70 /************************************************************************
71 * *
72 * Module interfaces *
73 * *
74 ************************************************************************/
75
76 static void
77 xsltDocumentFunctionLoadDocument(xmlXPathParserContextPtr ctxt, xmlChar* URI)
78 {
79 xsltTransformContextPtr tctxt;
80 xmlURIPtr uri;
81 xmlChar *fragment;
82 xsltDocumentPtr idoc; /* document info */
83 xmlDocPtr doc;
84 xmlXPathContextPtr xptrctxt = NULL;
85 xmlXPathObjectPtr resObj = NULL;
86
87 tctxt = xsltXPathGetTransformContext(ctxt);
88 if (tctxt == NULL) {
89 xsltTransformError(NULL, NULL, NULL,
90 "document() : internal error tctxt == NULL\n");
91 valuePush(ctxt, xmlXPathNewNodeSet(NULL));
92 return;
93 }
94
95 uri = xmlParseURI((const char *) URI);
96 if (uri == NULL) {
97 xsltTransformError(tctxt, NULL, NULL,
98 "document() : failed to parse URI\n");
99 valuePush(ctxt, xmlXPathNewNodeSet(NULL));
100 return;
101 }
102
103 /*
104 * check for and remove fragment identifier
105 */
106 fragment = (xmlChar *)uri->fragment;
107 if (fragment != NULL) {
108 xmlChar *newURI;
109 uri->fragment = NULL;
110 newURI = xmlSaveUri(uri);
111 idoc = xsltLoadDocument(tctxt, newURI);
112 xmlFree(newURI);
113 } else
114 idoc = xsltLoadDocument(tctxt, URI);
115 xmlFreeURI(uri);
116
117 if (idoc == NULL) {
118 if ((URI == NULL) ||
119 (URI[0] == '#') ||
120 ((tctxt->style->doc != NULL) &&
121 (xmlStrEqual(tctxt->style->doc->URL, URI))))
122 {
123 /*
124 * This selects the stylesheet's doc itself.
125 */
126 doc = tctxt->style->doc;
127 } else {
128 valuePush(ctxt, xmlXPathNewNodeSet(NULL));
129
130 if (fragment != NULL)
131 xmlFree(fragment);
132
133 return;
134 }
135 } else
136 doc = idoc->doc;
137
138 if (fragment == NULL) {
139 valuePush(ctxt, xmlXPathNewNodeSet((xmlNodePtr) doc));
140 return;
141 }
142
143 /* use XPointer of HTML location for fragment ID */
144 #ifdef LIBXML_XPTR_ENABLED
145 xptrctxt = xmlXPtrNewContext(doc, NULL, NULL);
146 if (xptrctxt == NULL) {
147 xsltTransformError(tctxt, NULL, NULL,
148 "document() : internal error xptrctxt == NULL\n");
149 goto out_fragment;
150 }
151
152 resObj = xmlXPtrEval(fragment, xptrctxt);
153 xmlXPathFreeContext(xptrctxt);
154 #endif
155
156 if (resObj == NULL)
157 goto out_fragment;
158
159 switch (resObj->type) {
160 case XPATH_NODESET:
161 break;
162 case XPATH_UNDEFINED:
163 case XPATH_BOOLEAN:
164 case XPATH_NUMBER:
165 case XPATH_STRING:
166 case XPATH_POINT:
167 case XPATH_USERS:
168 case XPATH_XSLT_TREE:
169 case XPATH_RANGE:
170 case XPATH_LOCATIONSET:
171 xsltTransformError(tctxt, NULL, NULL,
172 "document() : XPointer does not select a node set: #%s\n",
173 fragment);
174 goto out_object;
175 }
176
177 valuePush(ctxt, resObj);
178 xmlFree(fragment);
179 return;
180
181 out_object:
182 xmlXPathFreeObject(resObj);
183
184 out_fragment:
185 valuePush(ctxt, xmlXPathNewNodeSet(NULL));
186 xmlFree(fragment);
187 }
188
189 /**
190 * xsltDocumentFunction:
191 * @ctxt: the XPath Parser context
192 * @nargs: the number of arguments
193 *
194 * Implement the document() XSLT function
195 * node-set document(object, node-set?)
196 */
197 void
198 xsltDocumentFunction(xmlXPathParserContextPtr ctxt, int nargs)
199 {
200 xmlXPathObjectPtr obj, obj2 = NULL;
201 xmlChar *base = NULL, *URI;
202
203
204 if ((nargs < 1) || (nargs > 2)) {
205 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
206 "document() : invalid number of args %d\n",
207 nargs);
208 ctxt->error = XPATH_INVALID_ARITY;
209 return;
210 }
211 if (ctxt->value == NULL) {
212 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
213 "document() : invalid arg value\n");
214 ctxt->error = XPATH_INVALID_TYPE;
215 return;
216 }
217
218 if (nargs == 2) {
219 if (ctxt->value->type != XPATH_NODESET) {
220 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
221 "document() : invalid arg expecting a nodeset\n");
222 ctxt->error = XPATH_INVALID_TYPE;
223 return;
224 }
225
226 obj2 = valuePop(ctxt);
227 }
228
229 if (ctxt->value->type == XPATH_NODESET) {
230 int i;
231 xmlXPathObjectPtr newobj, ret;
232
233 obj = valuePop(ctxt);
234 ret = xmlXPathNewNodeSet(NULL);
235
236 if ((obj != NULL) && obj->nodesetval) {
237 for (i = 0; i < obj->nodesetval->nodeNr; i++) {
238 valuePush(ctxt,
239 xmlXPathNewNodeSet(obj->nodesetval->nodeTab[i]));
240 xmlXPathStringFunction(ctxt, 1);
241 if (nargs == 2) {
242 valuePush(ctxt, xmlXPathObjectCopy(obj2));
243 } else {
244 valuePush(ctxt,
245 xmlXPathNewNodeSet(obj->nodesetval->
246 nodeTab[i]));
247 }
248 xsltDocumentFunction(ctxt, 2);
249 newobj = valuePop(ctxt);
250 ret->nodesetval = xmlXPathNodeSetMerge(ret->nodesetval,
251 newobj->nodesetval);
252 xmlXPathFreeObject(newobj);
253 }
254 }
255
256 if (obj != NULL)
257 xmlXPathFreeObject(obj);
258 if (obj2 != NULL)
259 xmlXPathFreeObject(obj2);
260 valuePush(ctxt, ret);
261 return;
262 }
263 /*
264 * Make sure it's converted to a string
265 */
266 xmlXPathStringFunction(ctxt, 1);
267 if (ctxt->value->type != XPATH_STRING) {
268 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
269 "document() : invalid arg expecting a string\n");
270 ctxt->error = XPATH_INVALID_TYPE;
271 if (obj2 != NULL)
272 xmlXPathFreeObject(obj2);
273 return;
274 }
275 obj = valuePop(ctxt);
276 if (obj->stringval == NULL) {
277 valuePush(ctxt, xmlXPathNewNodeSet(NULL));
278 } else {
279 xsltTransformContextPtr tctxt;
280 tctxt = xsltXPathGetTransformContext(ctxt);
281 if ((obj2 != NULL) && (obj2->nodesetval != NULL) &&
282 (obj2->nodesetval->nodeNr > 0) &&
283 IS_XSLT_REAL_NODE(obj2->nodesetval->nodeTab[0])) {
284 xmlNodePtr target;
285
286 target = obj2->nodesetval->nodeTab[0];
287 if ((target->type == XML_ATTRIBUTE_NODE) ||
288 (target->type == XML_PI_NODE)) {
289 target = ((xmlAttrPtr) target)->parent;
290 }
291 base = xmlNodeGetBase(target->doc, target);
292 } else {
293 if ((tctxt != NULL) && (tctxt->inst != NULL)) {
294 base = xmlNodeGetBase(tctxt->inst->doc, tctxt->inst);
295 } else if ((tctxt != NULL) && (tctxt->style != NULL) &&
296 (tctxt->style->doc != NULL)) {
297 base = xmlNodeGetBase(tctxt->style->doc,
298 (xmlNodePtr) tctxt->style->doc);
299 }
300 }
301 URI = xmlBuildURI(obj->stringval, base);
302 if (base != NULL)
303 xmlFree(base);
304 if (URI == NULL) {
305 if ((tctxt != NULL) && (tctxt->style != NULL) &&
306 (tctxt->style->doc != NULL) &&
307 (xmlStrEqual(URI, tctxt->style->doc->URL))) {
308 /* This selects the stylesheet's doc itself. */
309 valuePush(ctxt, xmlXPathNewNodeSet((xmlNodePtr) tctxt->style->doc));
310 } else {
311 valuePush(ctxt, xmlXPathNewNodeSet(NULL));
312 }
313 } else {
314 xsltDocumentFunctionLoadDocument( ctxt, URI );
315 xmlFree(URI);
316 }
317 }
318 xmlXPathFreeObject(obj);
319 if (obj2 != NULL)
320 xmlXPathFreeObject(obj2);
321 }
322
323 /**
324 * xsltKeyFunction:
325 * @ctxt: the XPath Parser context
326 * @nargs: the number of arguments
327 *
328 * Implement the key() XSLT function
329 * node-set key(string, object)
330 */
331 void
332 xsltKeyFunction(xmlXPathParserContextPtr ctxt, int nargs){
333 xmlXPathObjectPtr obj1, obj2;
334
335 if (nargs != 2) {
336 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
337 "key() : expects two arguments\n");
338 ctxt->error = XPATH_INVALID_ARITY;
339 return;
340 }
341
342 /*
343 * Get the key's value.
344 */
345 obj2 = valuePop(ctxt);
346 xmlXPathStringFunction(ctxt, 1);
347 if ((obj2 == NULL) ||
348 (ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
349 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
350 "key() : invalid arg expecting a string\n");
351 ctxt->error = XPATH_INVALID_TYPE;
352 xmlXPathFreeObject(obj2);
353
354 return;
355 }
356 /*
357 * Get the key's name.
358 */
359 obj1 = valuePop(ctxt);
360
361 if ((obj2->type == XPATH_NODESET) || (obj2->type == XPATH_XSLT_TREE)) {
362 int i;
363 xmlXPathObjectPtr newobj, ret;
364
365 ret = xmlXPathNewNodeSet(NULL);
366
367 if (obj2->nodesetval != NULL) {
368 for (i = 0; i < obj2->nodesetval->nodeNr; i++) {
369 valuePush(ctxt, xmlXPathObjectCopy(obj1));
370 valuePush(ctxt,
371 xmlXPathNewNodeSet(obj2->nodesetval->nodeTab[i]));
372 xmlXPathStringFunction(ctxt, 1);
373 xsltKeyFunction(ctxt, 2);
374 newobj = valuePop(ctxt);
375 ret->nodesetval = xmlXPathNodeSetMerge(ret->nodesetval,
376 newobj->nodesetval);
377 xmlXPathFreeObject(newobj);
378 }
379 }
380 valuePush(ctxt, ret);
381 } else {
382 xmlNodeSetPtr nodelist = NULL;
383 xmlChar *key = NULL, *value;
384 const xmlChar *keyURI;
385 xsltTransformContextPtr tctxt;
386 xmlChar *qname, *prefix;
387 xmlXPathContextPtr xpctxt = ctxt->context;
388 xmlNodePtr tmpNode = NULL;
389 xsltDocumentPtr oldDocInfo;
390
391 tctxt = xsltXPathGetTransformContext(ctxt);
392
393 oldDocInfo = tctxt->document;
394
395 if (xpctxt->node == NULL) {
396 xsltTransformError(tctxt, NULL, tctxt->inst,
397 "Internal error in xsltKeyFunction(): "
398 "The context node is not set on the XPath context.\n");
399 tctxt->state = XSLT_STATE_STOPPED;
400 goto error;
401 }
402 /*
403 * Get the associated namespace URI if qualified name
404 */
405 qname = obj1->stringval;
406 key = xmlSplitQName2(qname, &prefix);
407 if (key == NULL) {
408 key = xmlStrdup(obj1->stringval);
409 keyURI = NULL;
410 if (prefix != NULL)
411 xmlFree(prefix);
412 } else {
413 if (prefix != NULL) {
414 keyURI = xmlXPathNsLookup(xpctxt, prefix);
415 if (keyURI == NULL) {
416 xsltTransformError(tctxt, NULL, tctxt->inst,
417 "key() : prefix %s is not bound\n", prefix);
418 /*
419 * TODO: Shouldn't we stop here?
420 */
421 }
422 xmlFree(prefix);
423 } else {
424 keyURI = NULL;
425 }
426 }
427
428 /*
429 * Force conversion of first arg to string
430 */
431 valuePush(ctxt, obj2);
432 xmlXPathStringFunction(ctxt, 1);
433 if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
434 xsltTransformError(tctxt, NULL, tctxt->inst,
435 "key() : invalid arg expecting a string\n");
436 ctxt->error = XPATH_INVALID_TYPE;
437 goto error;
438 }
439 obj2 = valuePop(ctxt);
440 value = obj2->stringval;
441
442 /*
443 * We need to ensure that ctxt->document is available for
444 * xsltGetKey().
445 * First find the relevant doc, which is the context node's
446 * owner doc; using context->doc is not safe, since
447 * the doc could have been acquired via the document() function,
448 * or the doc might be a Result Tree Fragment.
449 * FUTURE INFO: In XSLT 2.0 the key() function takes an additional
450 * argument indicating the doc to use.
451 */
452 if (xpctxt->node->type == XML_NAMESPACE_DECL) {
453 /*
454 * REVISIT: This is a libxml hack! Check xpath.c for details.
455 * The XPath module sets the owner element of a ns-node on
456 * the ns->next field.
457 */
458 if ((((xmlNsPtr) xpctxt->node)->next != NULL) &&
459 (((xmlNsPtr) xpctxt->node)->next->type == XML_ELEMENT_NODE))
460 {
461 tmpNode = (xmlNodePtr) ((xmlNsPtr) xpctxt->node)->next;
462 }
463 } else
464 tmpNode = xpctxt->node;
465
466 if ((tmpNode == NULL) || (tmpNode->doc == NULL)) {
467 xsltTransformError(tctxt, NULL, tctxt->inst,
468 "Internal error in xsltKeyFunction(): "
469 "Couldn't get the doc of the XPath context node.\n");
470 goto error;
471 }
472
473 if ((tctxt->document == NULL) ||
474 (tctxt->document->doc != tmpNode->doc))
475 {
476 if (tmpNode->doc->name && (tmpNode->doc->name[0] == ' ')) {
477 /*
478 * This is a Result Tree Fragment.
479 */
480 if (tmpNode->doc->_private == NULL) {
481 tmpNode->doc->_private = xsltNewDocument(tctxt, tmpNode->doc);
482 if (tmpNode->doc->_private == NULL)
483 goto error;
484 }
485 tctxt->document = (xsltDocumentPtr) tmpNode->doc->_private;
486 } else {
487 /*
488 * May be the initial source doc or a doc acquired via the
489 * document() function.
490 */
491 tctxt->document = xsltFindDocument(tctxt, tmpNode->doc);
492 }
493 if (tctxt->document == NULL) {
494 xsltTransformError(tctxt, NULL, tctxt->inst,
495 "Internal error in xsltKeyFunction(): "
496 "Could not get the document info of a context doc.\n");
497 tctxt->state = XSLT_STATE_STOPPED;
498 goto error;
499 }
500 }
501 /*
502 * Get/compute the key value.
503 */
504 nodelist = xsltGetKey(tctxt, key, keyURI, value);
505
506 error:
507 tctxt->document = oldDocInfo;
508 valuePush(ctxt, xmlXPathWrapNodeSet(
509 xmlXPathNodeSetMerge(NULL, nodelist)));
510 if (key != NULL)
511 xmlFree(key);
512 }
513
514 if (obj1 != NULL)
515 xmlXPathFreeObject(obj1);
516 if (obj2 != NULL)
517 xmlXPathFreeObject(obj2);
518 }
519
520 /**
521 * xsltUnparsedEntityURIFunction:
522 * @ctxt: the XPath Parser context
523 * @nargs: the number of arguments
524 *
525 * Implement the unparsed-entity-uri() XSLT function
526 * string unparsed-entity-uri(string)
527 */
528 void
529 xsltUnparsedEntityURIFunction(xmlXPathParserContextPtr ctxt, int nargs){
530 xmlXPathObjectPtr obj;
531 xmlChar *str;
532
533 if ((nargs != 1) || (ctxt->value == NULL)) {
534 xsltGenericError(xsltGenericErrorContext,
535 "unparsed-entity-uri() : expects one string arg\n");
536 ctxt->error = XPATH_INVALID_ARITY;
537 return;
538 }
539 obj = valuePop(ctxt);
540 if (obj->type != XPATH_STRING) {
541 obj = xmlXPathConvertString(obj);
542 }
543
544 str = obj->stringval;
545 if (str == NULL) {
546 valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
547 } else {
548 xmlEntityPtr entity;
549
550 entity = xmlGetDocEntity(ctxt->context->doc, str);
551 if (entity == NULL) {
552 valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
553 } else {
554 if (entity->URI != NULL)
555 valuePush(ctxt, xmlXPathNewString(entity->URI));
556 else
557 valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
558 }
559 }
560 xmlXPathFreeObject(obj);
561 }
562
563 /**
564 * xsltFormatNumberFunction:
565 * @ctxt: the XPath Parser context
566 * @nargs: the number of arguments
567 *
568 * Implement the format-number() XSLT function
569 * string format-number(number, string, string?)
570 */
571 void
572 xsltFormatNumberFunction(xmlXPathParserContextPtr ctxt, int nargs)
573 {
574 xmlXPathObjectPtr numberObj = NULL;
575 xmlXPathObjectPtr formatObj = NULL;
576 xmlXPathObjectPtr decimalObj = NULL;
577 xsltStylesheetPtr sheet;
578 xsltDecimalFormatPtr formatValues;
579 xmlChar *result;
580 xsltTransformContextPtr tctxt;
581
582 tctxt = xsltXPathGetTransformContext(ctxt);
583 if (tctxt == NULL)
584 return;
585 sheet = tctxt->style;
586 if (sheet == NULL)
587 return;
588 formatValues = sheet->decimalFormat;
589
590 switch (nargs) {
591 case 3:
592 CAST_TO_STRING;
593 decimalObj = valuePop(ctxt);
594 formatValues = xsltDecimalFormatGetByName(sheet, decimalObj->stringval);
595 if (formatValues == NULL) {
596 xsltTransformError(tctxt, NULL, NULL,
597 "format-number() : undeclared decimal format '%s'\n",
598 decimalObj->stringval);
599 }
600 /* Intentional fall-through */
601 case 2:
602 CAST_TO_STRING;
603 formatObj = valuePop(ctxt);
604 CAST_TO_NUMBER;
605 numberObj = valuePop(ctxt);
606 break;
607 default:
608 XP_ERROR(XPATH_INVALID_ARITY);
609 }
610
611 if (formatValues != NULL) {
612 if (xsltFormatNumberConversion(formatValues,
613 formatObj->stringval,
614 numberObj->floatval,
615 &result) == XPATH_EXPRESSION_OK) {
616 valuePush(ctxt, xmlXPathNewString(result));
617 xmlFree(result);
618 }
619 }
620
621 xmlXPathFreeObject(numberObj);
622 xmlXPathFreeObject(formatObj);
623 xmlXPathFreeObject(decimalObj);
624 }
625
626 /**
627 * xsltGenerateIdFunction:
628 * @ctxt: the XPath Parser context
629 * @nargs: the number of arguments
630 *
631 * Implement the generate-id() XSLT function
632 * string generate-id(node-set?)
633 */
634 void
635 xsltGenerateIdFunction(xmlXPathParserContextPtr ctxt, int nargs){
636 static char base_address;
637 xmlNodePtr cur = NULL;
638 xmlXPathObjectPtr obj = NULL;
639 long val;
640 xmlChar str[30];
641
642 if (nargs == 0) {
643 cur = ctxt->context->node;
644 } else if (nargs == 1) {
645 xmlNodeSetPtr nodelist;
646 int i, ret;
647
648 if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_NODESET)) {
649 ctxt->error = XPATH_INVALID_TYPE;
650 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
651 "generate-id() : invalid arg expecting a node-set\n");
652 return;
653 }
654 obj = valuePop(ctxt);
655 nodelist = obj->nodesetval;
656 if ((nodelist == NULL) || (nodelist->nodeNr <= 0)) {
657 xmlXPathFreeObject(obj);
658 valuePush(ctxt, xmlXPathNewCString(""));
659 return;
660 }
661 cur = nodelist->nodeTab[0];
662 for (i = 1;i < nodelist->nodeNr;i++) {
663 ret = xmlXPathCmpNodes(cur, nodelist->nodeTab[i]);
664 if (ret == -1)
665 cur = nodelist->nodeTab[i];
666 }
667 } else {
668 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
669 "generate-id() : invalid number of args %d\n", nargs);
670 ctxt->error = XPATH_INVALID_ARITY;
671 return;
672 }
673
674 if (obj)
675 xmlXPathFreeObject(obj);
676
677 val = (long)((char *)cur - (char *)&base_address);
678 if (val >= 0) {
679 snprintf((char *)str, sizeof(str), "idp%ld", val);
680 } else {
681 snprintf((char *)str, sizeof(str), "idm%ld", -val);
682 }
683 valuePush(ctxt, xmlXPathNewString(str));
684 }
685
686 /**
687 * xsltSystemPropertyFunction:
688 * @ctxt: the XPath Parser context
689 * @nargs: the number of arguments
690 *
691 * Implement the system-property() XSLT function
692 * object system-property(string)
693 */
694 void
695 xsltSystemPropertyFunction(xmlXPathParserContextPtr ctxt, int nargs){
696 xmlXPathObjectPtr obj;
697 xmlChar *prefix, *name;
698 const xmlChar *nsURI = NULL;
699
700 if (nargs != 1) {
701 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
702 "system-property() : expects one string arg\n");
703 ctxt->error = XPATH_INVALID_ARITY;
704 return;
705 }
706 if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
707 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
708 "system-property() : invalid arg expecting a string\n");
709 ctxt->error = XPATH_INVALID_TYPE;
710 return;
711 }
712 obj = valuePop(ctxt);
713 if (obj->stringval == NULL) {
714 valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
715 } else {
716 name = xmlSplitQName2(obj->stringval, &prefix);
717 if (name == NULL) {
718 name = xmlStrdup(obj->stringval);
719 } else {
720 nsURI = xmlXPathNsLookup(ctxt->context, prefix);
721 if (nsURI == NULL) {
722 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
723 "system-property() : prefix %s is not bound\n", prefix);
724 }
725 }
726
727 if (xmlStrEqual(nsURI, XSLT_NAMESPACE)) {
728 #ifdef DOCBOOK_XSL_HACK
729 if (xmlStrEqual(name, (const xmlChar *)"vendor")) {
730 xsltStylesheetPtr sheet;
731 xsltTransformContextPtr tctxt;
732
733 tctxt = xsltXPathGetTransformContext(ctxt);
734 if ((tctxt != NULL) && (tctxt->inst != NULL) &&
735 (xmlStrEqual(tctxt->inst->name, BAD_CAST "variable")) &&
736 (tctxt->inst->parent != NULL) &&
737 (xmlStrEqual(tctxt->inst->parent->name,
738 BAD_CAST "template")))
739 sheet = tctxt->style;
740 else
741 sheet = NULL;
742 if ((sheet != NULL) && (sheet->doc != NULL) &&
743 (sheet->doc->URL != NULL) &&
744 (xmlStrstr(sheet->doc->URL,
745 (const xmlChar *)"chunk") != NULL)) {
746 valuePush(ctxt, xmlXPathNewString(
747 (const xmlChar *)"libxslt (SAXON 6.2 compatible)"));
748
749 } else {
750 valuePush(ctxt, xmlXPathNewString(
751 (const xmlChar *)XSLT_DEFAULT_VENDOR));
752 }
753 } else
754 #else
755 if (xmlStrEqual(name, (const xmlChar *)"vendor")) {
756 valuePush(ctxt, xmlXPathNewString(
757 (const xmlChar *)XSLT_DEFAULT_VENDOR));
758 } else
759 #endif
760 if (xmlStrEqual(name, (const xmlChar *)"version")) {
761 valuePush(ctxt, xmlXPathNewString(
762 (const xmlChar *)XSLT_DEFAULT_VERSION));
763 } else if (xmlStrEqual(name, (const xmlChar *)"vendor-url")) {
764 valuePush(ctxt, xmlXPathNewString(
765 (const xmlChar *)XSLT_DEFAULT_URL));
766 } else {
767 valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
768 }
769 } else {
770 valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
771 }
772 if (name != NULL)
773 xmlFree(name);
774 if (prefix != NULL)
775 xmlFree(prefix);
776 }
777 xmlXPathFreeObject(obj);
778 }
779
780 /**
781 * xsltElementAvailableFunction:
782 * @ctxt: the XPath Parser context
783 * @nargs: the number of arguments
784 *
785 * Implement the element-available() XSLT function
786 * boolean element-available(string)
787 */
788 void
789 xsltElementAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){
790 xmlXPathObjectPtr obj;
791 xmlChar *prefix, *name;
792 const xmlChar *nsURI = NULL;
793 xsltTransformContextPtr tctxt;
794
795 if (nargs != 1) {
796 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
797 "element-available() : expects one string arg\n");
798 ctxt->error = XPATH_INVALID_ARITY;
799 return;
800 }
801 xmlXPathStringFunction(ctxt, 1);
802 if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
803 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
804 "element-available() : invalid arg expecting a string\n");
805 ctxt->error = XPATH_INVALID_TYPE;
806 return;
807 }
808 obj = valuePop(ctxt);
809 tctxt = xsltXPathGetTransformContext(ctxt);
810 if (tctxt == NULL) {
811 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
812 "element-available() : internal error tctxt == NULL\n");
813 xmlXPathFreeObject(obj);
814 valuePush(ctxt, xmlXPathNewBoolean(0));
815 return;
816 }
817
818
819 name = xmlSplitQName2(obj->stringval, &prefix);
820 if (name == NULL) {
821 xmlNsPtr ns;
822
823 name = xmlStrdup(obj->stringval);
824 ns = xmlSearchNs(tctxt->inst->doc, tctxt->inst, NULL);
825 if (ns != NULL) nsURI = xmlStrdup(ns->href);
826 } else {
827 nsURI = xmlXPathNsLookup(ctxt->context, prefix);
828 if (nsURI == NULL) {
829 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
830 "element-available() : prefix %s is not bound\n", prefix);
831 }
832 }
833
834 if (xsltExtElementLookup(tctxt, name, nsURI) != NULL) {
835 valuePush(ctxt, xmlXPathNewBoolean(1));
836 } else {
837 valuePush(ctxt, xmlXPathNewBoolean(0));
838 }
839
840 xmlXPathFreeObject(obj);
841 if (name != NULL)
842 xmlFree(name);
843 if (prefix != NULL)
844 xmlFree(prefix);
845 }
846
847 /**
848 * xsltFunctionAvailableFunction:
849 * @ctxt: the XPath Parser context
850 * @nargs: the number of arguments
851 *
852 * Implement the function-available() XSLT function
853 * boolean function-available(string)
854 */
855 void
856 xsltFunctionAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){
857 xmlXPathObjectPtr obj;
858 xmlChar *prefix, *name;
859 const xmlChar *nsURI = NULL;
860
861 if (nargs != 1) {
862 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
863 "function-available() : expects one string arg\n");
864 ctxt->error = XPATH_INVALID_ARITY;
865 return;
866 }
867 xmlXPathStringFunction(ctxt, 1);
868 if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
869 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
870 "function-available() : invalid arg expecting a string\n");
871 ctxt->error = XPATH_INVALID_TYPE;
872 return;
873 }
874 obj = valuePop(ctxt);
875
876 name = xmlSplitQName2(obj->stringval, &prefix);
877 if (name == NULL) {
878 name = xmlStrdup(obj->stringval);
879 } else {
880 nsURI = xmlXPathNsLookup(ctxt->context, prefix);
881 if (nsURI == NULL) {
882 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
883 "function-available() : prefix %s is not bound\n", prefix);
884 }
885 }
886
887 if (xmlXPathFunctionLookupNS(ctxt->context, name, nsURI) != NULL) {
888 valuePush(ctxt, xmlXPathNewBoolean(1));
889 } else {
890 valuePush(ctxt, xmlXPathNewBoolean(0));
891 }
892
893 xmlXPathFreeObject(obj);
894 if (name != NULL)
895 xmlFree(name);
896 if (prefix != NULL)
897 xmlFree(prefix);
898 }
899
900 /**
901 * xsltCurrentFunction:
902 * @ctxt: the XPath Parser context
903 * @nargs: the number of arguments
904 *
905 * Implement the current() XSLT function
906 * node-set current()
907 */
908 static void
909 xsltCurrentFunction(xmlXPathParserContextPtr ctxt, int nargs){
910 xsltTransformContextPtr tctxt;
911
912 if (nargs != 0) {
913 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
914 "current() : function uses no argument\n");
915 ctxt->error = XPATH_INVALID_ARITY;
916 return;
917 }
918 tctxt = xsltXPathGetTransformContext(ctxt);
919 if (tctxt == NULL) {
920 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
921 "current() : internal error tctxt == NULL\n");
922 valuePush(ctxt, xmlXPathNewNodeSet(NULL));
923 } else {
924 valuePush(ctxt, xmlXPathNewNodeSet(tctxt->node)); /* current */
925 }
926 }
927
928 /************************************************************************
929 * *
930 * Registration of XSLT and libxslt functions *
931 * *
932 ************************************************************************/
933
934 /**
935 * xsltRegisterAllFunctions:
936 * @ctxt: the XPath context
937 *
938 * Registers all default XSLT functions in this context
939 */
940 void
941 xsltRegisterAllFunctions(xmlXPathContextPtr ctxt)
942 {
943 xmlXPathRegisterFunc(ctxt, (const xmlChar *) "current",
944 xsltCurrentFunction);
945 xmlXPathRegisterFunc(ctxt, (const xmlChar *) "document",
946 xsltDocumentFunction);
947 xmlXPathRegisterFunc(ctxt, (const xmlChar *) "key", xsltKeyFunction);
948 xmlXPathRegisterFunc(ctxt, (const xmlChar *) "unparsed-entity-uri",
949 xsltUnparsedEntityURIFunction);
950 xmlXPathRegisterFunc(ctxt, (const xmlChar *) "format-number",
951 xsltFormatNumberFunction);
952 xmlXPathRegisterFunc(ctxt, (const xmlChar *) "generate-id",
953 xsltGenerateIdFunction);
954 xmlXPathRegisterFunc(ctxt, (const xmlChar *) "system-property",
955 xsltSystemPropertyFunction);
956 xmlXPathRegisterFunc(ctxt, (const xmlChar *) "element-available",
957 xsltElementAvailableFunction);
958 xmlXPathRegisterFunc(ctxt, (const xmlChar *) "function-available",
959 xsltFunctionAvailableFunction);
960 }