1 #define IN_LIBEXSLT
2 #include "libexslt/libexslt.h"
3
4 #if defined(WIN32) && !defined (__CYGWIN__) && (!__MINGW32__)
5 #include <win32config.h>
6 #else
7 #include "config.h"
8 #endif
9
10 #include <libxml/tree.h>
11 #include <libxml/xpath.h>
12 #include <libxml/xpathInternals.h>
13 #include <libxml/parser.h>
14 #include <libxml/encoding.h>
15 #include <libxml/uri.h>
16
17 #include <libxslt/xsltconfig.h>
18 #include <libxslt/xsltutils.h>
19 #include <libxslt/xsltInternals.h>
20 #include <libxslt/extensions.h>
21
22 #include "exslt.h"
23
24 /**
25 * exsltStrTokenizeFunction:
26 * @ctxt: an XPath parser context
27 * @nargs: the number of arguments
28 *
29 * Splits up a string on the characters of the delimiter string and returns a
30 * node set of token elements, each containing one token from the string.
31 */
32 static void
33 exsltStrTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs)
34 {
35 xsltTransformContextPtr tctxt;
36 xmlChar *str, *delimiters, *cur;
37 const xmlChar *token, *delimiter;
38 xmlNodePtr node;
39 xmlDocPtr container;
40 xmlXPathObjectPtr ret = NULL;
41 int clen;
42
43 if ((nargs < 1) || (nargs > 2)) {
44 xmlXPathSetArityError(ctxt);
45 return;
46 }
47
48 if (nargs == 2) {
49 delimiters = xmlXPathPopString(ctxt);
50 if (xmlXPathCheckError(ctxt))
51 return;
52 } else {
53 delimiters = xmlStrdup((const xmlChar *) "\t\r\n ");
54 }
55 if (delimiters == NULL)
56 return;
57
58 str = xmlXPathPopString(ctxt);
59 if (xmlXPathCheckError(ctxt) || (str == NULL)) {
60 xmlFree(delimiters);
61 return;
62 }
63
64 /* Return a result tree fragment */
65 tctxt = xsltXPathGetTransformContext(ctxt);
66 if (tctxt == NULL) {
67 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
68 "exslt:tokenize : internal error tctxt == NULL\n");
69 goto fail;
70 }
71
72 container = xsltCreateRVT(tctxt);
73 if (container != NULL) {
74 xsltRegisterLocalRVT(tctxt, container);
75 ret = xmlXPathNewNodeSet(NULL);
76 if (ret != NULL) {
77 for (cur = str, token = str; *cur != 0; cur += clen) {
78 clen = xmlUTF8Size(cur);
79 if (*delimiters == 0) { /* empty string case */
80 xmlChar ctmp;
81 ctmp = *(cur+clen);
82 *(cur+clen) = 0;
83 node = xmlNewDocRawNode(container, NULL,
84 (const xmlChar *) "token", cur);
85 xmlAddChild((xmlNodePtr) container, node);
86 xmlXPathNodeSetAddUnique(ret->nodesetval, node);
87 *(cur+clen) = ctmp; /* restore the changed byte */
88 token = cur + clen;
89 } else for (delimiter = delimiters; *delimiter != 0;
90 delimiter += xmlUTF8Size(delimiter)) {
91 if (!xmlUTF8Charcmp(cur, delimiter)) {
92 if (cur == token) {
93 /* discard empty tokens */
94 token = cur + clen;
95 break;
96 }
97 *cur = 0; /* terminate the token */
98 node = xmlNewDocRawNode(container, NULL,
99 (const xmlChar *) "token", token);
100 xmlAddChild((xmlNodePtr) container, node);
101 xmlXPathNodeSetAddUnique(ret->nodesetval, node);
102 *cur = *delimiter; /* restore the changed byte */
103 token = cur + clen;
104 break;
105 }
106 }
107 }
108 if (token != cur) {
109 node = xmlNewDocRawNode(container, NULL,
110 (const xmlChar *) "token", token);
111 xmlAddChild((xmlNodePtr) container, node);
112 xmlXPathNodeSetAddUnique(ret->nodesetval, node);
113 }
114 /*
115 * Mark it as a function result in order to avoid garbage
116 * collecting of tree fragments
117 */
118 xsltExtensionInstructionResultRegister(tctxt, ret);
119 }
120 }
121
122 fail:
123 if (str != NULL)
124 xmlFree(str);
125 if (delimiters != NULL)
126 xmlFree(delimiters);
127 if (ret != NULL)
128 valuePush(ctxt, ret);
129 else
130 valuePush(ctxt, xmlXPathNewNodeSet(NULL));
131 }
132
133 /**
134 * exsltStrSplitFunction:
135 * @ctxt: an XPath parser context
136 * @nargs: the number of arguments
137 *
138 * Splits up a string on a delimiting string and returns a node set of token
139 * elements, each containing one token from the string.
140 */
141 static void
142 exsltStrSplitFunction(xmlXPathParserContextPtr ctxt, int nargs) {
143 xsltTransformContextPtr tctxt;
144 xmlChar *str, *delimiter, *cur;
145 const xmlChar *token;
146 xmlNodePtr node;
147 xmlDocPtr container;
148 xmlXPathObjectPtr ret = NULL;
149 int delimiterLength;
150
151 if ((nargs < 1) || (nargs > 2)) {
152 xmlXPathSetArityError(ctxt);
153 return;
154 }
155
156 if (nargs == 2) {
157 delimiter = xmlXPathPopString(ctxt);
158 if (xmlXPathCheckError(ctxt))
159 return;
160 } else {
161 delimiter = xmlStrdup((const xmlChar *) " ");
162 }
163 if (delimiter == NULL)
164 return;
165 delimiterLength = xmlStrlen (delimiter);
166
167 str = xmlXPathPopString(ctxt);
168 if (xmlXPathCheckError(ctxt) || (str == NULL)) {
169 xmlFree(delimiter);
170 return;
171 }
172
173 /* Return a result tree fragment */
174 tctxt = xsltXPathGetTransformContext(ctxt);
175 if (tctxt == NULL) {
176 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
177 "exslt:tokenize : internal error tctxt == NULL\n");
178 goto fail;
179 }
180
181 /*
182 * OPTIMIZE TODO: We are creating an xmlDoc for every split!
183 */
184 container = xsltCreateRVT(tctxt);
185 if (container != NULL) {
186 xsltRegisterLocalRVT(tctxt, container);
187 ret = xmlXPathNewNodeSet(NULL);
188 if (ret != NULL) {
189 for (cur = str, token = str; *cur != 0; cur++) {
190 if (delimiterLength == 0) {
191 if (cur != token) {
192 xmlChar tmp = *cur;
193 *cur = 0;
194 node = xmlNewDocRawNode(container, NULL,
195 (const xmlChar *) "token", token);
196 xmlAddChild((xmlNodePtr) container, node);
197 xmlXPathNodeSetAddUnique(ret->nodesetval, node);
198 *cur = tmp;
199 token++;
200 }
201 }
202 else if (!xmlStrncasecmp(cur, delimiter, delimiterLength)) {
203 if (cur == token) {
204 /* discard empty tokens */
205 cur = cur + delimiterLength - 1;
206 token = cur + 1;
207 continue;
208 }
209 *cur = 0;
210 node = xmlNewDocRawNode(container, NULL,
211 (const xmlChar *) "token", token);
212 xmlAddChild((xmlNodePtr) container, node);
213 xmlXPathNodeSetAddUnique(ret->nodesetval, node);
214 *cur = *delimiter;
215 cur = cur + delimiterLength - 1;
216 token = cur + 1;
217 }
218 }
219 if (token != cur) {
220 node = xmlNewDocRawNode(container, NULL,
221 (const xmlChar *) "token", token);
222 xmlAddChild((xmlNodePtr) container, node);
223 xmlXPathNodeSetAddUnique(ret->nodesetval, node);
224 }
225 /*
226 * Mark it as a function result in order to avoid garbage
227 * collecting of tree fragments
228 */
229 xsltExtensionInstructionResultRegister(tctxt, ret);
230 }
231 }
232
233 fail:
234 if (str != NULL)
235 xmlFree(str);
236 if (delimiter != NULL)
237 xmlFree(delimiter);
238 if (ret != NULL)
239 valuePush(ctxt, ret);
240 else
241 valuePush(ctxt, xmlXPathNewNodeSet(NULL));
242 }
243
244 /**
245 * exsltStrEncodeUriFunction:
246 * @ctxt: an XPath parser context
247 * @nargs: the number of arguments
248 *
249 * URI-Escapes a string
250 */
251 static void
252 exsltStrEncodeUriFunction (xmlXPathParserContextPtr ctxt, int nargs) {
253 int escape_all = 1, str_len = 0;
254 xmlChar *str = NULL, *ret = NULL, *tmp;
255
256 if ((nargs < 2) || (nargs > 3)) {
257 xmlXPathSetArityError(ctxt);
258 return;
259 }
260
261 if (nargs >= 3) {
262 /* check for UTF-8 if encoding was explicitly given;
263 we don't support anything else yet */
264 tmp = xmlXPathPopString(ctxt);
265 if (xmlUTF8Strlen(tmp) != 5 || xmlStrcmp((const xmlChar *)"UTF-8",tmp)) {
266 xmlXPathReturnEmptyString(ctxt);
267 xmlFree(tmp);
268 return;
269 }
270 xmlFree(tmp);
271 }
272
273 escape_all = xmlXPathPopBoolean(ctxt);
274
275 str = xmlXPathPopString(ctxt);
276 str_len = xmlUTF8Strlen(str);
277
278 if (str_len == 0) {
279 xmlXPathReturnEmptyString(ctxt);
280 xmlFree(str);
281 return;
282 }
283
284 ret = xmlURIEscapeStr(str,(const xmlChar *)(escape_all?"-_.!~*'()":"-_.!~*'();/?:@&=+$,[]"));
285 xmlXPathReturnString(ctxt, ret);
286
287 if (str != NULL)
288 xmlFree(str);
289 }
290
291 /**
292 * exsltStrDecodeUriFunction:
293 * @ctxt: an XPath parser context
294 * @nargs: the number of arguments
295 *
296 * reverses URI-Escaping of a string
297 */
298 static void
299 exsltStrDecodeUriFunction (xmlXPathParserContextPtr ctxt, int nargs) {
300 int str_len = 0;
301 xmlChar *str = NULL, *ret = NULL, *tmp;
302
303 if ((nargs < 1) || (nargs > 2)) {
304 xmlXPathSetArityError(ctxt);
305 return;
306 }
307
308 if (nargs >= 2) {
309 /* check for UTF-8 if encoding was explicitly given;
310 we don't support anything else yet */
311 tmp = xmlXPathPopString(ctxt);
312 if (xmlUTF8Strlen(tmp) != 5 || xmlStrcmp((const xmlChar *)"UTF-8",tmp)) {
313 xmlXPathReturnEmptyString(ctxt);
314 xmlFree(tmp);
315 return;
316 }
317 xmlFree(tmp);
318 }
319
320 str = xmlXPathPopString(ctxt);
321 str_len = xmlUTF8Strlen(str);
322
323 if (str_len == 0) {
324 xmlXPathReturnEmptyString(ctxt);
325 xmlFree(str);
326 return;
327 }
328
329 ret = (xmlChar *) xmlURIUnescapeString((const char *)str,0,NULL);
330 if (!xmlCheckUTF8(ret)) {
331 /* FIXME: instead of throwing away the whole URI, we should
332 only discard the invalid sequence(s). How to do that? */
333 xmlXPathReturnEmptyString(ctxt);
334 xmlFree(str);
335 xmlFree(ret);
336 return;
337 }
338
339 xmlXPathReturnString(ctxt, ret);
340
341 if (str != NULL)
342 xmlFree(str);
343 }
344
345 /**
346 * exsltStrPaddingFunction:
347 * @ctxt: an XPath parser context
348 * @nargs: the number of arguments
349 *
350 * Creates a padding string of a certain length.
351 */
352 static void
353 exsltStrPaddingFunction (xmlXPathParserContextPtr ctxt, int nargs) {
354 int number, str_len = 0;
355 xmlChar *str = NULL, *ret = NULL, *tmp;
356
357 if ((nargs < 1) || (nargs > 2)) {
358 xmlXPathSetArityError(ctxt);
359 return;
360 }
361
362 if (nargs == 2) {
363 str = xmlXPathPopString(ctxt);
364 str_len = xmlUTF8Strlen(str);
365 }
366 if (str_len == 0) {
367 if (str != NULL) xmlFree(str);
368 str = xmlStrdup((const xmlChar *) " ");
369 str_len = 1;
370 }
371
372 number = (int) xmlXPathPopNumber(ctxt);
373
374 if (number <= 0) {
375 xmlXPathReturnEmptyString(ctxt);
376 xmlFree(str);
377 return;
378 }
379
380 while (number >= str_len) {
381 ret = xmlStrncat(ret, str, str_len);
382 number -= str_len;
383 }
384 tmp = xmlUTF8Strndup (str, number);
385 ret = xmlStrcat(ret, tmp);
386 if (tmp != NULL)
387 xmlFree (tmp);
388
389 xmlXPathReturnString(ctxt, ret);
390
391 if (str != NULL)
392 xmlFree(str);
393 }
394
395 /**
396 * exsltStrAlignFunction:
397 * @ctxt: an XPath parser context
398 * @nargs: the number of arguments
399 *
400 * Aligns a string within another string.
401 */
402 static void
403 exsltStrAlignFunction (xmlXPathParserContextPtr ctxt, int nargs) {
404 xmlChar *str, *padding, *alignment, *ret;
405 int str_l, padding_l;
406
407 if ((nargs < 2) || (nargs > 3)) {
408 xmlXPathSetArityError(ctxt);
409 return;
410 }
411
412 if (nargs == 3)
413 alignment = xmlXPathPopString(ctxt);
414 else
415 alignment = NULL;
416
417 padding = xmlXPathPopString(ctxt);
418 str = xmlXPathPopString(ctxt);
419
420 str_l = xmlUTF8Strlen (str);
421 padding_l = xmlUTF8Strlen (padding);
422
423 if (str_l == padding_l) {
424 xmlXPathReturnString (ctxt, str);
425 xmlFree(padding);
426 xmlFree(alignment);
427 return;
428 }
429
430 if (str_l > padding_l) {
431 ret = xmlUTF8Strndup (str, padding_l);
432 } else {
433 if (xmlStrEqual(alignment, (const xmlChar *) "right")) {
434 ret = xmlUTF8Strndup (padding, padding_l - str_l);
435 ret = xmlStrcat (ret, str);
436 } else if (xmlStrEqual(alignment, (const xmlChar *) "center")) {
437 int left = (padding_l - str_l) / 2;
438 int right_start;
439
440 ret = xmlUTF8Strndup (padding, left);
441 ret = xmlStrcat (ret, str);
442
443 right_start = xmlUTF8Strsize (padding, left + str_l);
444 ret = xmlStrcat (ret, padding + right_start);
445 } else {
446 int str_s;
447
448 str_s = xmlStrlen (str);
449 ret = xmlStrdup (str);
450 ret = xmlStrcat (ret, padding + str_s);
451 }
452 }
453
454 xmlXPathReturnString (ctxt, ret);
455
456 xmlFree(str);
457 xmlFree(padding);
458 xmlFree(alignment);
459 }
460
461 /**
462 * exsltStrConcatFunction:
463 * @ctxt: an XPath parser context
464 * @nargs: the number of arguments
465 *
466 * Takes a node set and returns the concatenation of the string values
467 * of the nodes in that node set. If the node set is empty, it
468 * returns an empty string.
469 */
470 static void
471 exsltStrConcatFunction (xmlXPathParserContextPtr ctxt, int nargs) {
472 xmlXPathObjectPtr obj;
473 xmlChar *ret = NULL;
474 int i;
475
476 if (nargs != 1) {
477 xmlXPathSetArityError(ctxt);
478 return;
479 }
480
481 if (!xmlXPathStackIsNodeSet(ctxt)) {
482 xmlXPathSetTypeError(ctxt);
483 return;
484 }
485
486 obj = valuePop (ctxt);
487
488 if (xmlXPathNodeSetIsEmpty(obj->nodesetval)) {
489 xmlXPathReturnEmptyString(ctxt);
490 return;
491 }
492
493 for (i = 0; i < obj->nodesetval->nodeNr; i++) {
494 xmlChar *tmp;
495 tmp = xmlXPathCastNodeToString(obj->nodesetval->nodeTab[i]);
496
497 ret = xmlStrcat (ret, tmp);
498
499 xmlFree(tmp);
500 }
501
502 xmlXPathFreeObject (obj);
503
504 xmlXPathReturnString(ctxt, ret);
505 }
506
507 /**
508 * exsltStrReturnString:
509 * @ctxt: an XPath parser context
510 * @str: a string
511 * @len: length of string
512 *
513 * Returns a string as a node set.
514 */
515 static int
516 exsltStrReturnString(xmlXPathParserContextPtr ctxt, const xmlChar *str,
517 int len)
518 {
519 xsltTransformContextPtr tctxt = xsltXPathGetTransformContext(ctxt);
520 xmlDocPtr container;
521 xmlNodePtr text_node;
522 xmlXPathObjectPtr ret;
523
524 container = xsltCreateRVT(tctxt);
525 if (container == NULL) {
526 xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
527 return(-1);
528 }
529 xsltRegisterLocalRVT(tctxt, container);
530
531 text_node = xmlNewTextLen(str, len);
532 if (text_node == NULL) {
533 xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
534 return(-1);
535 }
536 xmlAddChild((xmlNodePtr) container, text_node);
537
538 ret = xmlXPathNewNodeSet(text_node);
539 if (ret == NULL) {
540 xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
541 return(-1);
542 }
543
544 xsltExtensionInstructionResultRegister(tctxt, ret);
545 valuePush(ctxt, ret);
546
547 return(0);
548 }
549
550 /**
551 * exsltStrReplaceFunction:
552 * @ctxt: an XPath parser context
553 * @nargs: the number of arguments
554 *
555 * Takes a string, and two node sets and returns the string with all strings in
556 * the first node set replaced by all strings in the second node set.
557 */
558 static void
559 exsltStrReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs) {
560 int i, i_empty, n, slen0, rlen0, *slen, *rlen;
561 void *mem = NULL;
562 const xmlChar *src, *start;
563 xmlChar *string, *search_str = NULL, *replace_str = NULL;
564 xmlChar **search, **replace;
565 xmlNodeSetPtr search_set = NULL, replace_set = NULL;
566 xmlBufferPtr buf;
567
568 if (nargs != 3) {
569 xmlXPathSetArityError(ctxt);
570 return;
571 }
572
573 /* get replace argument */
574
575 if (!xmlXPathStackIsNodeSet(ctxt))
576 replace_str = xmlXPathPopString(ctxt);
577 else
578 replace_set = xmlXPathPopNodeSet(ctxt);
579
580 if (xmlXPathCheckError(ctxt))
581 goto fail_replace;
582
583 /* get search argument */
584
585 if (!xmlXPathStackIsNodeSet(ctxt)) {
586 search_str = xmlXPathPopString(ctxt);
587 n = 1;
588 }
589 else {
590 search_set = xmlXPathPopNodeSet(ctxt);
591 n = search_set != NULL ? search_set->nodeNr : 0;
592 }
593
594 if (xmlXPathCheckError(ctxt))
595 goto fail_search;
596
597 /* get string argument */
598
599 string = xmlXPathPopString(ctxt);
600 if (xmlXPathCheckError(ctxt))
601 goto fail_string;
602
603 /* check for empty search node list */
604
605 if (n <= 0) {
606 exsltStrReturnString(ctxt, string, xmlStrlen(string));
607 goto done_empty_search;
608 }
609
610 /* allocate memory for string pointer and length arrays */
611
612 if (n == 1) {
613 search = &search_str;
614 replace = &replace_str;
615 slen = &slen0;
616 rlen = &rlen0;
617 }
618 else {
619 mem = xmlMalloc(2 * n * (sizeof(const xmlChar *) + sizeof(int)));
620 if (mem == NULL) {
621 xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
622 goto fail_malloc;
623 }
624 search = (xmlChar **) mem;
625 replace = search + n;
626 slen = (int *) (replace + n);
627 rlen = slen + n;
628 }
629
630 /* process arguments */
631
632 i_empty = -1;
633
634 for (i=0; i<n; ++i) {
635 if (search_set != NULL) {
636 search[i] = xmlXPathCastNodeToString(search_set->nodeTab[i]);
637 if (search[i] == NULL) {
638 n = i;
639 goto fail_process_args;
640 }
641 }
642
643 slen[i] = xmlStrlen(search[i]);
644 if (i_empty < 0 && slen[i] == 0)
645 i_empty = i;
646
647 if (replace_set != NULL) {
648 if (i < replace_set->nodeNr) {
649 replace[i] = xmlXPathCastNodeToString(replace_set->nodeTab[i]);
650 if (replace[i] == NULL) {
651 n = i + 1;
652 goto fail_process_args;
653 }
654 }
655 else
656 replace[i] = NULL;
657 }
658 else {
659 if (i == 0)
660 replace[i] = replace_str;
661 else
662 replace[i] = NULL;
663 }
664
665 if (replace[i] == NULL)
666 rlen[i] = 0;
667 else
668 rlen[i] = xmlStrlen(replace[i]);
669 }
670
671 if (i_empty >= 0 && rlen[i_empty] == 0)
672 i_empty = -1;
673
674 /* replace operation */
675
676 buf = xmlBufferCreate();
677 if (buf == NULL) {
678 xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
679 goto fail_buffer;
680 }
681 src = string;
682 start = string;
683
684 while (*src != 0) {
685 int max_len = 0, i_match = 0;
686
687 for (i=0; i<n; ++i) {
688 if (*src == search[i][0] &&
689 slen[i] > max_len &&
690 xmlStrncmp(src, search[i], slen[i]) == 0)
691 {
692 i_match = i;
693 max_len = slen[i];
694 }
695 }
696
697 if (max_len == 0) {
698 if (i_empty >= 0 && start < src) {
699 if (xmlBufferAdd(buf, start, src - start) ||
700 xmlBufferAdd(buf, replace[i_empty], rlen[i_empty]))
701 {
702 xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
703 goto fail_buffer_add;
704 }
705 start = src;
706 }
707
708 src += xmlUTF8Size(src);
709 }
710 else {
711 if ((start < src &&
712 xmlBufferAdd(buf, start, src - start)) ||
713 (rlen[i_match] &&
714 xmlBufferAdd(buf, replace[i_match], rlen[i_match])))
715 {
716 xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
717 goto fail_buffer_add;
718 }
719
720 src += slen[i_match];
721 start = src;
722 }
723 }
724
725 if (start < src && xmlBufferAdd(buf, start, src - start)) {
726 xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
727 goto fail_buffer_add;
728 }
729
730 /* create result node set */
731
732 exsltStrReturnString(ctxt, xmlBufferContent(buf), xmlBufferLength(buf));
733
734 /* clean up */
735
736 fail_buffer_add:
737 xmlBufferFree(buf);
738
739 fail_buffer:
740 fail_process_args:
741 if (search_set != NULL) {
742 for (i=0; i<n; ++i)
743 xmlFree(search[i]);
744 }
745 if (replace_set != NULL) {
746 for (i=0; i<n; ++i) {
747 if (replace[i] != NULL)
748 xmlFree(replace[i]);
749 }
750 }
751
752 if (mem != NULL)
753 xmlFree(mem);
754
755 fail_malloc:
756 done_empty_search:
757 xmlFree(string);
758
759 fail_string:
760 if (search_set != NULL)
761 xmlXPathFreeNodeSet(search_set);
762 else
763 xmlFree(search_str);
764
765 fail_search:
766 if (replace_set != NULL)
767 xmlXPathFreeNodeSet(replace_set);
768 else
769 xmlFree(replace_str);
770
771 fail_replace:
772 return;
773 }
774
775 /**
776 * exsltStrRegister:
777 *
778 * Registers the EXSLT - Strings module
779 */
780
781 void
782 exsltStrRegister (void) {
783 xsltRegisterExtModuleFunction ((const xmlChar *) "tokenize",
784 EXSLT_STRINGS_NAMESPACE,
785 exsltStrTokenizeFunction);
786 xsltRegisterExtModuleFunction ((const xmlChar *) "split",
787 EXSLT_STRINGS_NAMESPACE,
788 exsltStrSplitFunction);
789 xsltRegisterExtModuleFunction ((const xmlChar *) "encode-uri",
790 EXSLT_STRINGS_NAMESPACE,
791 exsltStrEncodeUriFunction);
792 xsltRegisterExtModuleFunction ((const xmlChar *) "decode-uri",
793 EXSLT_STRINGS_NAMESPACE,
794 exsltStrDecodeUriFunction);
795 xsltRegisterExtModuleFunction ((const xmlChar *) "padding",
796 EXSLT_STRINGS_NAMESPACE,
797 exsltStrPaddingFunction);
798 xsltRegisterExtModuleFunction ((const xmlChar *) "align",
799 EXSLT_STRINGS_NAMESPACE,
800 exsltStrAlignFunction);
801 xsltRegisterExtModuleFunction ((const xmlChar *) "concat",
802 EXSLT_STRINGS_NAMESPACE,
803 exsltStrConcatFunction);
804 xsltRegisterExtModuleFunction ((const xmlChar *) "replace",
805 EXSLT_STRINGS_NAMESPACE,
806 exsltStrReplaceFunction);
807 }
808
809 /**
810 * exsltStrXpathCtxtRegister:
811 *
812 * Registers the EXSLT - Strings module for use outside XSLT
813 */
814 int
815 exsltStrXpathCtxtRegister (xmlXPathContextPtr ctxt, const xmlChar *prefix)
816 {
817 if (ctxt
818 && prefix
819 && !xmlXPathRegisterNs(ctxt,
820 prefix,
821 (const xmlChar *) EXSLT_STRINGS_NAMESPACE)
822 && !xmlXPathRegisterFuncNS(ctxt,
823 (const xmlChar *) "encode-uri",
824 (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
825 exsltStrEncodeUriFunction)
826 && !xmlXPathRegisterFuncNS(ctxt,
827 (const xmlChar *) "decode-uri",
828 (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
829 exsltStrDecodeUriFunction)
830 && !xmlXPathRegisterFuncNS(ctxt,
831 (const xmlChar *) "padding",
832 (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
833 exsltStrPaddingFunction)
834 && !xmlXPathRegisterFuncNS(ctxt,
835 (const xmlChar *) "align",
836 (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
837 exsltStrAlignFunction)
838 && !xmlXPathRegisterFuncNS(ctxt,
839 (const xmlChar *) "concat",
840 (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
841 exsltStrConcatFunction)
842 && !xmlXPathRegisterFuncNS(ctxt,
843 (const xmlChar *) "replace",
844 (const xmlChar *) EXSLT_STRINGS_NAMESPACE,
845 exsltStrReplaceFunction)) {
846 return 0;
847 }
848 return -1;
849 }