xref: /reactos/dll/3rdparty/libxslt/functions.c (revision bae2bac6) 
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 = NULL;
579     xmlChar *result;
580     const xmlChar *ncname;
581     const xmlChar *prefix = NULL;
582     const xmlChar *nsUri = NULL;
583     xsltTransformContextPtr tctxt;
584 
585     tctxt = xsltXPathGetTransformContext(ctxt);
586     if ((tctxt == NULL) || (tctxt->inst == NULL))
587 	return;
588     sheet = tctxt->style;
589     if (sheet == NULL)
590 	return;
591     formatValues = sheet->decimalFormat;
592 
593     switch (nargs) {
594     case 3:
595 	CAST_TO_STRING;
596 	decimalObj = valuePop(ctxt);
597         ncname = xsltSplitQName(sheet->dict, decimalObj->stringval, &prefix);
598         if (prefix != NULL) {
599             xmlNsPtr ns = xmlSearchNs(tctxt->inst->doc, tctxt->inst, prefix);
600             if (ns == NULL) {
601                 xsltTransformError(tctxt, NULL, NULL,
602                     "format-number : No namespace found for QName '%s:%s'\n",
603                     prefix, ncname);
604                 sheet->errors++;
605                 ncname = NULL;
606             }
607             else {
608                 nsUri = ns->href;
609             }
610         }
611         if (ncname != NULL) {
612 	    formatValues = xsltDecimalFormatGetByQName(sheet, nsUri, ncname);
613         }
614 	if (formatValues == NULL) {
615 	    xsltTransformError(tctxt, NULL, NULL,
616 		    "format-number() : undeclared decimal format '%s'\n",
617 		    decimalObj->stringval);
618 	}
619 	/* Intentional fall-through */
620     case 2:
621 	CAST_TO_STRING;
622 	formatObj = valuePop(ctxt);
623 	CAST_TO_NUMBER;
624 	numberObj = valuePop(ctxt);
625 	break;
626     default:
627 	XP_ERROR(XPATH_INVALID_ARITY);
628     }
629 
630     if (formatValues != NULL) {
631 	if (xsltFormatNumberConversion(formatValues,
632 				       formatObj->stringval,
633 				       numberObj->floatval,
634 				       &result) == XPATH_EXPRESSION_OK) {
635 	    valuePush(ctxt, xmlXPathNewString(result));
636 	    xmlFree(result);
637 	}
638     }
639 
640     xmlXPathFreeObject(numberObj);
641     xmlXPathFreeObject(formatObj);
642     xmlXPathFreeObject(decimalObj);
643 }
644 
645 /**
646  * xsltGenerateIdFunction:
647  * @ctxt:  the XPath Parser context
648  * @nargs:  the number of arguments
649  *
650  * Implement the generate-id() XSLT function
651  *   string generate-id(node-set?)
652  */
653 void
654 xsltGenerateIdFunction(xmlXPathParserContextPtr ctxt, int nargs){
655     static char base_address;
656     xmlNodePtr cur = NULL;
657     xmlXPathObjectPtr obj = NULL;
658     long val;
659     xmlChar str[30];
660 
661     if (nargs == 0) {
662 	cur = ctxt->context->node;
663     } else if (nargs == 1) {
664 	xmlNodeSetPtr nodelist;
665 	int i, ret;
666 
667 	if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_NODESET)) {
668 	    ctxt->error = XPATH_INVALID_TYPE;
669 	    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
670 		"generate-id() : invalid arg expecting a node-set\n");
671 	    return;
672 	}
673 	obj = valuePop(ctxt);
674 	nodelist = obj->nodesetval;
675 	if ((nodelist == NULL) || (nodelist->nodeNr <= 0)) {
676 	    xmlXPathFreeObject(obj);
677 	    valuePush(ctxt, xmlXPathNewCString(""));
678 	    return;
679 	}
680 	cur = nodelist->nodeTab[0];
681 	for (i = 1;i < nodelist->nodeNr;i++) {
682 	    ret = xmlXPathCmpNodes(cur, nodelist->nodeTab[i]);
683 	    if (ret == -1)
684 	        cur = nodelist->nodeTab[i];
685 	}
686     } else {
687 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
688 		"generate-id() : invalid number of args %d\n", nargs);
689 	ctxt->error = XPATH_INVALID_ARITY;
690 	return;
691     }
692 
693     if (obj)
694         xmlXPathFreeObject(obj);
695 
696     val = (long)((char *)cur - (char *)&base_address);
697     if (val >= 0) {
698       snprintf((char *)str, sizeof(str), "idp%ld", val);
699     } else {
700       snprintf((char *)str, sizeof(str), "idm%ld", -val);
701     }
702     valuePush(ctxt, xmlXPathNewString(str));
703 }
704 
705 /**
706  * xsltSystemPropertyFunction:
707  * @ctxt:  the XPath Parser context
708  * @nargs:  the number of arguments
709  *
710  * Implement the system-property() XSLT function
711  *   object system-property(string)
712  */
713 void
714 xsltSystemPropertyFunction(xmlXPathParserContextPtr ctxt, int nargs){
715     xmlXPathObjectPtr obj;
716     xmlChar *prefix, *name;
717     const xmlChar *nsURI = NULL;
718 
719     if (nargs != 1) {
720 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
721 		"system-property() : expects one string arg\n");
722 	ctxt->error = XPATH_INVALID_ARITY;
723 	return;
724     }
725     if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
726 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
727 	    "system-property() : invalid arg expecting a string\n");
728 	ctxt->error = XPATH_INVALID_TYPE;
729 	return;
730     }
731     obj = valuePop(ctxt);
732     if (obj->stringval == NULL) {
733 	valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
734     } else {
735 	name = xmlSplitQName2(obj->stringval, &prefix);
736 	if (name == NULL) {
737 	    name = xmlStrdup(obj->stringval);
738 	} else {
739 	    nsURI = xmlXPathNsLookup(ctxt->context, prefix);
740 	    if (nsURI == NULL) {
741 		xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
742 		    "system-property() : prefix %s is not bound\n", prefix);
743 	    }
744 	}
745 
746 	if (xmlStrEqual(nsURI, XSLT_NAMESPACE)) {
747 #ifdef DOCBOOK_XSL_HACK
748 	    if (xmlStrEqual(name, (const xmlChar *)"vendor")) {
749 		xsltStylesheetPtr sheet;
750 		xsltTransformContextPtr tctxt;
751 
752 		tctxt = xsltXPathGetTransformContext(ctxt);
753 		if ((tctxt != NULL) && (tctxt->inst != NULL) &&
754 		    (xmlStrEqual(tctxt->inst->name, BAD_CAST "variable")) &&
755 		    (tctxt->inst->parent != NULL) &&
756 		    (xmlStrEqual(tctxt->inst->parent->name,
757 				 BAD_CAST "template")))
758 		    sheet = tctxt->style;
759 		else
760 		    sheet = NULL;
761 		if ((sheet != NULL) && (sheet->doc != NULL) &&
762 		    (sheet->doc->URL != NULL) &&
763 		    (xmlStrstr(sheet->doc->URL,
764 			       (const xmlChar *)"chunk") != NULL)) {
765 		    valuePush(ctxt, xmlXPathNewString(
766 			(const xmlChar *)"libxslt (SAXON 6.2 compatible)"));
767 
768 		} else {
769 		    valuePush(ctxt, xmlXPathNewString(
770 			(const xmlChar *)XSLT_DEFAULT_VENDOR));
771 		}
772 	    } else
773 #else
774 	    if (xmlStrEqual(name, (const xmlChar *)"vendor")) {
775 		valuePush(ctxt, xmlXPathNewString(
776 			  (const xmlChar *)XSLT_DEFAULT_VENDOR));
777 	    } else
778 #endif
779 	    if (xmlStrEqual(name, (const xmlChar *)"version")) {
780 		valuePush(ctxt, xmlXPathNewString(
781 		    (const xmlChar *)XSLT_DEFAULT_VERSION));
782 	    } else if (xmlStrEqual(name, (const xmlChar *)"vendor-url")) {
783 		valuePush(ctxt, xmlXPathNewString(
784 		    (const xmlChar *)XSLT_DEFAULT_URL));
785 	    } else {
786 		valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
787 	    }
788 	} else {
789 	    valuePush(ctxt, xmlXPathNewString((const xmlChar *)""));
790         }
791 	if (name != NULL)
792 	    xmlFree(name);
793 	if (prefix != NULL)
794 	    xmlFree(prefix);
795     }
796     xmlXPathFreeObject(obj);
797 }
798 
799 /**
800  * xsltElementAvailableFunction:
801  * @ctxt:  the XPath Parser context
802  * @nargs:  the number of arguments
803  *
804  * Implement the element-available() XSLT function
805  *   boolean element-available(string)
806  */
807 void
808 xsltElementAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){
809     xmlXPathObjectPtr obj;
810     xmlChar *prefix, *name;
811     const xmlChar *nsURI = NULL;
812     xsltTransformContextPtr tctxt;
813 
814     if (nargs != 1) {
815 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
816 		"element-available() : expects one string arg\n");
817 	ctxt->error = XPATH_INVALID_ARITY;
818 	return;
819     }
820     xmlXPathStringFunction(ctxt, 1);
821     if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
822 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
823 	    "element-available() : invalid arg expecting a string\n");
824 	ctxt->error = XPATH_INVALID_TYPE;
825 	return;
826     }
827     obj = valuePop(ctxt);
828     tctxt = xsltXPathGetTransformContext(ctxt);
829     if ((tctxt == NULL) || (tctxt->inst == NULL)) {
830 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
831 		"element-available() : internal error tctxt == NULL\n");
832 	xmlXPathFreeObject(obj);
833 	valuePush(ctxt, xmlXPathNewBoolean(0));
834 	return;
835     }
836 
837 
838     name = xmlSplitQName2(obj->stringval, &prefix);
839     if (name == NULL) {
840 	xmlNsPtr ns;
841 
842 	name = xmlStrdup(obj->stringval);
843 	ns = xmlSearchNs(tctxt->inst->doc, tctxt->inst, NULL);
844 	if (ns != NULL) nsURI = ns->href;
845     } else {
846 	nsURI = xmlXPathNsLookup(ctxt->context, prefix);
847 	if (nsURI == NULL) {
848 	    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
849 		"element-available() : prefix %s is not bound\n", prefix);
850 	}
851     }
852 
853     if (xsltExtElementLookup(tctxt, name, nsURI) != NULL) {
854 	valuePush(ctxt, xmlXPathNewBoolean(1));
855     } else {
856 	valuePush(ctxt, xmlXPathNewBoolean(0));
857     }
858 
859     xmlXPathFreeObject(obj);
860     if (name != NULL)
861 	xmlFree(name);
862     if (prefix != NULL)
863 	xmlFree(prefix);
864 }
865 
866 /**
867  * xsltFunctionAvailableFunction:
868  * @ctxt:  the XPath Parser context
869  * @nargs:  the number of arguments
870  *
871  * Implement the function-available() XSLT function
872  *   boolean function-available(string)
873  */
874 void
875 xsltFunctionAvailableFunction(xmlXPathParserContextPtr ctxt, int nargs){
876     xmlXPathObjectPtr obj;
877     xmlChar *prefix, *name;
878     const xmlChar *nsURI = NULL;
879 
880     if (nargs != 1) {
881 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
882 		"function-available() : expects one string arg\n");
883 	ctxt->error = XPATH_INVALID_ARITY;
884 	return;
885     }
886     xmlXPathStringFunction(ctxt, 1);
887     if ((ctxt->value == NULL) || (ctxt->value->type != XPATH_STRING)) {
888 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
889 	    "function-available() : invalid arg expecting a string\n");
890 	ctxt->error = XPATH_INVALID_TYPE;
891 	return;
892     }
893     obj = valuePop(ctxt);
894 
895     name = xmlSplitQName2(obj->stringval, &prefix);
896     if (name == NULL) {
897 	name = xmlStrdup(obj->stringval);
898     } else {
899 	nsURI = xmlXPathNsLookup(ctxt->context, prefix);
900 	if (nsURI == NULL) {
901 	    xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
902 		"function-available() : prefix %s is not bound\n", prefix);
903 	}
904     }
905 
906     if (xmlXPathFunctionLookupNS(ctxt->context, name, nsURI) != NULL) {
907 	valuePush(ctxt, xmlXPathNewBoolean(1));
908     } else {
909 	valuePush(ctxt, xmlXPathNewBoolean(0));
910     }
911 
912     xmlXPathFreeObject(obj);
913     if (name != NULL)
914 	xmlFree(name);
915     if (prefix != NULL)
916 	xmlFree(prefix);
917 }
918 
919 /**
920  * xsltCurrentFunction:
921  * @ctxt:  the XPath Parser context
922  * @nargs:  the number of arguments
923  *
924  * Implement the current() XSLT function
925  *   node-set current()
926  */
927 static void
928 xsltCurrentFunction(xmlXPathParserContextPtr ctxt, int nargs){
929     xsltTransformContextPtr tctxt;
930 
931     if (nargs != 0) {
932 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
933 		"current() : function uses no argument\n");
934 	ctxt->error = XPATH_INVALID_ARITY;
935 	return;
936     }
937     tctxt = xsltXPathGetTransformContext(ctxt);
938     if (tctxt == NULL) {
939 	xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
940 		"current() : internal error tctxt == NULL\n");
941 	valuePush(ctxt, xmlXPathNewNodeSet(NULL));
942     } else {
943 	valuePush(ctxt, xmlXPathNewNodeSet(tctxt->node)); /* current */
944     }
945 }
946 
947 /************************************************************************
948  *									*
949  *		Registration of XSLT and libxslt functions		*
950  *									*
951  ************************************************************************/
952 
953 /**
954  * xsltRegisterAllFunctions:
955  * @ctxt:  the XPath context
956  *
957  * Registers all default XSLT functions in this context
958  */
959 void
960 xsltRegisterAllFunctions(xmlXPathContextPtr ctxt)
961 {
962     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "current",
963                          xsltCurrentFunction);
964     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "document",
965                          xsltDocumentFunction);
966     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "key", xsltKeyFunction);
967     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "unparsed-entity-uri",
968                          xsltUnparsedEntityURIFunction);
969     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "format-number",
970                          xsltFormatNumberFunction);
971     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "generate-id",
972                          xsltGenerateIdFunction);
973     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "system-property",
974                          xsltSystemPropertyFunction);
975     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "element-available",
976                          xsltElementAvailableFunction);
977     xmlXPathRegisterFunc(ctxt, (const xmlChar *) "function-available",
978                          xsltFunctionAvailableFunction);
979 }
980