1 /*
2 * extensions.c: Implemetation of the extensions support
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 */
11
12 #define IN_LIBXSLT
13 #include "libxslt.h"
14
15 #include <string.h>
16 #include <limits.h>
17
18 #include <libxml/xmlmemory.h>
19 #include <libxml/tree.h>
20 #include <libxml/hash.h>
21 #include <libxml/xmlerror.h>
22 #include <libxml/parserInternals.h>
23 #include <libxml/xpathInternals.h>
24 #ifdef WITH_MODULES
25 #include <libxml/xmlmodule.h>
26 #endif
27 #include <libxml/list.h>
28 #include <libxml/xmlIO.h>
29 #include "xslt.h"
30 #include "xsltInternals.h"
31 #include "xsltutils.h"
32 #include "imports.h"
33 #include "extensions.h"
34
35 #ifdef _WIN32
36 #include <stdlib.h> /* for _MAX_PATH */
37 #ifndef PATH_MAX
38 #define PATH_MAX _MAX_PATH
39 #endif
40 #endif
41
42 #ifdef WITH_XSLT_DEBUG
43 #define WITH_XSLT_DEBUG_EXTENSIONS
44 #endif
45
46 /************************************************************************
47 * *
48 * Private Types and Globals *
49 * *
50 ************************************************************************/
51
52 typedef struct _xsltExtDef xsltExtDef;
53 typedef xsltExtDef *xsltExtDefPtr;
54 struct _xsltExtDef {
55 struct _xsltExtDef *next;
56 xmlChar *prefix;
57 xmlChar *URI;
58 void *data;
59 };
60
61 typedef struct _xsltExtModule xsltExtModule;
62 typedef xsltExtModule *xsltExtModulePtr;
63 struct _xsltExtModule {
64 xsltExtInitFunction initFunc;
65 xsltExtShutdownFunction shutdownFunc;
66 xsltStyleExtInitFunction styleInitFunc;
67 xsltStyleExtShutdownFunction styleShutdownFunc;
68 };
69
70 typedef struct _xsltExtData xsltExtData;
71 typedef xsltExtData *xsltExtDataPtr;
72 struct _xsltExtData {
73 xsltExtModulePtr extModule;
74 void *extData;
75 };
76
77 typedef struct _xsltExtElement xsltExtElement;
78 typedef xsltExtElement *xsltExtElementPtr;
79 struct _xsltExtElement {
80 xsltPreComputeFunction precomp;
81 xsltTransformFunction transform;
82 };
83
84 static xmlHashTablePtr xsltExtensionsHash = NULL;
85 static xmlHashTablePtr xsltFunctionsHash = NULL;
86 static xmlHashTablePtr xsltElementsHash = NULL;
87 static xmlHashTablePtr xsltTopLevelsHash = NULL;
88 static xmlHashTablePtr xsltModuleHash = NULL;
89 static xmlMutexPtr xsltExtMutex = NULL;
90
91 /************************************************************************
92 * *
93 * Type functions *
94 * *
95 ************************************************************************/
96
97 /**
98 * xsltNewExtDef:
99 * @prefix: the extension prefix
100 * @URI: the namespace URI
101 *
102 * Create a new XSLT ExtDef
103 *
104 * Returns the newly allocated xsltExtDefPtr or NULL in case of error
105 */
106 static xsltExtDefPtr
107 xsltNewExtDef(const xmlChar * prefix, const xmlChar * URI)
108 {
109 xsltExtDefPtr cur;
110
111 cur = (xsltExtDefPtr) xmlMalloc(sizeof(xsltExtDef));
112 if (cur == NULL) {
113 xsltTransformError(NULL, NULL, NULL,
114 "xsltNewExtDef : malloc failed\n");
115 return (NULL);
116 }
117 memset(cur, 0, sizeof(xsltExtDef));
118 if (prefix != NULL)
119 cur->prefix = xmlStrdup(prefix);
120 if (URI != NULL)
121 cur->URI = xmlStrdup(URI);
122 return (cur);
123 }
124
125 /**
126 * xsltFreeExtDef:
127 * @extensiond: an XSLT extension definition
128 *
129 * Free up the memory allocated by @extensiond
130 */
131 static void
132 xsltFreeExtDef(xsltExtDefPtr extensiond)
133 {
134 if (extensiond == NULL)
135 return;
136 if (extensiond->prefix != NULL)
137 xmlFree(extensiond->prefix);
138 if (extensiond->URI != NULL)
139 xmlFree(extensiond->URI);
140 xmlFree(extensiond);
141 }
142
143 /**
144 * xsltFreeExtDefList:
145 * @extensiond: an XSLT extension definition list
146 *
147 * Free up the memory allocated by all the elements of @extensiond
148 */
149 static void
150 xsltFreeExtDefList(xsltExtDefPtr extensiond)
151 {
152 xsltExtDefPtr cur;
153
154 while (extensiond != NULL) {
155 cur = extensiond;
156 extensiond = extensiond->next;
157 xsltFreeExtDef(cur);
158 }
159 }
160
161 /**
162 * xsltNewExtModule:
163 * @initFunc: the module initialization function
164 * @shutdownFunc: the module shutdown function
165 * @styleInitFunc: the stylesheet module data allocator function
166 * @styleShutdownFunc: the stylesheet module data free function
167 *
168 * Create a new XSLT extension module
169 *
170 * Returns the newly allocated xsltExtModulePtr or NULL in case of error
171 */
172 static xsltExtModulePtr
173 xsltNewExtModule(xsltExtInitFunction initFunc,
174 xsltExtShutdownFunction shutdownFunc,
175 xsltStyleExtInitFunction styleInitFunc,
176 xsltStyleExtShutdownFunction styleShutdownFunc)
177 {
178 xsltExtModulePtr cur;
179
180 cur = (xsltExtModulePtr) xmlMalloc(sizeof(xsltExtModule));
181 if (cur == NULL) {
182 xsltTransformError(NULL, NULL, NULL,
183 "xsltNewExtModule : malloc failed\n");
184 return (NULL);
185 }
186 cur->initFunc = initFunc;
187 cur->shutdownFunc = shutdownFunc;
188 cur->styleInitFunc = styleInitFunc;
189 cur->styleShutdownFunc = styleShutdownFunc;
190 return (cur);
191 }
192
193 /**
194 * xsltFreeExtModule:
195 * @ext: an XSLT extension module
196 *
197 * Free up the memory allocated by @ext
198 */
199 static void
200 xsltFreeExtModule(xsltExtModulePtr ext)
201 {
202 if (ext == NULL)
203 return;
204 xmlFree(ext);
205 }
206
207 /**
208 * xsltNewExtData:
209 * @extModule: the module
210 * @extData: the associated data
211 *
212 * Create a new XSLT extension module data wrapper
213 *
214 * Returns the newly allocated xsltExtDataPtr or NULL in case of error
215 */
216 static xsltExtDataPtr
217 xsltNewExtData(xsltExtModulePtr extModule, void *extData)
218 {
219 xsltExtDataPtr cur;
220
221 if (extModule == NULL)
222 return (NULL);
223 cur = (xsltExtDataPtr) xmlMalloc(sizeof(xsltExtData));
224 if (cur == NULL) {
225 xsltTransformError(NULL, NULL, NULL,
226 "xsltNewExtData : malloc failed\n");
227 return (NULL);
228 }
229 cur->extModule = extModule;
230 cur->extData = extData;
231 return (cur);
232 }
233
234 /**
235 * xsltFreeExtData:
236 * @ext: an XSLT extension module data wrapper
237 *
238 * Free up the memory allocated by @ext
239 */
240 static void
241 xsltFreeExtData(xsltExtDataPtr ext)
242 {
243 if (ext == NULL)
244 return;
245 xmlFree(ext);
246 }
247
248 /**
249 * xsltNewExtElement:
250 * @precomp: the pre-computation function
251 * @transform: the transformation function
252 *
253 * Create a new XSLT extension element
254 *
255 * Returns the newly allocated xsltExtElementPtr or NULL in case of
256 * error
257 */
258 static xsltExtElementPtr
259 xsltNewExtElement(xsltPreComputeFunction precomp,
260 xsltTransformFunction transform)
261 {
262 xsltExtElementPtr cur;
263
264 if (transform == NULL)
265 return (NULL);
266
267 cur = (xsltExtElementPtr) xmlMalloc(sizeof(xsltExtElement));
268 if (cur == NULL) {
269 xsltTransformError(NULL, NULL, NULL,
270 "xsltNewExtElement : malloc failed\n");
271 return (NULL);
272 }
273 cur->precomp = precomp;
274 cur->transform = transform;
275 return (cur);
276 }
277
278 /**
279 * xsltFreeExtElement:
280 * @ext: an XSLT extension element
281 *
282 * Frees up the memory allocated by @ext
283 */
284 static void
285 xsltFreeExtElement(xsltExtElementPtr ext)
286 {
287 if (ext == NULL)
288 return;
289 xmlFree(ext);
290 }
291
292
293 #ifdef WITH_MODULES
294 typedef void (*exsltRegisterFunction) (void);
295
296 #ifndef PATH_MAX
297 #define PATH_MAX 4096
298 #endif
299
300 /**
301 * xsltExtModuleRegisterDynamic:
302 * @URI: the function or element namespace URI
303 *
304 * Dynamically loads an extension plugin when available.
305 *
306 * The plugin name is derived from the URI by removing the
307 * initial protocol designation, e.g. "http://", then converting
308 * the characters ".", "-", "/", and "\" into "_", the removing
309 * any trailing "/", then concatenating LIBXML_MODULE_EXTENSION.
310 *
311 * Plugins are loaded from the directory specified by the
312 * environment variable LIBXSLT_PLUGINS_PATH, or if NULL,
313 * by LIBXSLT_DEFAULT_PLUGINS_PATH() which is determined at
314 * compile time.
315 *
316 * Returns 0 if successful, -1 in case of error.
317 */
318
319 static int
320 xsltExtModuleRegisterDynamic(const xmlChar * URI)
321 {
322
323 xmlModulePtr m;
324 exsltRegisterFunction regfunc;
325 xmlChar *ext_name;
326 char module_filename[PATH_MAX];
327 const xmlChar *ext_directory = NULL;
328 const xmlChar *protocol = NULL;
329 xmlChar *i, *regfunc_name;
330 void *vregfunc;
331 int rc;
332
333 /* check for bad inputs */
334 if (URI == NULL)
335 return (-1);
336
337 if (NULL == xsltModuleHash) {
338 xsltModuleHash = xmlHashCreate(5);
339 if (xsltModuleHash == NULL)
340 return (-1);
341 }
342
343 xmlMutexLock(xsltExtMutex);
344
345 /* have we attempted to register this module already? */
346 if (xmlHashLookup(xsltModuleHash, URI) != NULL) {
347 xmlMutexUnlock(xsltExtMutex);
348 return (-1);
349 }
350 xmlMutexUnlock(xsltExtMutex);
351
352 /* transform extension namespace into a module name */
353 protocol = xmlStrstr(URI, BAD_CAST "://");
354 if (protocol == NULL) {
355 ext_name = xmlStrdup(URI);
356 } else {
357 ext_name = xmlStrdup(protocol + 3);
358 }
359 if (ext_name == NULL) {
360 return (-1);
361 }
362
363 i = ext_name;
364 while ('\0' != *i) {
365 if (('/' == *i) || ('\\' == *i) || ('.' == *i) || ('-' == *i))
366 *i = '_';
367 i++;
368 }
369
370 if (*(i - 1) == '_')
371 *i = '\0';
372
373 /* determine module directory */
374 ext_directory = (xmlChar *) getenv("LIBXSLT_PLUGINS_PATH");
375
376 if (NULL == ext_directory) {
377 ext_directory = BAD_CAST LIBXSLT_DEFAULT_PLUGINS_PATH();
378 if (NULL == ext_directory)
379 return (-1);
380 }
381 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
382 else
383 xsltGenericDebug(xsltGenericDebugContext,
384 "LIBXSLT_PLUGINS_PATH is %s\n", ext_directory);
385 #endif
386
387 /* build the module filename, and confirm the module exists */
388 xmlStrPrintf((xmlChar *) module_filename, sizeof(module_filename),
389 BAD_CAST "%s/%s%s",
390 ext_directory, ext_name, LIBXML_MODULE_EXTENSION);
391
392 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
393 xsltGenericDebug(xsltGenericDebugContext,
394 "Attempting to load plugin: %s for URI: %s\n",
395 module_filename, URI);
396 #endif
397
398 if (1 != xmlCheckFilename(module_filename)) {
399
400 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
401 xsltGenericDebug(xsltGenericDebugContext,
402 "xmlCheckFilename failed for plugin: %s\n", module_filename);
403 #endif
404
405 xmlFree(ext_name);
406 return (-1);
407 }
408
409 /* attempt to open the module */
410 m = xmlModuleOpen(module_filename, 0);
411 if (NULL == m) {
412
413 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
414 xsltGenericDebug(xsltGenericDebugContext,
415 "xmlModuleOpen failed for plugin: %s\n", module_filename);
416 #endif
417
418 xmlFree(ext_name);
419 return (-1);
420 }
421
422 /* construct initialization func name */
423 regfunc_name = xmlStrdup(ext_name);
424 regfunc_name = xmlStrcat(regfunc_name, BAD_CAST "_init");
425
426 vregfunc = NULL;
427 rc = xmlModuleSymbol(m, (const char *) regfunc_name, &vregfunc);
428 regfunc = vregfunc;
429 if (0 == rc) {
430 /*
431 * Call the module's init function. Note that this function
432 * calls xsltRegisterExtModuleFull which will add the module
433 * to xsltExtensionsHash (together with it's entry points).
434 */
435 (*regfunc) ();
436
437 /* register this module in our hash */
438 xmlMutexLock(xsltExtMutex);
439 xmlHashAddEntry(xsltModuleHash, URI, (void *) m);
440 xmlMutexUnlock(xsltExtMutex);
441 } else {
442
443 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
444 xsltGenericDebug(xsltGenericDebugContext,
445 "xmlModuleSymbol failed for plugin: %s, regfunc: %s\n",
446 module_filename, regfunc_name);
447 #endif
448
449 /* if regfunc not found unload the module immediately */
450 xmlModuleClose(m);
451 }
452
453 xmlFree(ext_name);
454 xmlFree(regfunc_name);
455 return (NULL == regfunc) ? -1 : 0;
456 }
457 #else
458 static int
459 xsltExtModuleRegisterDynamic(const xmlChar * URI ATTRIBUTE_UNUSED)
460 {
461 return -1;
462 }
463 #endif
464
465 /************************************************************************
466 * *
467 * The stylesheet extension prefixes handling *
468 * *
469 ************************************************************************/
470
471
472 /**
473 * xsltFreeExts:
474 * @style: an XSLT stylesheet
475 *
476 * Free up the memory used by XSLT extensions in a stylesheet
477 */
478 void
479 xsltFreeExts(xsltStylesheetPtr style)
480 {
481 if (style->nsDefs != NULL)
482 xsltFreeExtDefList((xsltExtDefPtr) style->nsDefs);
483 }
484
485 /**
486 * xsltRegisterExtPrefix:
487 * @style: an XSLT stylesheet
488 * @prefix: the prefix used (optional)
489 * @URI: the URI associated to the extension
490 *
491 * Registers an extension namespace
492 * This is called from xslt.c during compile-time.
493 * The given prefix is not needed.
494 * Called by:
495 * xsltParseExtElemPrefixes() (new function)
496 * xsltRegisterExtPrefix() (old function)
497 *
498 * Returns 0 in case of success, 1 if the @URI was already
499 * registered as an extension namespace and
500 * -1 in case of failure
501 */
502 int
503 xsltRegisterExtPrefix(xsltStylesheetPtr style,
504 const xmlChar * prefix, const xmlChar * URI)
505 {
506 xsltExtDefPtr def, ret;
507
508 if ((style == NULL) || (URI == NULL))
509 return (-1);
510
511 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
512 xsltGenericDebug(xsltGenericDebugContext,
513 "Registering extension namespace '%s'.\n", URI);
514 #endif
515 def = (xsltExtDefPtr) style->nsDefs;
516 #ifdef XSLT_REFACTORED
517 /*
518 * The extension is associated with a namespace name.
519 */
520 while (def != NULL) {
521 if (xmlStrEqual(URI, def->URI))
522 return (1);
523 def = def->next;
524 }
525 #else
526 while (def != NULL) {
527 if (xmlStrEqual(prefix, def->prefix))
528 return (-1);
529 def = def->next;
530 }
531 #endif
532 ret = xsltNewExtDef(prefix, URI);
533 if (ret == NULL)
534 return (-1);
535 ret->next = (xsltExtDefPtr) style->nsDefs;
536 style->nsDefs = ret;
537
538 /*
539 * check whether there is an extension module with a stylesheet
540 * initialization function.
541 */
542 #ifdef XSLT_REFACTORED
543 /*
544 * Don't initialize modules based on specified namespaces via
545 * the attribute "[xsl:]extension-element-prefixes".
546 */
547 #else
548 if (xsltExtensionsHash != NULL) {
549 xsltExtModulePtr module;
550
551 xmlMutexLock(xsltExtMutex);
552 module = xmlHashLookup(xsltExtensionsHash, URI);
553 xmlMutexUnlock(xsltExtMutex);
554 if (NULL == module) {
555 if (!xsltExtModuleRegisterDynamic(URI)) {
556 xmlMutexLock(xsltExtMutex);
557 module = xmlHashLookup(xsltExtensionsHash, URI);
558 xmlMutexUnlock(xsltExtMutex);
559 }
560 }
561 if (module != NULL) {
562 xsltStyleGetExtData(style, URI);
563 }
564 }
565 #endif
566 return (0);
567 }
568
569 /************************************************************************
570 * *
571 * The extensions modules interfaces *
572 * *
573 ************************************************************************/
574
575 /**
576 * xsltRegisterExtFunction:
577 * @ctxt: an XSLT transformation context
578 * @name: the name of the element
579 * @URI: the URI associated to the element
580 * @function: the actual implementation which should be called
581 *
582 * Registers an extension function
583 *
584 * Returns 0 in case of success, -1 in case of failure
585 */
586 int
587 xsltRegisterExtFunction(xsltTransformContextPtr ctxt, const xmlChar * name,
588 const xmlChar * URI, xmlXPathFunction function)
589 {
590 int ret;
591
592 if ((ctxt == NULL) || (name == NULL) ||
593 (URI == NULL) || (function == NULL))
594 return (-1);
595 if (ctxt->xpathCtxt != NULL) {
596 xmlXPathRegisterFuncNS(ctxt->xpathCtxt, name, URI, function);
597 }
598 if (ctxt->extFunctions == NULL)
599 ctxt->extFunctions = xmlHashCreate(10);
600 if (ctxt->extFunctions == NULL)
601 return (-1);
602
603 ret = xmlHashAddEntry2(ctxt->extFunctions, name, URI,
604 XML_CAST_FPTR(function));
605
606 return(ret);
607 }
608
609 /**
610 * xsltRegisterExtElement:
611 * @ctxt: an XSLT transformation context
612 * @name: the name of the element
613 * @URI: the URI associated to the element
614 * @function: the actual implementation which should be called
615 *
616 * Registers an extension element
617 *
618 * Returns 0 in case of success, -1 in case of failure
619 */
620 int
621 xsltRegisterExtElement(xsltTransformContextPtr ctxt, const xmlChar * name,
622 const xmlChar * URI, xsltTransformFunction function)
623 {
624 if ((ctxt == NULL) || (name == NULL) ||
625 (URI == NULL) || (function == NULL))
626 return (-1);
627 if (ctxt->extElements == NULL)
628 ctxt->extElements = xmlHashCreate(10);
629 if (ctxt->extElements == NULL)
630 return (-1);
631 return (xmlHashAddEntry2
632 (ctxt->extElements, name, URI, XML_CAST_FPTR(function)));
633 }
634
635 /**
636 * xsltFreeCtxtExts:
637 * @ctxt: an XSLT transformation context
638 *
639 * Free the XSLT extension data
640 */
641 void
642 xsltFreeCtxtExts(xsltTransformContextPtr ctxt)
643 {
644 if (ctxt->extElements != NULL)
645 xmlHashFree(ctxt->extElements, NULL);
646 if (ctxt->extFunctions != NULL)
647 xmlHashFree(ctxt->extFunctions, NULL);
648 }
649
650 /**
651 * xsltStyleGetStylesheetExtData:
652 * @style: an XSLT stylesheet
653 * @URI: the URI associated to the exension module
654 *
655 * Fires the compile-time initialization callback
656 * of an extension module and returns a container
657 * holding the user-data (retrieved via the callback).
658 *
659 * Returns the create module-data container
660 * or NULL if such a module was not registered.
661 */
662 static xsltExtDataPtr
663 xsltStyleInitializeStylesheetModule(xsltStylesheetPtr style,
664 const xmlChar * URI)
665 {
666 xsltExtDataPtr dataContainer;
667 void *userData = NULL;
668 xsltExtModulePtr module;
669
670 if ((style == NULL) || (URI == NULL))
671 return(NULL);
672
673 if (xsltExtensionsHash == NULL) {
674 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
675 xsltGenericDebug(xsltGenericDebugContext,
676 "Not registered extension module: %s\n", URI);
677 #endif
678 return(NULL);
679 }
680
681 xmlMutexLock(xsltExtMutex);
682
683 module = xmlHashLookup(xsltExtensionsHash, URI);
684
685 xmlMutexUnlock(xsltExtMutex);
686
687 if (module == NULL) {
688 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
689 xsltGenericDebug(xsltGenericDebugContext,
690 "Not registered extension module: %s\n", URI);
691 #endif
692 return (NULL);
693 }
694 /*
695 * The specified module was registered so initialize it.
696 */
697 if (style->extInfos == NULL) {
698 style->extInfos = xmlHashCreate(10);
699 if (style->extInfos == NULL)
700 return (NULL);
701 }
702 /*
703 * Fire the initialization callback if available.
704 */
705 if (module->styleInitFunc == NULL) {
706 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
707 xsltGenericDebug(xsltGenericDebugContext,
708 "Initializing module with *no* callback: %s\n", URI);
709 #endif
710 } else {
711 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
712 xsltGenericDebug(xsltGenericDebugContext,
713 "Initializing module with callback: %s\n", URI);
714 #endif
715 /*
716 * Fire the initialization callback.
717 */
718 userData = module->styleInitFunc(style, URI);
719 }
720 /*
721 * Store the user-data in the context of the given stylesheet.
722 */
723 dataContainer = xsltNewExtData(module, userData);
724 if (dataContainer == NULL)
725 return (NULL);
726
727 if (xmlHashAddEntry(style->extInfos, URI,
728 (void *) dataContainer) < 0)
729 {
730 xsltTransformError(NULL, style, NULL,
731 "Failed to register module '%s'.\n", URI);
732 style->errors++;
733 if (module->styleShutdownFunc)
734 module->styleShutdownFunc(style, URI, userData);
735 xsltFreeExtData(dataContainer);
736 return (NULL);
737 }
738
739 return(dataContainer);
740 }
741
742 /**
743 * xsltStyleGetExtData:
744 * @style: an XSLT stylesheet
745 * @URI: the URI associated to the exension module
746 *
747 * Retrieve the data associated to the extension module
748 * in this given stylesheet.
749 * Called by:
750 * xsltRegisterExtPrefix(),
751 * ( xsltExtElementPreCompTest(), xsltExtInitTest )
752 *
753 * Returns the pointer or NULL if not present
754 */
755 void *
756 xsltStyleGetExtData(xsltStylesheetPtr style, const xmlChar * URI)
757 {
758 xsltExtDataPtr dataContainer = NULL;
759 xsltStylesheetPtr tmpStyle;
760
761 if ((style == NULL) || (URI == NULL) ||
762 (xsltExtensionsHash == NULL))
763 return (NULL);
764
765
766 #ifdef XSLT_REFACTORED
767 /*
768 * This is intended for global storage, so only the main
769 * stylesheet will hold the data.
770 */
771 tmpStyle = style;
772 while (tmpStyle->parent != NULL)
773 tmpStyle = tmpStyle->parent;
774 if (tmpStyle->extInfos != NULL) {
775 dataContainer =
776 (xsltExtDataPtr) xmlHashLookup(tmpStyle->extInfos, URI);
777 if (dataContainer != NULL) {
778 /*
779 * The module was already initialized in the context
780 * of this stylesheet; just return the user-data that
781 * comes with it.
782 */
783 return(dataContainer->extData);
784 }
785 }
786 #else
787 /*
788 * Old behaviour.
789 */
790 tmpStyle = style;
791 while (tmpStyle != NULL) {
792 if (tmpStyle->extInfos != NULL) {
793 dataContainer =
794 (xsltExtDataPtr) xmlHashLookup(tmpStyle->extInfos, URI);
795 if (dataContainer != NULL) {
796 return(dataContainer->extData);
797 }
798 }
799 tmpStyle = xsltNextImport(tmpStyle);
800 }
801 tmpStyle = style;
802 #endif
803
804 dataContainer =
805 xsltStyleInitializeStylesheetModule(tmpStyle, URI);
806 if (dataContainer != NULL)
807 return (dataContainer->extData);
808 return(NULL);
809 }
810
811 #ifdef XSLT_REFACTORED
812 /**
813 * xsltStyleStylesheetLevelGetExtData:
814 * @style: an XSLT stylesheet
815 * @URI: the URI associated to the exension module
816 *
817 * Retrieve the data associated to the extension module in this given
818 * stylesheet.
819 *
820 * Returns the pointer or NULL if not present
821 */
822 void *
823 xsltStyleStylesheetLevelGetExtData(xsltStylesheetPtr style,
824 const xmlChar * URI)
825 {
826 xsltExtDataPtr dataContainer = NULL;
827
828 if ((style == NULL) || (URI == NULL) ||
829 (xsltExtensionsHash == NULL))
830 return (NULL);
831
832 if (style->extInfos != NULL) {
833 dataContainer = (xsltExtDataPtr) xmlHashLookup(style->extInfos, URI);
834 /*
835 * The module was already initialized in the context
836 * of this stylesheet; just return the user-data that
837 * comes with it.
838 */
839 if (dataContainer)
840 return(dataContainer->extData);
841 }
842
843 dataContainer =
844 xsltStyleInitializeStylesheetModule(style, URI);
845 if (dataContainer != NULL)
846 return (dataContainer->extData);
847 return(NULL);
848 }
849 #endif
850
851 /**
852 * xsltGetExtData:
853 * @ctxt: an XSLT transformation context
854 * @URI: the URI associated to the exension module
855 *
856 * Retrieve the data associated to the extension module in this given
857 * transformation.
858 *
859 * Returns the pointer or NULL if not present
860 */
861 void *
862 xsltGetExtData(xsltTransformContextPtr ctxt, const xmlChar * URI)
863 {
864 xsltExtDataPtr data;
865
866 if ((ctxt == NULL) || (URI == NULL))
867 return (NULL);
868 if (ctxt->extInfos == NULL) {
869 ctxt->extInfos = xmlHashCreate(10);
870 if (ctxt->extInfos == NULL)
871 return (NULL);
872 data = NULL;
873 } else {
874 data = (xsltExtDataPtr) xmlHashLookup(ctxt->extInfos, URI);
875 }
876 if (data == NULL) {
877 void *extData;
878 xsltExtModulePtr module;
879
880 xmlMutexLock(xsltExtMutex);
881
882 module = xmlHashLookup(xsltExtensionsHash, URI);
883
884 xmlMutexUnlock(xsltExtMutex);
885
886 if (module == NULL) {
887 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
888 xsltGenericDebug(xsltGenericDebugContext,
889 "Not registered extension module: %s\n", URI);
890 #endif
891 return (NULL);
892 } else {
893 if (module->initFunc == NULL)
894 return (NULL);
895
896 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
897 xsltGenericDebug(xsltGenericDebugContext,
898 "Initializing module: %s\n", URI);
899 #endif
900
901 extData = module->initFunc(ctxt, URI);
902 if (extData == NULL)
903 return (NULL);
904
905 data = xsltNewExtData(module, extData);
906 if (data == NULL)
907 return (NULL);
908 if (xmlHashAddEntry(ctxt->extInfos, URI, (void *) data) < 0) {
909 xsltTransformError(ctxt, NULL, NULL,
910 "Failed to register module data: %s\n",
911 URI);
912 if (module->shutdownFunc)
913 module->shutdownFunc(ctxt, URI, extData);
914 xsltFreeExtData(data);
915 return (NULL);
916 }
917 }
918 }
919 return (data->extData);
920 }
921
922 typedef struct _xsltInitExtCtxt xsltInitExtCtxt;
923 struct _xsltInitExtCtxt {
924 xsltTransformContextPtr ctxt;
925 int ret;
926 };
927
928 /**
929 * xsltInitCtxtExt:
930 * @styleData: the registered stylesheet data for the module
931 * @ctxt: the XSLT transformation context + the return value
932 * @URI: the extension URI
933 *
934 * Initializes an extension module
935 */
936 static void
937 xsltInitCtxtExt(xsltExtDataPtr styleData, xsltInitExtCtxt * ctxt,
938 const xmlChar * URI)
939 {
940 xsltExtModulePtr module;
941 xsltExtDataPtr ctxtData;
942 void *extData;
943
944 if ((styleData == NULL) || (ctxt == NULL) || (URI == NULL) ||
945 (ctxt->ret == -1)) {
946 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
947 xsltGenericDebug(xsltGenericDebugContext,
948 "xsltInitCtxtExt: NULL param or error\n");
949 #endif
950 return;
951 }
952 module = styleData->extModule;
953 if ((module == NULL) || (module->initFunc == NULL)) {
954 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
955 xsltGenericDebug(xsltGenericDebugContext,
956 "xsltInitCtxtExt: no module or no initFunc\n");
957 #endif
958 return;
959 }
960
961 ctxtData = (xsltExtDataPtr) xmlHashLookup(ctxt->ctxt->extInfos, URI);
962 if (ctxtData != NULL) {
963 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
964 xsltGenericDebug(xsltGenericDebugContext,
965 "xsltInitCtxtExt: already initialized\n");
966 #endif
967 return;
968 }
969
970 extData = module->initFunc(ctxt->ctxt, URI);
971 if (extData == NULL) {
972 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
973 xsltGenericDebug(xsltGenericDebugContext,
974 "xsltInitCtxtExt: no extData\n");
975 #endif
976 }
977 ctxtData = xsltNewExtData(module, extData);
978 if (ctxtData == NULL) {
979 ctxt->ret = -1;
980 return;
981 }
982
983 if (ctxt->ctxt->extInfos == NULL)
984 ctxt->ctxt->extInfos = xmlHashCreate(10);
985 if (ctxt->ctxt->extInfos == NULL) {
986 ctxt->ret = -1;
987 return;
988 }
989
990 if (xmlHashAddEntry(ctxt->ctxt->extInfos, URI, ctxtData) < 0) {
991 xsltGenericError(xsltGenericErrorContext,
992 "Failed to register module data: %s\n", URI);
993 if (module->shutdownFunc)
994 module->shutdownFunc(ctxt->ctxt, URI, extData);
995 xsltFreeExtData(ctxtData);
996 ctxt->ret = -1;
997 return;
998 }
999 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
1000 xsltGenericDebug(xsltGenericDebugContext, "Registered module %s\n",
1001 URI);
1002 #endif
1003 ctxt->ret++;
1004 }
1005
1006 /**
1007 * xsltInitCtxtExts:
1008 * @ctxt: an XSLT transformation context
1009 *
1010 * Initialize the set of modules with registered stylesheet data
1011 *
1012 * Returns the number of modules initialized or -1 in case of error
1013 */
1014 int
1015 xsltInitCtxtExts(xsltTransformContextPtr ctxt)
1016 {
1017 xsltStylesheetPtr style;
1018 xsltInitExtCtxt ctx;
1019
1020 if (ctxt == NULL)
1021 return (-1);
1022
1023 style = ctxt->style;
1024 if (style == NULL)
1025 return (-1);
1026
1027 ctx.ctxt = ctxt;
1028 ctx.ret = 0;
1029
1030 while (style != NULL) {
1031 if (style->extInfos != NULL) {
1032 xmlHashScan(style->extInfos,
1033 (xmlHashScanner) xsltInitCtxtExt, &ctx);
1034 if (ctx.ret == -1)
1035 return (-1);
1036 }
1037 style = xsltNextImport(style);
1038 }
1039 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
1040 xsltGenericDebug(xsltGenericDebugContext, "Registered %d modules\n",
1041 ctx.ret);
1042 #endif
1043 return (ctx.ret);
1044 }
1045
1046 /**
1047 * xsltShutdownCtxtExt:
1048 * @data: the registered data for the module
1049 * @ctxt: the XSLT transformation context
1050 * @URI: the extension URI
1051 *
1052 * Shutdown an extension module loaded
1053 */
1054 static void
1055 xsltShutdownCtxtExt(xsltExtDataPtr data, xsltTransformContextPtr ctxt,
1056 const xmlChar * URI)
1057 {
1058 xsltExtModulePtr module;
1059
1060 if ((data == NULL) || (ctxt == NULL) || (URI == NULL))
1061 return;
1062 module = data->extModule;
1063 if ((module == NULL) || (module->shutdownFunc == NULL))
1064 return;
1065
1066 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
1067 xsltGenericDebug(xsltGenericDebugContext,
1068 "Shutting down module : %s\n", URI);
1069 #endif
1070 module->shutdownFunc(ctxt, URI, data->extData);
1071 }
1072
1073 /**
1074 * xsltShutdownCtxtExts:
1075 * @ctxt: an XSLT transformation context
1076 *
1077 * Shutdown the set of modules loaded
1078 */
1079 void
1080 xsltShutdownCtxtExts(xsltTransformContextPtr ctxt)
1081 {
1082 if (ctxt == NULL)
1083 return;
1084 if (ctxt->extInfos == NULL)
1085 return;
1086 xmlHashScan(ctxt->extInfos, (xmlHashScanner) xsltShutdownCtxtExt,
1087 ctxt);
1088 xmlHashFree(ctxt->extInfos, (xmlHashDeallocator) xsltFreeExtData);
1089 ctxt->extInfos = NULL;
1090 }
1091
1092 /**
1093 * xsltShutdownExt:
1094 * @data: the registered data for the module
1095 * @ctxt: the XSLT stylesheet
1096 * @URI: the extension URI
1097 *
1098 * Shutdown an extension module loaded
1099 */
1100 static void
1101 xsltShutdownExt(xsltExtDataPtr data, xsltStylesheetPtr style,
1102 const xmlChar * URI)
1103 {
1104 xsltExtModulePtr module;
1105
1106 if ((data == NULL) || (style == NULL) || (URI == NULL))
1107 return;
1108 module = data->extModule;
1109 if ((module == NULL) || (module->styleShutdownFunc == NULL))
1110 return;
1111
1112 #ifdef WITH_XSLT_DEBUG_EXTENSIONS
1113 xsltGenericDebug(xsltGenericDebugContext,
1114 "Shutting down module : %s\n", URI);
1115 #endif
1116 module->styleShutdownFunc(style, URI, data->extData);
1117 /*
1118 * Don't remove the entry from the hash table here, since
1119 * this will produce segfaults - this fixes bug #340624.
1120 *
1121 * xmlHashRemoveEntry(style->extInfos, URI,
1122 * (xmlHashDeallocator) xsltFreeExtData);
1123 */
1124 }
1125
1126 /**
1127 * xsltShutdownExts:
1128 * @style: an XSLT stylesheet
1129 *
1130 * Shutdown the set of modules loaded
1131 */
1132 void
1133 xsltShutdownExts(xsltStylesheetPtr style)
1134 {
1135 if (style == NULL)
1136 return;
1137 if (style->extInfos == NULL)
1138 return;
1139 xmlHashScan(style->extInfos, (xmlHashScanner) xsltShutdownExt, style);
1140 xmlHashFree(style->extInfos, (xmlHashDeallocator) xsltFreeExtData);
1141 style->extInfos = NULL;
1142 }
1143
1144 /**
1145 * xsltCheckExtPrefix:
1146 * @style: the stylesheet
1147 * @URI: the namespace prefix (possibly NULL)
1148 *
1149 * Check if the given prefix is one of the declared extensions.
1150 * This is intended to be called only at compile-time.
1151 * Called by:
1152 * xsltGetInheritedNsList() (xslt.c)
1153 * xsltParseTemplateContent (xslt.c)
1154 *
1155 * Returns 1 if this is an extension, 0 otherwise
1156 */
1157 int
1158 xsltCheckExtPrefix(xsltStylesheetPtr style, const xmlChar * URI)
1159 {
1160 #ifdef XSLT_REFACTORED
1161 if ((style == NULL) || (style->compCtxt == NULL) ||
1162 (XSLT_CCTXT(style)->inode == NULL) ||
1163 (XSLT_CCTXT(style)->inode->extElemNs == NULL))
1164 return (0);
1165 /*
1166 * Lookup the extension namespaces registered
1167 * at the current node in the stylesheet's tree.
1168 */
1169 if (XSLT_CCTXT(style)->inode->extElemNs != NULL) {
1170 int i;
1171 xsltPointerListPtr list = XSLT_CCTXT(style)->inode->extElemNs;
1172
1173 for (i = 0; i < list->number; i++) {
1174 if (xmlStrEqual((const xmlChar *) list->items[i],
1175 URI))
1176 {
1177 return(1);
1178 }
1179 }
1180 }
1181 #else
1182 xsltExtDefPtr cur;
1183
1184 if ((style == NULL) || (style->nsDefs == NULL))
1185 return (0);
1186 if (URI == NULL)
1187 URI = BAD_CAST "#default";
1188 cur = (xsltExtDefPtr) style->nsDefs;
1189 while (cur != NULL) {
1190 /*
1191 * NOTE: This was change to work on namespace names rather
1192 * than namespace prefixes. This fixes bug #339583.
1193 * TODO: Consider renaming the field "prefix" of xsltExtDef
1194 * to "href".
1195 */
1196 if (xmlStrEqual(URI, cur->prefix))
1197 return (1);
1198 cur = cur->next;
1199 }
1200 #endif
1201 return (0);
1202 }
1203
1204 /**
1205 * xsltCheckExtURI:
1206 * @style: the stylesheet
1207 * @URI: the namespace URI (possibly NULL)
1208 *
1209 * Check if the given prefix is one of the declared extensions.
1210 * This is intended to be called only at compile-time.
1211 * Called by:
1212 * xsltPrecomputeStylesheet() (xslt.c)
1213 * xsltParseTemplateContent (xslt.c)
1214 *
1215 * Returns 1 if this is an extension, 0 otherwise
1216 */
1217 int
1218 xsltCheckExtURI(xsltStylesheetPtr style, const xmlChar * URI)
1219 {
1220 xsltExtDefPtr cur;
1221
1222 if ((style == NULL) || (style->nsDefs == NULL))
1223 return (0);
1224 if (URI == NULL)
1225 return (0);
1226 cur = (xsltExtDefPtr) style->nsDefs;
1227 while (cur != NULL) {
1228 if (xmlStrEqual(URI, cur->URI))
1229 return (1);
1230 cur = cur->next;
1231 }
1232 return (0);
1233 }
1234
1235 /**
1236 * xsltRegisterExtModuleFull:
1237 * @URI: URI associated to this module
1238 * @initFunc: the module initialization function
1239 * @shutdownFunc: the module shutdown function
1240 * @styleInitFunc: the module initialization function
1241 * @styleShutdownFunc: the module shutdown function
1242 *
1243 * Register an XSLT extension module to the library.
1244 *
1245 * Returns 0 if sucessful, -1 in case of error
1246 */
1247 int
1248 xsltRegisterExtModuleFull(const xmlChar * URI,
1249 xsltExtInitFunction initFunc,
1250 xsltExtShutdownFunction shutdownFunc,
1251 xsltStyleExtInitFunction styleInitFunc,
1252 xsltStyleExtShutdownFunction styleShutdownFunc)
1253 {
1254 int ret;
1255 xsltExtModulePtr module;
1256
1257 if ((URI == NULL) || (initFunc == NULL))
1258 return (-1);
1259 if (xsltExtensionsHash == NULL)
1260 xsltExtensionsHash = xmlHashCreate(10);
1261
1262 if (xsltExtensionsHash == NULL)
1263 return (-1);
1264
1265 xmlMutexLock(xsltExtMutex);
1266
1267 module = xmlHashLookup(xsltExtensionsHash, URI);
1268 if (module != NULL) {
1269 if ((module->initFunc == initFunc) &&
1270 (module->shutdownFunc == shutdownFunc))
1271 ret = 0;
1272 else
1273 ret = -1;
1274 goto done;
1275 }
1276 module = xsltNewExtModule(initFunc, shutdownFunc,
1277 styleInitFunc, styleShutdownFunc);
1278 if (module == NULL) {
1279 ret = -1;
1280 goto done;
1281 }
1282 ret = xmlHashAddEntry(xsltExtensionsHash, URI, (void *) module);
1283
1284 done:
1285 xmlMutexUnlock(xsltExtMutex);
1286 return (ret);
1287 }
1288
1289 /**
1290 * xsltRegisterExtModule:
1291 * @URI: URI associated to this module
1292 * @initFunc: the module initialization function
1293 * @shutdownFunc: the module shutdown function
1294 *
1295 * Register an XSLT extension module to the library.
1296 *
1297 * Returns 0 if sucessful, -1 in case of error
1298 */
1299 int
1300 xsltRegisterExtModule(const xmlChar * URI,
1301 xsltExtInitFunction initFunc,
1302 xsltExtShutdownFunction shutdownFunc)
1303 {
1304 return xsltRegisterExtModuleFull(URI, initFunc, shutdownFunc,
1305 NULL, NULL);
1306 }
1307
1308 /**
1309 * xsltUnregisterExtModule:
1310 * @URI: URI associated to this module
1311 *
1312 * Unregister an XSLT extension module from the library.
1313 *
1314 * Returns 0 if sucessful, -1 in case of error
1315 */
1316 int
1317 xsltUnregisterExtModule(const xmlChar * URI)
1318 {
1319 int ret;
1320
1321 if (URI == NULL)
1322 return (-1);
1323 if (xsltExtensionsHash == NULL)
1324 return (-1);
1325
1326 xmlMutexLock(xsltExtMutex);
1327
1328 ret = xmlHashRemoveEntry(xsltExtensionsHash, URI,
1329 (xmlHashDeallocator) xsltFreeExtModule);
1330
1331 xmlMutexUnlock(xsltExtMutex);
1332
1333 return (ret);
1334 }
1335
1336 /**
1337 * xsltUnregisterAllExtModules:
1338 *
1339 * Unregister all the XSLT extension module from the library.
1340 */
1341 static void
1342 xsltUnregisterAllExtModules(void)
1343 {
1344 if (xsltExtensionsHash == NULL)
1345 return;
1346
1347 xmlMutexLock(xsltExtMutex);
1348
1349 xmlHashFree(xsltExtensionsHash,
1350 (xmlHashDeallocator) xsltFreeExtModule);
1351 xsltExtensionsHash = NULL;
1352
1353 xmlMutexUnlock(xsltExtMutex);
1354 }
1355
1356 /**
1357 * xsltXPathGetTransformContext:
1358 * @ctxt: an XPath transformation context
1359 *
1360 * Provides the XSLT transformation context from the XPath transformation
1361 * context. This is useful when an XPath function in the extension module
1362 * is called by the XPath interpreter and that the XSLT context is needed
1363 * for example to retrieve the associated data pertaining to this XSLT
1364 * transformation.
1365 *
1366 * Returns the XSLT transformation context or NULL in case of error.
1367 */
1368 xsltTransformContextPtr
1369 xsltXPathGetTransformContext(xmlXPathParserContextPtr ctxt)
1370 {
1371 if ((ctxt == NULL) || (ctxt->context == NULL))
1372 return (NULL);
1373 return (ctxt->context->extra);
1374 }
1375
1376 /**
1377 * xsltRegisterExtModuleFunction:
1378 * @name: the function name
1379 * @URI: the function namespace URI
1380 * @function: the function callback
1381 *
1382 * Registers an extension module function.
1383 *
1384 * Returns 0 if successful, -1 in case of error.
1385 */
1386 int
1387 xsltRegisterExtModuleFunction(const xmlChar * name, const xmlChar * URI,
1388 xmlXPathFunction function)
1389 {
1390 if ((name == NULL) || (URI == NULL) || (function == NULL))
1391 return (-1);
1392
1393 if (xsltFunctionsHash == NULL)
1394 xsltFunctionsHash = xmlHashCreate(10);
1395 if (xsltFunctionsHash == NULL)
1396 return (-1);
1397
1398 xmlMutexLock(xsltExtMutex);
1399
1400 xmlHashUpdateEntry2(xsltFunctionsHash, name, URI,
1401 XML_CAST_FPTR(function), NULL);
1402
1403 xmlMutexUnlock(xsltExtMutex);
1404
1405 return (0);
1406 }
1407
1408 /**
1409 * xsltExtModuleFunctionLookup:
1410 * @name: the function name
1411 * @URI: the function namespace URI
1412 *
1413 * Looks up an extension module function
1414 *
1415 * Returns the function if found, NULL otherwise.
1416 */
1417 xmlXPathFunction
1418 xsltExtModuleFunctionLookup(const xmlChar * name, const xmlChar * URI)
1419 {
1420 xmlXPathFunction ret;
1421
1422 if ((xsltFunctionsHash == NULL) || (name == NULL) || (URI == NULL))
1423 return (NULL);
1424
1425 xmlMutexLock(xsltExtMutex);
1426
1427 XML_CAST_FPTR(ret) = xmlHashLookup2(xsltFunctionsHash, name, URI);
1428
1429 xmlMutexUnlock(xsltExtMutex);
1430
1431 /* if lookup fails, attempt a dynamic load on supported platforms */
1432 if (NULL == ret) {
1433 if (!xsltExtModuleRegisterDynamic(URI)) {
1434 xmlMutexLock(xsltExtMutex);
1435
1436 XML_CAST_FPTR(ret) =
1437 xmlHashLookup2(xsltFunctionsHash, name, URI);
1438
1439 xmlMutexUnlock(xsltExtMutex);
1440 }
1441 }
1442
1443 return ret;
1444 }
1445
1446 /**
1447 * xsltUnregisterExtModuleFunction:
1448 * @name: the function name
1449 * @URI: the function namespace URI
1450 *
1451 * Unregisters an extension module function
1452 *
1453 * Returns 0 if successful, -1 in case of error.
1454 */
1455 int
1456 xsltUnregisterExtModuleFunction(const xmlChar * name, const xmlChar * URI)
1457 {
1458 int ret;
1459
1460 if ((xsltFunctionsHash == NULL) || (name == NULL) || (URI == NULL))
1461 return (-1);
1462
1463 xmlMutexLock(xsltExtMutex);
1464
1465 ret = xmlHashRemoveEntry2(xsltFunctionsHash, name, URI, NULL);
1466
1467 xmlMutexUnlock(xsltExtMutex);
1468
1469 return(ret);
1470 }
1471
1472 /**
1473 * xsltUnregisterAllExtModuleFunction:
1474 *
1475 * Unregisters all extension module function
1476 */
1477 static void
1478 xsltUnregisterAllExtModuleFunction(void)
1479 {
1480 xmlMutexLock(xsltExtMutex);
1481
1482 xmlHashFree(xsltFunctionsHash, NULL);
1483 xsltFunctionsHash = NULL;
1484
1485 xmlMutexUnlock(xsltExtMutex);
1486 }
1487
1488
1489 /**
1490 * xsltNewElemPreComp:
1491 * @style: the XSLT stylesheet
1492 * @inst: the element node
1493 * @function: the transform function
1494 *
1495 * Creates and initializes an #xsltElemPreComp
1496 *
1497 * Returns the new and initialized #xsltElemPreComp
1498 */
1499 xsltElemPreCompPtr
1500 xsltNewElemPreComp(xsltStylesheetPtr style, xmlNodePtr inst,
1501 xsltTransformFunction function)
1502 {
1503 xsltElemPreCompPtr cur;
1504
1505 cur = (xsltElemPreCompPtr) xmlMalloc(sizeof(xsltElemPreComp));
1506 if (cur == NULL) {
1507 xsltTransformError(NULL, style, NULL,
1508 "xsltNewExtElement : malloc failed\n");
1509 return (NULL);
1510 }
1511 memset(cur, 0, sizeof(xsltElemPreComp));
1512
1513 xsltInitElemPreComp(cur, style, inst, function,
1514 (xsltElemPreCompDeallocator) xmlFree);
1515
1516 return (cur);
1517 }
1518
1519 /**
1520 * xsltInitElemPreComp:
1521 * @comp: an #xsltElemPreComp (or generally a derived structure)
1522 * @style: the XSLT stylesheet
1523 * @inst: the element node
1524 * @function: the transform function
1525 * @freeFunc: the @comp deallocator
1526 *
1527 * Initializes an existing #xsltElemPreComp structure. This is usefull
1528 * when extending an #xsltElemPreComp to store precomputed data.
1529 * This function MUST be called on any extension element precomputed
1530 * data struct.
1531 */
1532 void
1533 xsltInitElemPreComp(xsltElemPreCompPtr comp, xsltStylesheetPtr style,
1534 xmlNodePtr inst, xsltTransformFunction function,
1535 xsltElemPreCompDeallocator freeFunc)
1536 {
1537 comp->type = XSLT_FUNC_EXTENSION;
1538 comp->func = function;
1539 comp->inst = inst;
1540 comp->free = freeFunc;
1541
1542 comp->next = style->preComps;
1543 style->preComps = comp;
1544 }
1545
1546 /**
1547 * xsltPreComputeExtModuleElement:
1548 * @style: the stylesheet
1549 * @inst: the element node
1550 *
1551 * Precomputes an extension module element
1552 *
1553 * Returns the precomputed data
1554 */
1555 xsltElemPreCompPtr
1556 xsltPreComputeExtModuleElement(xsltStylesheetPtr style, xmlNodePtr inst)
1557 {
1558 xsltExtElementPtr ext;
1559 xsltElemPreCompPtr comp = NULL;
1560
1561 if ((style == NULL) || (inst == NULL) ||
1562 (inst->type != XML_ELEMENT_NODE) || (inst->ns == NULL))
1563 return (NULL);
1564
1565 xmlMutexLock(xsltExtMutex);
1566
1567 ext = (xsltExtElementPtr)
1568 xmlHashLookup2(xsltElementsHash, inst->name, inst->ns->href);
1569
1570 xmlMutexUnlock(xsltExtMutex);
1571
1572 /*
1573 * EXT TODO: Now what?
1574 */
1575 if (ext == NULL)
1576 return (NULL);
1577
1578 if (ext->precomp != NULL) {
1579 /*
1580 * REVISIT TODO: Check if the text below is correct.
1581 * This will return a xsltElemPreComp structure or NULL.
1582 * 1) If the the author of the extension needs a
1583 * custom structure to hold the specific values of
1584 * this extension, he will derive a structure based on
1585 * xsltElemPreComp; thus we obviously *cannot* refactor
1586 * the xsltElemPreComp structure, since all already derived
1587 * user-defined strucures will break.
1588 * Example: For the extension xsl:document,
1589 * in xsltDocumentComp() (preproc.c), the structure
1590 * xsltStyleItemDocument is allocated, filled with
1591 * specific values and returned.
1592 * 2) If the author needs no values to be stored in
1593 * this structure, then he'll return NULL;
1594 */
1595 comp = ext->precomp(style, inst, ext->transform);
1596 }
1597 if (comp == NULL) {
1598 /*
1599 * Default creation of a xsltElemPreComp structure, if
1600 * the author of this extension did not create a custom
1601 * structure.
1602 */
1603 comp = xsltNewElemPreComp(style, inst, ext->transform);
1604 }
1605
1606 return (comp);
1607 }
1608
1609 /**
1610 * xsltRegisterExtModuleElement:
1611 * @name: the element name
1612 * @URI: the element namespace URI
1613 * @precomp: the pre-computation callback
1614 * @transform: the transformation callback
1615 *
1616 * Registers an extension module element.
1617 *
1618 * Returns 0 if successful, -1 in case of error.
1619 */
1620 int
1621 xsltRegisterExtModuleElement(const xmlChar * name, const xmlChar * URI,
1622 xsltPreComputeFunction precomp,
1623 xsltTransformFunction transform)
1624 {
1625 int ret;
1626
1627 xsltExtElementPtr ext;
1628
1629 if ((name == NULL) || (URI == NULL) || (transform == NULL))
1630 return (-1);
1631
1632 if (xsltElementsHash == NULL)
1633 xsltElementsHash = xmlHashCreate(10);
1634 if (xsltElementsHash == NULL)
1635 return (-1);
1636
1637 xmlMutexLock(xsltExtMutex);
1638
1639 ext = xsltNewExtElement(precomp, transform);
1640 if (ext == NULL) {
1641 ret = -1;
1642 goto done;
1643 }
1644
1645 xmlHashUpdateEntry2(xsltElementsHash, name, URI, (void *) ext,
1646 (xmlHashDeallocator) xsltFreeExtElement);
1647
1648 done:
1649 xmlMutexUnlock(xsltExtMutex);
1650
1651 return (0);
1652 }
1653
1654 /**
1655 * xsltExtElementLookup:
1656 * @ctxt: an XSLT process context
1657 * @name: the element name
1658 * @URI: the element namespace URI
1659 *
1660 * Looks up an extension element. @ctxt can be NULL to search only in
1661 * module elements.
1662 *
1663 * Returns the element callback or NULL if not found
1664 */
1665 xsltTransformFunction
1666 xsltExtElementLookup(xsltTransformContextPtr ctxt,
1667 const xmlChar * name, const xmlChar * URI)
1668 {
1669 xsltTransformFunction ret;
1670
1671 if ((name == NULL) || (URI == NULL))
1672 return (NULL);
1673
1674 if ((ctxt != NULL) && (ctxt->extElements != NULL)) {
1675 XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->extElements, name, URI);
1676 if (ret != NULL) {
1677 return(ret);
1678 }
1679 }
1680
1681 ret = xsltExtModuleElementLookup(name, URI);
1682
1683 return (ret);
1684 }
1685
1686 /**
1687 * xsltExtModuleElementLookup:
1688 * @name: the element name
1689 * @URI: the element namespace URI
1690 *
1691 * Looks up an extension module element
1692 *
1693 * Returns the callback function if found, NULL otherwise.
1694 */
1695 xsltTransformFunction
1696 xsltExtModuleElementLookup(const xmlChar * name, const xmlChar * URI)
1697 {
1698 xsltExtElementPtr ext;
1699
1700 if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
1701 return (NULL);
1702
1703 xmlMutexLock(xsltExtMutex);
1704
1705 ext = (xsltExtElementPtr) xmlHashLookup2(xsltElementsHash, name, URI);
1706
1707 xmlMutexUnlock(xsltExtMutex);
1708
1709 /*
1710 * if function lookup fails, attempt a dynamic load on
1711 * supported platforms
1712 */
1713 if (NULL == ext) {
1714 if (!xsltExtModuleRegisterDynamic(URI)) {
1715 xmlMutexLock(xsltExtMutex);
1716
1717 ext = (xsltExtElementPtr)
1718 xmlHashLookup2(xsltElementsHash, name, URI);
1719
1720 xmlMutexUnlock(xsltExtMutex);
1721 }
1722 }
1723
1724 if (ext == NULL)
1725 return (NULL);
1726 return (ext->transform);
1727 }
1728
1729 /**
1730 * xsltExtModuleElementPreComputeLookup:
1731 * @name: the element name
1732 * @URI: the element namespace URI
1733 *
1734 * Looks up an extension module element pre-computation function
1735 *
1736 * Returns the callback function if found, NULL otherwise.
1737 */
1738 xsltPreComputeFunction
1739 xsltExtModuleElementPreComputeLookup(const xmlChar * name,
1740 const xmlChar * URI)
1741 {
1742 xsltExtElementPtr ext;
1743
1744 if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
1745 return (NULL);
1746
1747 xmlMutexLock(xsltExtMutex);
1748
1749 ext = (xsltExtElementPtr) xmlHashLookup2(xsltElementsHash, name, URI);
1750
1751 xmlMutexUnlock(xsltExtMutex);
1752
1753 if (ext == NULL) {
1754 if (!xsltExtModuleRegisterDynamic(URI)) {
1755 xmlMutexLock(xsltExtMutex);
1756
1757 ext = (xsltExtElementPtr)
1758 xmlHashLookup2(xsltElementsHash, name, URI);
1759
1760 xmlMutexUnlock(xsltExtMutex);
1761 }
1762 }
1763
1764 if (ext == NULL)
1765 return (NULL);
1766 return (ext->precomp);
1767 }
1768
1769 /**
1770 * xsltUnregisterExtModuleElement:
1771 * @name: the element name
1772 * @URI: the element namespace URI
1773 *
1774 * Unregisters an extension module element
1775 *
1776 * Returns 0 if successful, -1 in case of error.
1777 */
1778 int
1779 xsltUnregisterExtModuleElement(const xmlChar * name, const xmlChar * URI)
1780 {
1781 int ret;
1782
1783 if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
1784 return (-1);
1785
1786 xmlMutexLock(xsltExtMutex);
1787
1788 ret = xmlHashRemoveEntry2(xsltElementsHash, name, URI,
1789 (xmlHashDeallocator) xsltFreeExtElement);
1790
1791 xmlMutexUnlock(xsltExtMutex);
1792
1793 return(ret);
1794 }
1795
1796 /**
1797 * xsltUnregisterAllExtModuleElement:
1798 *
1799 * Unregisters all extension module element
1800 */
1801 static void
1802 xsltUnregisterAllExtModuleElement(void)
1803 {
1804 xmlMutexLock(xsltExtMutex);
1805
1806 xmlHashFree(xsltElementsHash, (xmlHashDeallocator) xsltFreeExtElement);
1807 xsltElementsHash = NULL;
1808
1809 xmlMutexUnlock(xsltExtMutex);
1810 }
1811
1812 /**
1813 * xsltRegisterExtModuleTopLevel:
1814 * @name: the top-level element name
1815 * @URI: the top-level element namespace URI
1816 * @function: the top-level element callback
1817 *
1818 * Registers an extension module top-level element.
1819 *
1820 * Returns 0 if successful, -1 in case of error.
1821 */
1822 int
1823 xsltRegisterExtModuleTopLevel(const xmlChar * name, const xmlChar * URI,
1824 xsltTopLevelFunction function)
1825 {
1826 if ((name == NULL) || (URI == NULL) || (function == NULL))
1827 return (-1);
1828
1829 if (xsltTopLevelsHash == NULL)
1830 xsltTopLevelsHash = xmlHashCreate(10);
1831 if (xsltTopLevelsHash == NULL)
1832 return (-1);
1833
1834 xmlMutexLock(xsltExtMutex);
1835
1836 xmlHashUpdateEntry2(xsltTopLevelsHash, name, URI,
1837 XML_CAST_FPTR(function), NULL);
1838
1839 xmlMutexUnlock(xsltExtMutex);
1840
1841 return (0);
1842 }
1843
1844 /**
1845 * xsltExtModuleTopLevelLookup:
1846 * @name: the top-level element name
1847 * @URI: the top-level element namespace URI
1848 *
1849 * Looks up an extension module top-level element
1850 *
1851 * Returns the callback function if found, NULL otherwise.
1852 */
1853 xsltTopLevelFunction
1854 xsltExtModuleTopLevelLookup(const xmlChar * name, const xmlChar * URI)
1855 {
1856 xsltTopLevelFunction ret;
1857
1858 if ((xsltTopLevelsHash == NULL) || (name == NULL) || (URI == NULL))
1859 return (NULL);
1860
1861 xmlMutexLock(xsltExtMutex);
1862
1863 XML_CAST_FPTR(ret) = xmlHashLookup2(xsltTopLevelsHash, name, URI);
1864
1865 xmlMutexUnlock(xsltExtMutex);
1866
1867 /* if lookup fails, attempt a dynamic load on supported platforms */
1868 if (NULL == ret) {
1869 if (!xsltExtModuleRegisterDynamic(URI)) {
1870 xmlMutexLock(xsltExtMutex);
1871
1872 XML_CAST_FPTR(ret) = xmlHashLookup2(xsltTopLevelsHash, name, URI);
1873
1874 xmlMutexUnlock(xsltExtMutex);
1875 }
1876 }
1877
1878 return (ret);
1879 }
1880
1881 /**
1882 * xsltUnregisterExtModuleTopLevel:
1883 * @name: the top-level element name
1884 * @URI: the top-level element namespace URI
1885 *
1886 * Unregisters an extension module top-level element
1887 *
1888 * Returns 0 if successful, -1 in case of error.
1889 */
1890 int
1891 xsltUnregisterExtModuleTopLevel(const xmlChar * name, const xmlChar * URI)
1892 {
1893 int ret;
1894
1895 if ((xsltTopLevelsHash == NULL) || (name == NULL) || (URI == NULL))
1896 return (-1);
1897
1898 xmlMutexLock(xsltExtMutex);
1899
1900 ret = xmlHashRemoveEntry2(xsltTopLevelsHash, name, URI, NULL);
1901
1902 xmlMutexUnlock(xsltExtMutex);
1903
1904 return(ret);
1905 }
1906
1907 /**
1908 * xsltUnregisterAllExtModuleTopLevel:
1909 *
1910 * Unregisters all extension module function
1911 */
1912 static void
1913 xsltUnregisterAllExtModuleTopLevel(void)
1914 {
1915 xmlMutexLock(xsltExtMutex);
1916
1917 xmlHashFree(xsltTopLevelsHash, NULL);
1918 xsltTopLevelsHash = NULL;
1919
1920 xmlMutexUnlock(xsltExtMutex);
1921 }
1922
1923 /**
1924 * xsltGetExtInfo:
1925 * @style: pointer to a stylesheet
1926 * @URI: the namespace URI desired
1927 *
1928 * looks up URI in extInfos of the stylesheet
1929 *
1930 * returns a pointer to the hash table if found, else NULL
1931 */
1932 xmlHashTablePtr
1933 xsltGetExtInfo(xsltStylesheetPtr style, const xmlChar * URI)
1934 {
1935 xsltExtDataPtr data;
1936
1937 /*
1938 * TODO: Why do we have a return type of xmlHashTablePtr?
1939 * Is the user-allocated data for extension modules expected
1940 * to be a xmlHashTablePtr only? Or is this intended for
1941 * the EXSLT module only?
1942 */
1943
1944 if (style != NULL && style->extInfos != NULL) {
1945 data = xmlHashLookup(style->extInfos, URI);
1946 if (data != NULL && data->extData != NULL)
1947 return data->extData;
1948 }
1949 return NULL;
1950 }
1951
1952 /************************************************************************
1953 * *
1954 * Test module http://xmlsoft.org/XSLT/ *
1955 * *
1956 ************************************************************************/
1957
1958 /************************************************************************
1959 * *
1960 * Test of the extension module API *
1961 * *
1962 ************************************************************************/
1963
1964 static xmlChar *testData = NULL;
1965 static xmlChar *testStyleData = NULL;
1966
1967 /**
1968 * xsltExtFunctionTest:
1969 * @ctxt: the XPath Parser context
1970 * @nargs: the number of arguments
1971 *
1972 * function libxslt:test() for testing the extensions support.
1973 */
1974 static void
1975 xsltExtFunctionTest(xmlXPathParserContextPtr ctxt,
1976 int nargs ATTRIBUTE_UNUSED)
1977 {
1978 xsltTransformContextPtr tctxt;
1979 void *data = NULL;
1980
1981 tctxt = xsltXPathGetTransformContext(ctxt);
1982
1983 if (testData == NULL) {
1984 xsltGenericDebug(xsltGenericDebugContext,
1985 "xsltExtFunctionTest: not initialized,"
1986 " calling xsltGetExtData\n");
1987 data = xsltGetExtData(tctxt, (const xmlChar *) XSLT_DEFAULT_URL);
1988 if (data == NULL) {
1989 xsltTransformError(tctxt, NULL, NULL,
1990 "xsltExtElementTest: not initialized\n");
1991 return;
1992 }
1993 }
1994 if (tctxt == NULL) {
1995 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
1996 "xsltExtFunctionTest: failed to get the transformation context\n");
1997 return;
1998 }
1999 if (data == NULL)
2000 data = xsltGetExtData(tctxt, (const xmlChar *) XSLT_DEFAULT_URL);
2001 if (data == NULL) {
2002 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
2003 "xsltExtFunctionTest: failed to get module data\n");
2004 return;
2005 }
2006 if (data != testData) {
2007 xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
2008 "xsltExtFunctionTest: got wrong module data\n");
2009 return;
2010 }
2011 #ifdef WITH_XSLT_DEBUG_FUNCTION
2012 xsltGenericDebug(xsltGenericDebugContext,
2013 "libxslt:test() called with %d args\n", nargs);
2014 #endif
2015 }
2016
2017 /**
2018 * xsltExtElementPreCompTest:
2019 * @style: the stylesheet
2020 * @inst: the instruction in the stylesheet
2021 *
2022 * Process a libxslt:test node
2023 */
2024 static xsltElemPreCompPtr
2025 xsltExtElementPreCompTest(xsltStylesheetPtr style, xmlNodePtr inst,
2026 xsltTransformFunction function)
2027 {
2028 xsltElemPreCompPtr ret;
2029
2030 if (style == NULL) {
2031 xsltTransformError(NULL, NULL, inst,
2032 "xsltExtElementTest: no transformation context\n");
2033 return (NULL);
2034 }
2035 if (testStyleData == NULL) {
2036 xsltGenericDebug(xsltGenericDebugContext,
2037 "xsltExtElementPreCompTest: not initialized,"
2038 " calling xsltStyleGetExtData\n");
2039 xsltStyleGetExtData(style, (const xmlChar *) XSLT_DEFAULT_URL);
2040 if (testStyleData == NULL) {
2041 xsltTransformError(NULL, style, inst,
2042 "xsltExtElementPreCompTest: not initialized\n");
2043 if (style != NULL)
2044 style->errors++;
2045 return (NULL);
2046 }
2047 }
2048 if (inst == NULL) {
2049 xsltTransformError(NULL, style, inst,
2050 "xsltExtElementPreCompTest: no instruction\n");
2051 if (style != NULL)
2052 style->errors++;
2053 return (NULL);
2054 }
2055 ret = xsltNewElemPreComp(style, inst, function);
2056 return (ret);
2057 }
2058
2059 /**
2060 * xsltExtElementTest:
2061 * @ctxt: an XSLT processing context
2062 * @node: The current node
2063 * @inst: the instruction in the stylesheet
2064 * @comp: precomputed informations
2065 *
2066 * Process a libxslt:test node
2067 */
2068 static void
2069 xsltExtElementTest(xsltTransformContextPtr ctxt, xmlNodePtr node,
2070 xmlNodePtr inst,
2071 xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
2072 {
2073 xmlNodePtr commentNode;
2074
2075 if (testData == NULL) {
2076 xsltGenericDebug(xsltGenericDebugContext,
2077 "xsltExtElementTest: not initialized,"
2078 " calling xsltGetExtData\n");
2079 xsltGetExtData(ctxt, (const xmlChar *) XSLT_DEFAULT_URL);
2080 if (testData == NULL) {
2081 xsltTransformError(ctxt, NULL, inst,
2082 "xsltExtElementTest: not initialized\n");
2083 return;
2084 }
2085 }
2086 if (ctxt == NULL) {
2087 xsltTransformError(ctxt, NULL, inst,
2088 "xsltExtElementTest: no transformation context\n");
2089 return;
2090 }
2091 if (node == NULL) {
2092 xsltTransformError(ctxt, NULL, inst,
2093 "xsltExtElementTest: no current node\n");
2094 return;
2095 }
2096 if (inst == NULL) {
2097 xsltTransformError(ctxt, NULL, inst,
2098 "xsltExtElementTest: no instruction\n");
2099 return;
2100 }
2101 if (ctxt->insert == NULL) {
2102 xsltTransformError(ctxt, NULL, inst,
2103 "xsltExtElementTest: no insertion point\n");
2104 return;
2105 }
2106 commentNode = xmlNewComment((const xmlChar *)
2107 "libxslt:test element test worked");
2108 xmlAddChild(ctxt->insert, commentNode);
2109 }
2110
2111 /**
2112 * xsltExtInitTest:
2113 * @ctxt: an XSLT transformation context
2114 * @URI: the namespace URI for the extension
2115 *
2116 * A function called at initialization time of an XSLT extension module
2117 *
2118 * Returns a pointer to the module specific data for this transformation
2119 */
2120 static void *
2121 xsltExtInitTest(xsltTransformContextPtr ctxt, const xmlChar * URI)
2122 {
2123 if (testStyleData == NULL) {
2124 xsltGenericDebug(xsltGenericErrorContext,
2125 "xsltExtInitTest: not initialized,"
2126 " calling xsltStyleGetExtData\n");
2127 testStyleData = xsltStyleGetExtData(ctxt->style, URI);
2128 if (testStyleData == NULL) {
2129 xsltTransformError(ctxt, NULL, NULL,
2130 "xsltExtInitTest: not initialized\n");
2131 return (NULL);
2132 }
2133 }
2134 if (testData != NULL) {
2135 xsltTransformError(ctxt, NULL, NULL,
2136 "xsltExtInitTest: already initialized\n");
2137 return (NULL);
2138 }
2139 testData = (void *) "test data";
2140 xsltGenericDebug(xsltGenericDebugContext,
2141 "Registered test module : %s\n", URI);
2142 return (testData);
2143 }
2144
2145
2146 /**
2147 * xsltExtShutdownTest:
2148 * @ctxt: an XSLT transformation context
2149 * @URI: the namespace URI for the extension
2150 * @data: the data associated to this module
2151 *
2152 * A function called at shutdown time of an XSLT extension module
2153 */
2154 static void
2155 xsltExtShutdownTest(xsltTransformContextPtr ctxt,
2156 const xmlChar * URI, void *data)
2157 {
2158 if (testData == NULL) {
2159 xsltTransformError(ctxt, NULL, NULL,
2160 "xsltExtShutdownTest: not initialized\n");
2161 return;
2162 }
2163 if (data != testData) {
2164 xsltTransformError(ctxt, NULL, NULL,
2165 "xsltExtShutdownTest: wrong data\n");
2166 }
2167 testData = NULL;
2168 xsltGenericDebug(xsltGenericDebugContext,
2169 "Unregistered test module : %s\n", URI);
2170 }
2171
2172 /**
2173 * xsltExtStyleInitTest:
2174 * @style: an XSLT stylesheet
2175 * @URI: the namespace URI for the extension
2176 *
2177 * A function called at initialization time of an XSLT extension module
2178 *
2179 * Returns a pointer to the module specific data for this transformation
2180 */
2181 static void *
2182 xsltExtStyleInitTest(xsltStylesheetPtr style ATTRIBUTE_UNUSED,
2183 const xmlChar * URI)
2184 {
2185 if (testStyleData != NULL) {
2186 xsltTransformError(NULL, NULL, NULL,
2187 "xsltExtInitTest: already initialized\n");
2188 return (NULL);
2189 }
2190 testStyleData = (void *) "test data";
2191 xsltGenericDebug(xsltGenericDebugContext,
2192 "Registered test module : %s\n", URI);
2193 return (testStyleData);
2194 }
2195
2196
2197 /**
2198 * xsltExtStyleShutdownTest:
2199 * @style: an XSLT stylesheet
2200 * @URI: the namespace URI for the extension
2201 * @data: the data associated to this module
2202 *
2203 * A function called at shutdown time of an XSLT extension module
2204 */
2205 static void
2206 xsltExtStyleShutdownTest(xsltStylesheetPtr style ATTRIBUTE_UNUSED,
2207 const xmlChar * URI, void *data)
2208 {
2209 if (testStyleData == NULL) {
2210 xsltGenericError(xsltGenericErrorContext,
2211 "xsltExtShutdownTest: not initialized\n");
2212 return;
2213 }
2214 if (data != testStyleData) {
2215 xsltTransformError(NULL, NULL, NULL,
2216 "xsltExtShutdownTest: wrong data\n");
2217 }
2218 testStyleData = NULL;
2219 xsltGenericDebug(xsltGenericDebugContext,
2220 "Unregistered test module : %s\n", URI);
2221 }
2222
2223 /**
2224 * xsltRegisterTestModule:
2225 *
2226 * Registers the test module
2227 */
2228 void
2229 xsltRegisterTestModule(void)
2230 {
2231 xsltInitGlobals();
2232 xsltRegisterExtModuleFull((const xmlChar *) XSLT_DEFAULT_URL,
2233 xsltExtInitTest, xsltExtShutdownTest,
2234 xsltExtStyleInitTest,
2235 xsltExtStyleShutdownTest);
2236 xsltRegisterExtModuleFunction((const xmlChar *) "test",
2237 (const xmlChar *) XSLT_DEFAULT_URL,
2238 xsltExtFunctionTest);
2239 xsltRegisterExtModuleElement((const xmlChar *) "test",
2240 (const xmlChar *) XSLT_DEFAULT_URL,
2241 xsltExtElementPreCompTest,
2242 xsltExtElementTest);
2243 }
2244
2245 static void
2246 xsltHashScannerModuleFree(void *payload ATTRIBUTE_UNUSED,
2247 void *data ATTRIBUTE_UNUSED,
2248 xmlChar * name ATTRIBUTE_UNUSED)
2249 {
2250 #ifdef WITH_MODULES
2251 xmlModuleClose(payload);
2252 #endif
2253 }
2254
2255 /**
2256 * xsltInitGlobals:
2257 *
2258 * Initialize the global variables for extensions
2259 */
2260 void
2261 xsltInitGlobals(void)
2262 {
2263 if (xsltExtMutex == NULL) {
2264 xsltExtMutex = xmlNewMutex();
2265 }
2266 }
2267
2268 /**
2269 * xsltCleanupGlobals:
2270 *
2271 * Unregister all global variables set up by the XSLT library
2272 */
2273 void
2274 xsltCleanupGlobals(void)
2275 {
2276 xsltUnregisterAllExtModules();
2277 xsltUnregisterAllExtModuleFunction();
2278 xsltUnregisterAllExtModuleElement();
2279 xsltUnregisterAllExtModuleTopLevel();
2280
2281 xmlMutexLock(xsltExtMutex);
2282 /* cleanup dynamic module hash */
2283 if (NULL != xsltModuleHash) {
2284 xmlHashScan(xsltModuleHash, xsltHashScannerModuleFree, 0);
2285 xmlHashFree(xsltModuleHash, NULL);
2286 xsltModuleHash = NULL;
2287 }
2288 xmlMutexUnlock(xsltExtMutex);
2289
2290 xmlFreeMutex(xsltExtMutex);
2291 xsltExtMutex = NULL;
2292 xsltFreeLocales();
2293 xsltUninit();
2294 }
2295
2296 static void
2297 xsltDebugDumpExtensionsCallback(void *function ATTRIBUTE_UNUSED,
2298 FILE * output, const xmlChar * name,
2299 const xmlChar * URI,
2300 const xmlChar * not_used ATTRIBUTE_UNUSED)
2301 {
2302 if (!name || !URI)
2303 return;
2304 fprintf(output, "{%s}%s\n", URI, name);
2305 }
2306
2307 static void
2308 xsltDebugDumpExtModulesCallback(void *function ATTRIBUTE_UNUSED,
2309 FILE * output, const xmlChar * URI,
2310 const xmlChar * not_used ATTRIBUTE_UNUSED,
2311 const xmlChar * not_used2 ATTRIBUTE_UNUSED)
2312 {
2313 if (!URI)
2314 return;
2315 fprintf(output, "%s\n", URI);
2316 }
2317
2318 /**
2319 * xsltDebugDumpExtensions:
2320 * @output: the FILE * for the output, if NULL stdout is used
2321 *
2322 * Dumps a list of the registered XSLT extension functions and elements
2323 */
2324 void
2325 xsltDebugDumpExtensions(FILE * output)
2326 {
2327 if (output == NULL)
2328 output = stdout;
2329 fprintf(output,
2330 "Registered XSLT Extensions\n--------------------------\n");
2331 if (!xsltFunctionsHash)
2332 fprintf(output, "No registered extension functions\n");
2333 else {
2334 fprintf(output, "Registered Extension Functions:\n");
2335 xmlMutexLock(xsltExtMutex);
2336 xmlHashScanFull(xsltFunctionsHash,
2337 (xmlHashScannerFull)
2338 xsltDebugDumpExtensionsCallback, output);
2339 xmlMutexUnlock(xsltExtMutex);
2340 }
2341 if (!xsltElementsHash)
2342 fprintf(output, "\nNo registered extension elements\n");
2343 else {
2344 fprintf(output, "\nRegistered Extension Elements:\n");
2345 xmlMutexLock(xsltExtMutex);
2346 xmlHashScanFull(xsltElementsHash,
2347 (xmlHashScannerFull)
2348 xsltDebugDumpExtensionsCallback, output);
2349 xmlMutexUnlock(xsltExtMutex);
2350 }
2351 if (!xsltExtensionsHash)
2352 fprintf(output, "\nNo registered extension modules\n");
2353 else {
2354 fprintf(output, "\nRegistered Extension Modules:\n");
2355 xmlMutexLock(xsltExtMutex);
2356 xmlHashScanFull(xsltExtensionsHash,
2357 (xmlHashScannerFull)
2358 xsltDebugDumpExtModulesCallback, output);
2359 xmlMutexUnlock(xsltExtMutex);
2360 }
2361
2362 }