Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-19 13:33:42 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/dll/3rdparty/libxslt/extensions.c
Thomas Faber 5c0faa58cf
[LIBXSLT] Update to version 1.1.32. CORE-14291
2018-02-05 14:37:37 +01:00

2347 lines
61 KiB
C
Raw Blame History

/*
* extensions.c: Implemetation of the extensions support
*
* Reference:
* http://www.w3.org/TR/1999/REC-xslt-19991116
*
* See Copyright for the status of this software.
*
* daniel@veillard.com
*/
#include "precomp.h"
#ifdef WITH_MODULES
#include <libxml/xmlmodule.h>
#endif
#include <libxml/list.h>
#ifdef _WIN32
#ifndef PATH_MAX
#define PATH_MAX _MAX_PATH
#endif
#endif
#ifdef WITH_XSLT_DEBUG
#define WITH_XSLT_DEBUG_EXTENSIONS
#endif
/************************************************************************
* *
* Private Types and Globals *
* *
************************************************************************/
typedef struct _xsltExtDef xsltExtDef;
typedef xsltExtDef *xsltExtDefPtr;
struct _xsltExtDef {
struct _xsltExtDef *next;
xmlChar *prefix;
xmlChar *URI;
void *data;
};
typedef struct _xsltExtModule xsltExtModule;
typedef xsltExtModule *xsltExtModulePtr;
struct _xsltExtModule {
xsltExtInitFunction initFunc;
xsltExtShutdownFunction shutdownFunc;
xsltStyleExtInitFunction styleInitFunc;
xsltStyleExtShutdownFunction styleShutdownFunc;
};
typedef struct _xsltExtData xsltExtData;
typedef xsltExtData *xsltExtDataPtr;
struct _xsltExtData {
xsltExtModulePtr extModule;
void *extData;
};
typedef struct _xsltExtElement xsltExtElement;
typedef xsltExtElement *xsltExtElementPtr;
struct _xsltExtElement {
xsltPreComputeFunction precomp;
xsltTransformFunction transform;
};
static xmlHashTablePtr xsltExtensionsHash = NULL;
static xmlHashTablePtr xsltFunctionsHash = NULL;
static xmlHashTablePtr xsltElementsHash = NULL;
static xmlHashTablePtr xsltTopLevelsHash = NULL;
static xmlHashTablePtr xsltModuleHash = NULL;
static xmlMutexPtr xsltExtMutex = NULL;
/************************************************************************
* *
* Type functions *
* *
************************************************************************/
/**
* xsltNewExtDef:
* @prefix: the extension prefix
* @URI: the namespace URI
*
* Create a new XSLT ExtDef
*
* Returns the newly allocated xsltExtDefPtr or NULL in case of error
*/
static xsltExtDefPtr
xsltNewExtDef(const xmlChar * prefix, const xmlChar * URI)
{
xsltExtDefPtr cur;
cur = (xsltExtDefPtr) xmlMalloc(sizeof(xsltExtDef));
if (cur == NULL) {
xsltTransformError(NULL, NULL, NULL,
"xsltNewExtDef : malloc failed\n");
return (NULL);
}
memset(cur, 0, sizeof(xsltExtDef));
if (prefix != NULL)
cur->prefix = xmlStrdup(prefix);
if (URI != NULL)
cur->URI = xmlStrdup(URI);
return (cur);
}
/**
* xsltFreeExtDef:
* @extensiond: an XSLT extension definition
*
* Free up the memory allocated by @extensiond
*/
static void
xsltFreeExtDef(xsltExtDefPtr extensiond)
{
if (extensiond == NULL)
return;
if (extensiond->prefix != NULL)
xmlFree(extensiond->prefix);
if (extensiond->URI != NULL)
xmlFree(extensiond->URI);
xmlFree(extensiond);
}
/**
* xsltFreeExtDefList:
* @extensiond: an XSLT extension definition list
*
* Free up the memory allocated by all the elements of @extensiond
*/
static void
xsltFreeExtDefList(xsltExtDefPtr extensiond)
{
xsltExtDefPtr cur;
while (extensiond != NULL) {
cur = extensiond;
extensiond = extensiond->next;
xsltFreeExtDef(cur);
}
}
/**
* xsltNewExtModule:
* @initFunc: the module initialization function
* @shutdownFunc: the module shutdown function
* @styleInitFunc: the stylesheet module data allocator function
* @styleShutdownFunc: the stylesheet module data free function
*
* Create a new XSLT extension module
*
* Returns the newly allocated xsltExtModulePtr or NULL in case of error
*/
static xsltExtModulePtr
xsltNewExtModule(xsltExtInitFunction initFunc,
xsltExtShutdownFunction shutdownFunc,
xsltStyleExtInitFunction styleInitFunc,
xsltStyleExtShutdownFunction styleShutdownFunc)
{
xsltExtModulePtr cur;
cur = (xsltExtModulePtr) xmlMalloc(sizeof(xsltExtModule));
if (cur == NULL) {
xsltTransformError(NULL, NULL, NULL,
"xsltNewExtModule : malloc failed\n");
return (NULL);
}
cur->initFunc = initFunc;
cur->shutdownFunc = shutdownFunc;
cur->styleInitFunc = styleInitFunc;
cur->styleShutdownFunc = styleShutdownFunc;
return (cur);
}
/**
* xsltFreeExtModule:
* @ext: an XSLT extension module
*
* Free up the memory allocated by @ext
*/
static void
xsltFreeExtModule(xsltExtModulePtr ext)
{
if (ext == NULL)
return;
xmlFree(ext);
}
/**
* xsltNewExtData:
* @extModule: the module
* @extData: the associated data
*
* Create a new XSLT extension module data wrapper
*
* Returns the newly allocated xsltExtDataPtr or NULL in case of error
*/
static xsltExtDataPtr
xsltNewExtData(xsltExtModulePtr extModule, void *extData)
{
xsltExtDataPtr cur;
if (extModule == NULL)
return (NULL);
cur = (xsltExtDataPtr) xmlMalloc(sizeof(xsltExtData));
if (cur == NULL) {
xsltTransformError(NULL, NULL, NULL,
"xsltNewExtData : malloc failed\n");
return (NULL);
}
cur->extModule = extModule;
cur->extData = extData;
return (cur);
}
/**
* xsltFreeExtData:
* @ext: an XSLT extension module data wrapper
*
* Free up the memory allocated by @ext
*/
static void
xsltFreeExtData(xsltExtDataPtr ext)
{
if (ext == NULL)
return;
xmlFree(ext);
}
/**
* xsltNewExtElement:
* @precomp: the pre-computation function
* @transform: the transformation function
*
* Create a new XSLT extension element
*
* Returns the newly allocated xsltExtElementPtr or NULL in case of
* error
*/
static xsltExtElementPtr
xsltNewExtElement(xsltPreComputeFunction precomp,
xsltTransformFunction transform)
{
xsltExtElementPtr cur;
if (transform == NULL)
return (NULL);
cur = (xsltExtElementPtr) xmlMalloc(sizeof(xsltExtElement));
if (cur == NULL) {
xsltTransformError(NULL, NULL, NULL,
"xsltNewExtElement : malloc failed\n");
return (NULL);
}
cur->precomp = precomp;
cur->transform = transform;
return (cur);
}
/**
* xsltFreeExtElement:
* @ext: an XSLT extension element
*
* Frees up the memory allocated by @ext
*/
static void
xsltFreeExtElement(xsltExtElementPtr ext)
{
if (ext == NULL)
return;
xmlFree(ext);
}
#ifdef WITH_MODULES
typedef void (*exsltRegisterFunction) (void);
#ifndef PATH_MAX
#define PATH_MAX 4096
#endif
/**
* xsltExtModuleRegisterDynamic:
* @URI: the function or element namespace URI
*
* Dynamically loads an extension plugin when available.
*
* The plugin name is derived from the URI by removing the
* initial protocol designation, e.g. "http://", then converting
* the characters ".", "-", "/", and "\" into "_", the removing
* any trailing "/", then concatenating LIBXML_MODULE_EXTENSION.
*
* Plugins are loaded from the directory specified by the
* environment variable LIBXSLT_PLUGINS_PATH, or if NULL,
* by LIBXSLT_DEFAULT_PLUGINS_PATH() which is determined at
* compile time.
*
* Returns 0 if successful, -1 in case of error.
*/
static int
xsltExtModuleRegisterDynamic(const xmlChar * URI)
{
xmlModulePtr m;
exsltRegisterFunction regfunc;
xmlChar *ext_name;
char module_filename[PATH_MAX];
const xmlChar *ext_directory = NULL;
const xmlChar *protocol = NULL;
xmlChar *i, *regfunc_name;
void *vregfunc;
int rc;
/* check for bad inputs */
if (URI == NULL)
return (-1);
if (NULL == xsltModuleHash) {
xsltModuleHash = xmlHashCreate(5);
if (xsltModuleHash == NULL)
return (-1);
}
xmlMutexLock(xsltExtMutex);
/* have we attempted to register this module already? */
if (xmlHashLookup(xsltModuleHash, URI) != NULL) {
xmlMutexUnlock(xsltExtMutex);
return (-1);
}
xmlMutexUnlock(xsltExtMutex);
/* transform extension namespace into a module name */
protocol = xmlStrstr(URI, BAD_CAST "://");
if (protocol == NULL) {
ext_name = xmlStrdup(URI);
} else {
ext_name = xmlStrdup(protocol + 3);
}
if (ext_name == NULL) {
return (-1);
}
i = ext_name;
while ('\0' != *i) {
if (('/' == *i) || ('\\' == *i) || ('.' == *i) || ('-' == *i))
*i = '_';
i++;
}
/* Strip underscores from end of string. */
while (i > ext_name && *(i - 1) == '_') {
i--;
*i = '\0';
}
/* determine module directory */
ext_directory = (xmlChar *) getenv("LIBXSLT_PLUGINS_PATH");
if (NULL == ext_directory) {
ext_directory = BAD_CAST LIBXSLT_DEFAULT_PLUGINS_PATH();
if (NULL == ext_directory)
return (-1);
}
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
else
xsltGenericDebug(xsltGenericDebugContext,
"LIBXSLT_PLUGINS_PATH is %s\n", ext_directory);
#endif
/* build the module filename, and confirm the module exists */
xmlStrPrintf((xmlChar *) module_filename, sizeof(module_filename),
"%s/%s%s", ext_directory, ext_name, LIBXML_MODULE_EXTENSION);
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Attempting to load plugin: %s for URI: %s\n",
module_filename, URI);
#endif
if (1 != xmlCheckFilename(module_filename)) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"xmlCheckFilename failed for plugin: %s\n", module_filename);
#endif
xmlFree(ext_name);
return (-1);
}
/* attempt to open the module */
m = xmlModuleOpen(module_filename, 0);
if (NULL == m) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"xmlModuleOpen failed for plugin: %s\n", module_filename);
#endif
xmlFree(ext_name);
return (-1);
}
/* construct initialization func name */
regfunc_name = xmlStrdup(ext_name);
regfunc_name = xmlStrcat(regfunc_name, BAD_CAST "_init");
vregfunc = NULL;
rc = xmlModuleSymbol(m, (const char *) regfunc_name, &vregfunc);
regfunc = vregfunc;
if (0 == rc) {
/*
* Call the module's init function. Note that this function
* calls xsltRegisterExtModuleFull which will add the module
* to xsltExtensionsHash (together with it's entry points).
*/
(*regfunc) ();
/* register this module in our hash */
xmlMutexLock(xsltExtMutex);
xmlHashAddEntry(xsltModuleHash, URI, (void *) m);
xmlMutexUnlock(xsltExtMutex);
} else {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"xmlModuleSymbol failed for plugin: %s, regfunc: %s\n",
module_filename, regfunc_name);
#endif
/* if regfunc not found unload the module immediately */
xmlModuleClose(m);
}
xmlFree(ext_name);
xmlFree(regfunc_name);
return (NULL == regfunc) ? -1 : 0;
}
#else
static int
xsltExtModuleRegisterDynamic(const xmlChar * URI ATTRIBUTE_UNUSED)
{
return -1;
}
#endif
/************************************************************************
* *
* The stylesheet extension prefixes handling *
* *
************************************************************************/
/**
* xsltFreeExts:
* @style: an XSLT stylesheet
*
* Free up the memory used by XSLT extensions in a stylesheet
*/
void
xsltFreeExts(xsltStylesheetPtr style)
{
if (style->nsDefs != NULL)
xsltFreeExtDefList((xsltExtDefPtr) style->nsDefs);
}
/**
* xsltRegisterExtPrefix:
* @style: an XSLT stylesheet
* @prefix: the prefix used (optional)
* @URI: the URI associated to the extension
*
* Registers an extension namespace
* This is called from xslt.c during compile-time.
* The given prefix is not needed.
* Called by:
* xsltParseExtElemPrefixes() (new function)
* xsltRegisterExtPrefix() (old function)
*
* Returns 0 in case of success, 1 if the @URI was already
* registered as an extension namespace and
* -1 in case of failure
*/
int
xsltRegisterExtPrefix(xsltStylesheetPtr style,
const xmlChar * prefix, const xmlChar * URI)
{
xsltExtDefPtr def, ret;
if ((style == NULL) || (URI == NULL))
return (-1);
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Registering extension namespace '%s'.\n", URI);
#endif
def = (xsltExtDefPtr) style->nsDefs;
#ifdef XSLT_REFACTORED
/*
* The extension is associated with a namespace name.
*/
while (def != NULL) {
if (xmlStrEqual(URI, def->URI))
return (1);
def = def->next;
}
#else
while (def != NULL) {
if (xmlStrEqual(prefix, def->prefix))
return (-1);
def = def->next;
}
#endif
ret = xsltNewExtDef(prefix, URI);
if (ret == NULL)
return (-1);
ret->next = (xsltExtDefPtr) style->nsDefs;
style->nsDefs = ret;
/*
* check whether there is an extension module with a stylesheet
* initialization function.
*/
#ifdef XSLT_REFACTORED
/*
* Don't initialize modules based on specified namespaces via
* the attribute "[xsl:]extension-element-prefixes".
*/
#else
if (xsltExtensionsHash != NULL) {
xsltExtModulePtr module;
xmlMutexLock(xsltExtMutex);
module = xmlHashLookup(xsltExtensionsHash, URI);
xmlMutexUnlock(xsltExtMutex);
if (NULL == module) {
if (!xsltExtModuleRegisterDynamic(URI)) {
xmlMutexLock(xsltExtMutex);
module = xmlHashLookup(xsltExtensionsHash, URI);
xmlMutexUnlock(xsltExtMutex);
}
}
if (module != NULL) {
xsltStyleGetExtData(style, URI);
}
}
#endif
return (0);
}
/************************************************************************
* *
* The extensions modules interfaces *
* *
************************************************************************/
/**
* xsltRegisterExtFunction:
* @ctxt: an XSLT transformation context
* @name: the name of the element
* @URI: the URI associated to the element
* @function: the actual implementation which should be called
*
* Registers an extension function
*
* Returns 0 in case of success, -1 in case of failure
*/
int
xsltRegisterExtFunction(xsltTransformContextPtr ctxt, const xmlChar * name,
const xmlChar * URI, xmlXPathFunction function)
{
int ret;
if ((ctxt == NULL) || (name == NULL) ||
(URI == NULL) || (function == NULL))
return (-1);
if (ctxt->xpathCtxt != NULL) {
xmlXPathRegisterFuncNS(ctxt->xpathCtxt, name, URI, function);
}
if (ctxt->extFunctions == NULL)
ctxt->extFunctions = xmlHashCreate(10);
if (ctxt->extFunctions == NULL)
return (-1);
ret = xmlHashAddEntry2(ctxt->extFunctions, name, URI,
XML_CAST_FPTR(function));
return(ret);
}
/**
* xsltRegisterExtElement:
* @ctxt: an XSLT transformation context
* @name: the name of the element
* @URI: the URI associated to the element
* @function: the actual implementation which should be called
*
* Registers an extension element
*
* Returns 0 in case of success, -1 in case of failure
*/
int
xsltRegisterExtElement(xsltTransformContextPtr ctxt, const xmlChar * name,
const xmlChar * URI, xsltTransformFunction function)
{
if ((ctxt == NULL) || (name == NULL) ||
(URI == NULL) || (function == NULL))
return (-1);
if (ctxt->extElements == NULL)
ctxt->extElements = xmlHashCreate(10);
if (ctxt->extElements == NULL)
return (-1);
return (xmlHashAddEntry2
(ctxt->extElements, name, URI, XML_CAST_FPTR(function)));
}
/**
* xsltFreeCtxtExts:
* @ctxt: an XSLT transformation context
*
* Free the XSLT extension data
*/
void
xsltFreeCtxtExts(xsltTransformContextPtr ctxt)
{
if (ctxt->extElements != NULL)
xmlHashFree(ctxt->extElements, NULL);
if (ctxt->extFunctions != NULL)
xmlHashFree(ctxt->extFunctions, NULL);
}
/**
* xsltStyleGetStylesheetExtData:
* @style: an XSLT stylesheet
* @URI: the URI associated to the exension module
*
* Fires the compile-time initialization callback
* of an extension module and returns a container
* holding the user-data (retrieved via the callback).
*
* Returns the create module-data container
* or NULL if such a module was not registered.
*/
static xsltExtDataPtr
xsltStyleInitializeStylesheetModule(xsltStylesheetPtr style,
const xmlChar * URI)
{
xsltExtDataPtr dataContainer;
void *userData = NULL;
xsltExtModulePtr module;
if ((style == NULL) || (URI == NULL))
return(NULL);
if (xsltExtensionsHash == NULL) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Not registered extension module: %s\n", URI);
#endif
return(NULL);
}
xmlMutexLock(xsltExtMutex);
module = xmlHashLookup(xsltExtensionsHash, URI);
xmlMutexUnlock(xsltExtMutex);
if (module == NULL) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Not registered extension module: %s\n", URI);
#endif
return (NULL);
}
/*
* The specified module was registered so initialize it.
*/
if (style->extInfos == NULL) {
style->extInfos = xmlHashCreate(10);
if (style->extInfos == NULL)
return (NULL);
}
/*
* Fire the initialization callback if available.
*/
if (module->styleInitFunc == NULL) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Initializing module with *no* callback: %s\n", URI);
#endif
} else {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Initializing module with callback: %s\n", URI);
#endif
/*
* Fire the initialization callback.
*/
userData = module->styleInitFunc(style, URI);
}
/*
* Store the user-data in the context of the given stylesheet.
*/
dataContainer = xsltNewExtData(module, userData);
if (dataContainer == NULL)
return (NULL);
if (xmlHashAddEntry(style->extInfos, URI,
(void *) dataContainer) < 0)
{
xsltTransformError(NULL, style, NULL,
"Failed to register module '%s'.\n", URI);
style->errors++;
if (module->styleShutdownFunc)
module->styleShutdownFunc(style, URI, userData);
xsltFreeExtData(dataContainer);
return (NULL);
}
return(dataContainer);
}
/**
* xsltStyleGetExtData:
* @style: an XSLT stylesheet
* @URI: the URI associated to the exension module
*
* Retrieve the data associated to the extension module
* in this given stylesheet.
* Called by:
* xsltRegisterExtPrefix(),
* ( xsltExtElementPreCompTest(), xsltExtInitTest )
*
* Returns the pointer or NULL if not present
*/
void *
xsltStyleGetExtData(xsltStylesheetPtr style, const xmlChar * URI)
{
xsltExtDataPtr dataContainer = NULL;
xsltStylesheetPtr tmpStyle;
if ((style == NULL) || (URI == NULL) ||
(xsltExtensionsHash == NULL))
return (NULL);
#ifdef XSLT_REFACTORED
/*
* This is intended for global storage, so only the main
* stylesheet will hold the data.
*/
tmpStyle = style;
while (tmpStyle->parent != NULL)
tmpStyle = tmpStyle->parent;
if (tmpStyle->extInfos != NULL) {
dataContainer =
(xsltExtDataPtr) xmlHashLookup(tmpStyle->extInfos, URI);
if (dataContainer != NULL) {
/*
* The module was already initialized in the context
* of this stylesheet; just return the user-data that
* comes with it.
*/
return(dataContainer->extData);
}
}
#else
/*
* Old behaviour.
*/
tmpStyle = style;
while (tmpStyle != NULL) {
if (tmpStyle->extInfos != NULL) {
dataContainer =
(xsltExtDataPtr) xmlHashLookup(tmpStyle->extInfos, URI);
if (dataContainer != NULL) {
return(dataContainer->extData);
}
}
tmpStyle = xsltNextImport(tmpStyle);
}
tmpStyle = style;
#endif
dataContainer =
xsltStyleInitializeStylesheetModule(tmpStyle, URI);
if (dataContainer != NULL)
return (dataContainer->extData);
return(NULL);
}
#ifdef XSLT_REFACTORED
/**
* xsltStyleStylesheetLevelGetExtData:
* @style: an XSLT stylesheet
* @URI: the URI associated to the exension module
*
* Retrieve the data associated to the extension module in this given
* stylesheet.
*
* Returns the pointer or NULL if not present
*/
void *
xsltStyleStylesheetLevelGetExtData(xsltStylesheetPtr style,
const xmlChar * URI)
{
xsltExtDataPtr dataContainer = NULL;
if ((style == NULL) || (URI == NULL) ||
(xsltExtensionsHash == NULL))
return (NULL);
if (style->extInfos != NULL) {
dataContainer = (xsltExtDataPtr) xmlHashLookup(style->extInfos, URI);
/*
* The module was already initialized in the context
* of this stylesheet; just return the user-data that
* comes with it.
*/
if (dataContainer)
return(dataContainer->extData);
}
dataContainer =
xsltStyleInitializeStylesheetModule(style, URI);
if (dataContainer != NULL)
return (dataContainer->extData);
return(NULL);
}
#endif
/**
* xsltGetExtData:
* @ctxt: an XSLT transformation context
* @URI: the URI associated to the exension module
*
* Retrieve the data associated to the extension module in this given
* transformation.
*
* Returns the pointer or NULL if not present
*/
void *
xsltGetExtData(xsltTransformContextPtr ctxt, const xmlChar * URI)
{
xsltExtDataPtr data;
if ((ctxt == NULL) || (URI == NULL))
return (NULL);
if (ctxt->extInfos == NULL) {
ctxt->extInfos = xmlHashCreate(10);
if (ctxt->extInfos == NULL)
return (NULL);
data = NULL;
} else {
data = (xsltExtDataPtr) xmlHashLookup(ctxt->extInfos, URI);
}
if (data == NULL) {
void *extData;
xsltExtModulePtr module;
xmlMutexLock(xsltExtMutex);
module = xmlHashLookup(xsltExtensionsHash, URI);
xmlMutexUnlock(xsltExtMutex);
if (module == NULL) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Not registered extension module: %s\n", URI);
#endif
return (NULL);
} else {
if (module->initFunc == NULL)
return (NULL);
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Initializing module: %s\n", URI);
#endif
extData = module->initFunc(ctxt, URI);
if (extData == NULL)
return (NULL);
data = xsltNewExtData(module, extData);
if (data == NULL)
return (NULL);
if (xmlHashAddEntry(ctxt->extInfos, URI, (void *) data) < 0) {
xsltTransformError(ctxt, NULL, NULL,
"Failed to register module data: %s\n",
URI);
if (module->shutdownFunc)
module->shutdownFunc(ctxt, URI, extData);
xsltFreeExtData(data);
return (NULL);
}
}
}
return (data->extData);
}
typedef struct _xsltInitExtCtxt xsltInitExtCtxt;
struct _xsltInitExtCtxt {
xsltTransformContextPtr ctxt;
int ret;
};
/**
* xsltInitCtxtExt:
* @styleData: the registered stylesheet data for the module
* @ctxt: the XSLT transformation context + the return value
* @URI: the extension URI
*
* Initializes an extension module
*/
static void
xsltInitCtxtExt(xsltExtDataPtr styleData, xsltInitExtCtxt * ctxt,
const xmlChar * URI)
{
xsltExtModulePtr module;
xsltExtDataPtr ctxtData;
void *extData;
if ((styleData == NULL) || (ctxt == NULL) || (URI == NULL) ||
(ctxt->ret == -1)) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"xsltInitCtxtExt: NULL param or error\n");
#endif
return;
}
module = styleData->extModule;
if ((module == NULL) || (module->initFunc == NULL)) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"xsltInitCtxtExt: no module or no initFunc\n");
#endif
return;
}
ctxtData = (xsltExtDataPtr) xmlHashLookup(ctxt->ctxt->extInfos, URI);
if (ctxtData != NULL) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"xsltInitCtxtExt: already initialized\n");
#endif
return;
}
extData = module->initFunc(ctxt->ctxt, URI);
if (extData == NULL) {
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"xsltInitCtxtExt: no extData\n");
#endif
}
ctxtData = xsltNewExtData(module, extData);
if (ctxtData == NULL) {
ctxt->ret = -1;
return;
}
if (ctxt->ctxt->extInfos == NULL)
ctxt->ctxt->extInfos = xmlHashCreate(10);
if (ctxt->ctxt->extInfos == NULL) {
ctxt->ret = -1;
return;
}
if (xmlHashAddEntry(ctxt->ctxt->extInfos, URI, ctxtData) < 0) {
xsltGenericError(xsltGenericErrorContext,
"Failed to register module data: %s\n", URI);
if (module->shutdownFunc)
module->shutdownFunc(ctxt->ctxt, URI, extData);
xsltFreeExtData(ctxtData);
ctxt->ret = -1;
return;
}
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext, "Registered module %s\n",
URI);
#endif
ctxt->ret++;
}
/**
* xsltInitCtxtExts:
* @ctxt: an XSLT transformation context
*
* Initialize the set of modules with registered stylesheet data
*
* Returns the number of modules initialized or -1 in case of error
*/
int
xsltInitCtxtExts(xsltTransformContextPtr ctxt)
{
xsltStylesheetPtr style;
xsltInitExtCtxt ctx;
if (ctxt == NULL)
return (-1);
style = ctxt->style;
if (style == NULL)
return (-1);
ctx.ctxt = ctxt;
ctx.ret = 0;
while (style != NULL) {
if (style->extInfos != NULL) {
xmlHashScan(style->extInfos,
(xmlHashScanner) xsltInitCtxtExt, &ctx);
if (ctx.ret == -1)
return (-1);
}
style = xsltNextImport(style);
}
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext, "Registered %d modules\n",
ctx.ret);
#endif
return (ctx.ret);
}
/**
* xsltShutdownCtxtExt:
* @data: the registered data for the module
* @ctxt: the XSLT transformation context
* @URI: the extension URI
*
* Shutdown an extension module loaded
*/
static void
xsltShutdownCtxtExt(xsltExtDataPtr data, xsltTransformContextPtr ctxt,
const xmlChar * URI)
{
xsltExtModulePtr module;
if ((data == NULL) || (ctxt == NULL) || (URI == NULL))
return;
module = data->extModule;
if ((module == NULL) || (module->shutdownFunc == NULL))
return;
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Shutting down module : %s\n", URI);
#endif
module->shutdownFunc(ctxt, URI, data->extData);
}
/**
* xsltShutdownCtxtExts:
* @ctxt: an XSLT transformation context
*
* Shutdown the set of modules loaded
*/
void
xsltShutdownCtxtExts(xsltTransformContextPtr ctxt)
{
if (ctxt == NULL)
return;
if (ctxt->extInfos == NULL)
return;
xmlHashScan(ctxt->extInfos, (xmlHashScanner) xsltShutdownCtxtExt,
ctxt);
xmlHashFree(ctxt->extInfos, (xmlHashDeallocator) xsltFreeExtData);
ctxt->extInfos = NULL;
}
/**
* xsltShutdownExt:
* @data: the registered data for the module
* @ctxt: the XSLT stylesheet
* @URI: the extension URI
*
* Shutdown an extension module loaded
*/
static void
xsltShutdownExt(xsltExtDataPtr data, xsltStylesheetPtr style,
const xmlChar * URI)
{
xsltExtModulePtr module;
if ((data == NULL) || (style == NULL) || (URI == NULL))
return;
module = data->extModule;
if ((module == NULL) || (module->styleShutdownFunc == NULL))
return;
#ifdef WITH_XSLT_DEBUG_EXTENSIONS
xsltGenericDebug(xsltGenericDebugContext,
"Shutting down module : %s\n", URI);
#endif
module->styleShutdownFunc(style, URI, data->extData);
/*
* Don't remove the entry from the hash table here, since
* this will produce segfaults - this fixes bug #340624.
*
* xmlHashRemoveEntry(style->extInfos, URI,
* (xmlHashDeallocator) xsltFreeExtData);
*/
}
/**
* xsltShutdownExts:
* @style: an XSLT stylesheet
*
* Shutdown the set of modules loaded
*/
void
xsltShutdownExts(xsltStylesheetPtr style)
{
if (style == NULL)
return;
if (style->extInfos == NULL)
return;
xmlHashScan(style->extInfos, (xmlHashScanner) xsltShutdownExt, style);
xmlHashFree(style->extInfos, (xmlHashDeallocator) xsltFreeExtData);
style->extInfos = NULL;
}
/**
* xsltCheckExtPrefix:
* @style: the stylesheet
* @URI: the namespace prefix (possibly NULL)
*
* Check if the given prefix is one of the declared extensions.
* This is intended to be called only at compile-time.
* Called by:
* xsltGetInheritedNsList() (xslt.c)
* xsltParseTemplateContent (xslt.c)
*
* Returns 1 if this is an extension, 0 otherwise
*/
int
xsltCheckExtPrefix(xsltStylesheetPtr style, const xmlChar * URI)
{
#ifdef XSLT_REFACTORED
if ((style == NULL) || (style->compCtxt == NULL) ||
(XSLT_CCTXT(style)->inode == NULL) ||
(XSLT_CCTXT(style)->inode->extElemNs == NULL))
return (0);
/*
* Lookup the extension namespaces registered
* at the current node in the stylesheet's tree.
*/
if (XSLT_CCTXT(style)->inode->extElemNs != NULL) {
int i;
xsltPointerListPtr list = XSLT_CCTXT(style)->inode->extElemNs;
for (i = 0; i < list->number; i++) {
if (xmlStrEqual((const xmlChar *) list->items[i],
URI))
{
return(1);
}
}
}
#else
xsltExtDefPtr cur;
if ((style == NULL) || (style->nsDefs == NULL))
return (0);
if (URI == NULL)
URI = BAD_CAST "#default";
cur = (xsltExtDefPtr) style->nsDefs;
while (cur != NULL) {
/*
* NOTE: This was change to work on namespace names rather
* than namespace prefixes. This fixes bug #339583.
* TODO: Consider renaming the field "prefix" of xsltExtDef
* to "href".
*/
if (xmlStrEqual(URI, cur->prefix))
return (1);
cur = cur->next;
}
#endif
return (0);
}
/**
* xsltCheckExtURI:
* @style: the stylesheet
* @URI: the namespace URI (possibly NULL)
*
* Check if the given prefix is one of the declared extensions.
* This is intended to be called only at compile-time.
* Called by:
* xsltPrecomputeStylesheet() (xslt.c)
* xsltParseTemplateContent (xslt.c)
*
* Returns 1 if this is an extension, 0 otherwise
*/
int
xsltCheckExtURI(xsltStylesheetPtr style, const xmlChar * URI)
{
xsltExtDefPtr cur;
if ((style == NULL) || (style->nsDefs == NULL))
return (0);
if (URI == NULL)
return (0);
cur = (xsltExtDefPtr) style->nsDefs;
while (cur != NULL) {
if (xmlStrEqual(URI, cur->URI))
return (1);
cur = cur->next;
}
return (0);
}
/**
* xsltRegisterExtModuleFull:
* @URI: URI associated to this module
* @initFunc: the module initialization function
* @shutdownFunc: the module shutdown function
* @styleInitFunc: the module initialization function
* @styleShutdownFunc: the module shutdown function
*
* Register an XSLT extension module to the library.
*
* Returns 0 if sucessful, -1 in case of error
*/
int
xsltRegisterExtModuleFull(const xmlChar * URI,
xsltExtInitFunction initFunc,
xsltExtShutdownFunction shutdownFunc,
xsltStyleExtInitFunction styleInitFunc,
xsltStyleExtShutdownFunction styleShutdownFunc)
{
int ret;
xsltExtModulePtr module;
if ((URI == NULL) || (initFunc == NULL))
return (-1);
if (xsltExtensionsHash == NULL)
xsltExtensionsHash = xmlHashCreate(10);
if (xsltExtensionsHash == NULL)
return (-1);
xmlMutexLock(xsltExtMutex);
module = xmlHashLookup(xsltExtensionsHash, URI);
if (module != NULL) {
if ((module->initFunc == initFunc) &&
(module->shutdownFunc == shutdownFunc))
ret = 0;
else
ret = -1;
goto done;
}
module = xsltNewExtModule(initFunc, shutdownFunc,
styleInitFunc, styleShutdownFunc);
if (module == NULL) {
ret = -1;
goto done;
}
ret = xmlHashAddEntry(xsltExtensionsHash, URI, (void *) module);
done:
xmlMutexUnlock(xsltExtMutex);
return (ret);
}
/**
* xsltRegisterExtModule:
* @URI: URI associated to this module
* @initFunc: the module initialization function
* @shutdownFunc: the module shutdown function
*
* Register an XSLT extension module to the library.
*
* Returns 0 if sucessful, -1 in case of error
*/
int
xsltRegisterExtModule(const xmlChar * URI,
xsltExtInitFunction initFunc,
xsltExtShutdownFunction shutdownFunc)
{
return xsltRegisterExtModuleFull(URI, initFunc, shutdownFunc,
NULL, NULL);
}
/**
* xsltUnregisterExtModule:
* @URI: URI associated to this module
*
* Unregister an XSLT extension module from the library.
*
* Returns 0 if sucessful, -1 in case of error
*/
int
xsltUnregisterExtModule(const xmlChar * URI)
{
int ret;
if (URI == NULL)
return (-1);
if (xsltExtensionsHash == NULL)
return (-1);
xmlMutexLock(xsltExtMutex);
ret = xmlHashRemoveEntry(xsltExtensionsHash, URI,
(xmlHashDeallocator) xsltFreeExtModule);
xmlMutexUnlock(xsltExtMutex);
return (ret);
}
/**
* xsltUnregisterAllExtModules:
*
* Unregister all the XSLT extension module from the library.
*/
static void
xsltUnregisterAllExtModules(void)
{
if (xsltExtensionsHash == NULL)
return;
xmlMutexLock(xsltExtMutex);
xmlHashFree(xsltExtensionsHash,
(xmlHashDeallocator) xsltFreeExtModule);
xsltExtensionsHash = NULL;
xmlMutexUnlock(xsltExtMutex);
}
/**
* xsltXPathGetTransformContext:
* @ctxt: an XPath transformation context
*
* Provides the XSLT transformation context from the XPath transformation
* context. This is useful when an XPath function in the extension module
* is called by the XPath interpreter and that the XSLT context is needed
* for example to retrieve the associated data pertaining to this XSLT
* transformation.
*
* Returns the XSLT transformation context or NULL in case of error.
*/
xsltTransformContextPtr
xsltXPathGetTransformContext(xmlXPathParserContextPtr ctxt)
{
if ((ctxt == NULL) || (ctxt->context == NULL))
return (NULL);
return (ctxt->context->extra);
}
/**
* xsltRegisterExtModuleFunction:
* @name: the function name
* @URI: the function namespace URI
* @function: the function callback
*
* Registers an extension module function.
*
* Returns 0 if successful, -1 in case of error.
*/
int
xsltRegisterExtModuleFunction(const xmlChar * name, const xmlChar * URI,
xmlXPathFunction function)
{
if ((name == NULL) || (URI == NULL) || (function == NULL))
return (-1);
if (xsltFunctionsHash == NULL)
xsltFunctionsHash = xmlHashCreate(10);
if (xsltFunctionsHash == NULL)
return (-1);
xmlMutexLock(xsltExtMutex);
xmlHashUpdateEntry2(xsltFunctionsHash, name, URI,
XML_CAST_FPTR(function), NULL);
xmlMutexUnlock(xsltExtMutex);
return (0);
}
/**
* xsltExtModuleFunctionLookup:
* @name: the function name
* @URI: the function namespace URI
*
* Looks up an extension module function
*
* Returns the function if found, NULL otherwise.
*/
xmlXPathFunction
xsltExtModuleFunctionLookup(const xmlChar * name, const xmlChar * URI)
{
xmlXPathFunction ret;
if ((xsltFunctionsHash == NULL) || (name == NULL) || (URI == NULL))
return (NULL);
xmlMutexLock(xsltExtMutex);
XML_CAST_FPTR(ret) = xmlHashLookup2(xsltFunctionsHash, name, URI);
xmlMutexUnlock(xsltExtMutex);
/* if lookup fails, attempt a dynamic load on supported platforms */
if (NULL == ret) {
if (!xsltExtModuleRegisterDynamic(URI)) {
xmlMutexLock(xsltExtMutex);
XML_CAST_FPTR(ret) =
xmlHashLookup2(xsltFunctionsHash, name, URI);
xmlMutexUnlock(xsltExtMutex);
}
}
return ret;
}
/**
* xsltUnregisterExtModuleFunction:
* @name: the function name
* @URI: the function namespace URI
*
* Unregisters an extension module function
*
* Returns 0 if successful, -1 in case of error.
*/
int
xsltUnregisterExtModuleFunction(const xmlChar * name, const xmlChar * URI)
{
int ret;
if ((xsltFunctionsHash == NULL) || (name == NULL) || (URI == NULL))
return (-1);
xmlMutexLock(xsltExtMutex);
ret = xmlHashRemoveEntry2(xsltFunctionsHash, name, URI, NULL);
xmlMutexUnlock(xsltExtMutex);
return(ret);
}
/**
* xsltUnregisterAllExtModuleFunction:
*
* Unregisters all extension module function
*/
static void
xsltUnregisterAllExtModuleFunction(void)
{
xmlMutexLock(xsltExtMutex);
xmlHashFree(xsltFunctionsHash, NULL);
xsltFunctionsHash = NULL;
xmlMutexUnlock(xsltExtMutex);
}
/**
* xsltNewElemPreComp:
* @style: the XSLT stylesheet
* @inst: the element node
* @function: the transform function
*
* Creates and initializes an #xsltElemPreComp
*
* Returns the new and initialized #xsltElemPreComp
*/
xsltElemPreCompPtr
xsltNewElemPreComp(xsltStylesheetPtr style, xmlNodePtr inst,
xsltTransformFunction function)
{
xsltElemPreCompPtr cur;
cur = (xsltElemPreCompPtr) xmlMalloc(sizeof(xsltElemPreComp));
if (cur == NULL) {
xsltTransformError(NULL, style, NULL,
"xsltNewExtElement : malloc failed\n");
return (NULL);
}
memset(cur, 0, sizeof(xsltElemPreComp));
xsltInitElemPreComp(cur, style, inst, function,
(xsltElemPreCompDeallocator) xmlFree);
return (cur);
}
/**
* xsltInitElemPreComp:
* @comp: an #xsltElemPreComp (or generally a derived structure)
* @style: the XSLT stylesheet
* @inst: the element node
* @function: the transform function
* @freeFunc: the @comp deallocator
*
* Initializes an existing #xsltElemPreComp structure. This is usefull
* when extending an #xsltElemPreComp to store precomputed data.
* This function MUST be called on any extension element precomputed
* data struct.
*/
void
xsltInitElemPreComp(xsltElemPreCompPtr comp, xsltStylesheetPtr style,
xmlNodePtr inst, xsltTransformFunction function,
xsltElemPreCompDeallocator freeFunc)
{
comp->type = XSLT_FUNC_EXTENSION;
comp->func = function;
comp->inst = inst;
comp->free = freeFunc;
comp->next = style->preComps;
style->preComps = comp;
}
/**
* xsltPreComputeExtModuleElement:
* @style: the stylesheet
* @inst: the element node
*
* Precomputes an extension module element
*
* Returns the precomputed data
*/
xsltElemPreCompPtr
xsltPreComputeExtModuleElement(xsltStylesheetPtr style, xmlNodePtr inst)
{
xsltExtElementPtr ext;
xsltElemPreCompPtr comp = NULL;
if ((style == NULL) || (inst == NULL) ||
(inst->type != XML_ELEMENT_NODE) || (inst->ns == NULL))
return (NULL);
xmlMutexLock(xsltExtMutex);
ext = (xsltExtElementPtr)
xmlHashLookup2(xsltElementsHash, inst->name, inst->ns->href);
xmlMutexUnlock(xsltExtMutex);
/*
* EXT TODO: Now what?
*/
if (ext == NULL)
return (NULL);
if (ext->precomp != NULL) {
/*
* REVISIT TODO: Check if the text below is correct.
* This will return a xsltElemPreComp structure or NULL.
* 1) If the the author of the extension needs a
* custom structure to hold the specific values of
* this extension, he will derive a structure based on
* xsltElemPreComp; thus we obviously *cannot* refactor
* the xsltElemPreComp structure, since all already derived
* user-defined strucures will break.
* Example: For the extension xsl:document,
* in xsltDocumentComp() (preproc.c), the structure
* xsltStyleItemDocument is allocated, filled with
* specific values and returned.
* 2) If the author needs no values to be stored in
* this structure, then he'll return NULL;
*/
comp = ext->precomp(style, inst, ext->transform);
}
if (comp == NULL) {
/*
* Default creation of a xsltElemPreComp structure, if
* the author of this extension did not create a custom
* structure.
*/
comp = xsltNewElemPreComp(style, inst, ext->transform);
}
return (comp);
}
/**
* xsltRegisterExtModuleElement:
* @name: the element name
* @URI: the element namespace URI
* @precomp: the pre-computation callback
* @transform: the transformation callback
*
* Registers an extension module element.
*
* Returns 0 if successful, -1 in case of error.
*/
int
xsltRegisterExtModuleElement(const xmlChar * name, const xmlChar * URI,
xsltPreComputeFunction precomp,
xsltTransformFunction transform)
{
int ret = 0;
xsltExtElementPtr ext;
if ((name == NULL) || (URI == NULL) || (transform == NULL))
return (-1);
if (xsltElementsHash == NULL)
xsltElementsHash = xmlHashCreate(10);
if (xsltElementsHash == NULL)
return (-1);
xmlMutexLock(xsltExtMutex);
ext = xsltNewExtElement(precomp, transform);
if (ext == NULL) {
ret = -1;
goto done;
}
xmlHashUpdateEntry2(xsltElementsHash, name, URI, (void *) ext,
(xmlHashDeallocator) xsltFreeExtElement);
done:
xmlMutexUnlock(xsltExtMutex);
return (ret);
}
/**
* xsltExtElementLookup:
* @ctxt: an XSLT process context
* @name: the element name
* @URI: the element namespace URI
*
* Looks up an extension element. @ctxt can be NULL to search only in
* module elements.
*
* Returns the element callback or NULL if not found
*/
xsltTransformFunction
xsltExtElementLookup(xsltTransformContextPtr ctxt,
const xmlChar * name, const xmlChar * URI)
{
xsltTransformFunction ret;
if ((name == NULL) || (URI == NULL))
return (NULL);
if ((ctxt != NULL) && (ctxt->extElements != NULL)) {
XML_CAST_FPTR(ret) = xmlHashLookup2(ctxt->extElements, name, URI);
if (ret != NULL) {
return(ret);
}
}
ret = xsltExtModuleElementLookup(name, URI);
return (ret);
}
/**
* xsltExtModuleElementLookup:
* @name: the element name
* @URI: the element namespace URI
*
* Looks up an extension module element
*
* Returns the callback function if found, NULL otherwise.
*/
xsltTransformFunction
xsltExtModuleElementLookup(const xmlChar * name, const xmlChar * URI)
{
xsltExtElementPtr ext;
if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
return (NULL);
xmlMutexLock(xsltExtMutex);
ext = (xsltExtElementPtr) xmlHashLookup2(xsltElementsHash, name, URI);
xmlMutexUnlock(xsltExtMutex);
/*
* if function lookup fails, attempt a dynamic load on
* supported platforms
*/
if (NULL == ext) {
if (!xsltExtModuleRegisterDynamic(URI)) {
xmlMutexLock(xsltExtMutex);
ext = (xsltExtElementPtr)
xmlHashLookup2(xsltElementsHash, name, URI);
xmlMutexUnlock(xsltExtMutex);
}
}
if (ext == NULL)
return (NULL);
return (ext->transform);
}
/**
* xsltExtModuleElementPreComputeLookup:
* @name: the element name
* @URI: the element namespace URI
*
* Looks up an extension module element pre-computation function
*
* Returns the callback function if found, NULL otherwise.
*/
xsltPreComputeFunction
xsltExtModuleElementPreComputeLookup(const xmlChar * name,
const xmlChar * URI)
{
xsltExtElementPtr ext;
if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
return (NULL);
xmlMutexLock(xsltExtMutex);
ext = (xsltExtElementPtr) xmlHashLookup2(xsltElementsHash, name, URI);
xmlMutexUnlock(xsltExtMutex);
if (ext == NULL) {
if (!xsltExtModuleRegisterDynamic(URI)) {
xmlMutexLock(xsltExtMutex);
ext = (xsltExtElementPtr)
xmlHashLookup2(xsltElementsHash, name, URI);
xmlMutexUnlock(xsltExtMutex);
}
}
if (ext == NULL)
return (NULL);
return (ext->precomp);
}
/**
* xsltUnregisterExtModuleElement:
* @name: the element name
* @URI: the element namespace URI
*
* Unregisters an extension module element
*
* Returns 0 if successful, -1 in case of error.
*/
int
xsltUnregisterExtModuleElement(const xmlChar * name, const xmlChar * URI)
{
int ret;
if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
return (-1);
xmlMutexLock(xsltExtMutex);
ret = xmlHashRemoveEntry2(xsltElementsHash, name, URI,
(xmlHashDeallocator) xsltFreeExtElement);
xmlMutexUnlock(xsltExtMutex);
return(ret);
}
/**
* xsltUnregisterAllExtModuleElement:
*
* Unregisters all extension module element
*/
static void
xsltUnregisterAllExtModuleElement(void)
{
xmlMutexLock(xsltExtMutex);
xmlHashFree(xsltElementsHash, (xmlHashDeallocator) xsltFreeExtElement);
xsltElementsHash = NULL;
xmlMutexUnlock(xsltExtMutex);
}
/**
* xsltRegisterExtModuleTopLevel:
* @name: the top-level element name
* @URI: the top-level element namespace URI
* @function: the top-level element callback
*
* Registers an extension module top-level element.
*
* Returns 0 if successful, -1 in case of error.
*/
int
xsltRegisterExtModuleTopLevel(const xmlChar * name, const xmlChar * URI,
xsltTopLevelFunction function)
{
if ((name == NULL) || (URI == NULL) || (function == NULL))
return (-1);
if (xsltTopLevelsHash == NULL)
xsltTopLevelsHash = xmlHashCreate(10);
if (xsltTopLevelsHash == NULL)
return (-1);
xmlMutexLock(xsltExtMutex);
xmlHashUpdateEntry2(xsltTopLevelsHash, name, URI,
XML_CAST_FPTR(function), NULL);
xmlMutexUnlock(xsltExtMutex);
return (0);
}
/**
* xsltExtModuleTopLevelLookup:
* @name: the top-level element name
* @URI: the top-level element namespace URI
*
* Looks up an extension module top-level element
*
* Returns the callback function if found, NULL otherwise.
*/
xsltTopLevelFunction
xsltExtModuleTopLevelLookup(const xmlChar * name, const xmlChar * URI)
{
xsltTopLevelFunction ret;
if ((xsltTopLevelsHash == NULL) || (name == NULL) || (URI == NULL))
return (NULL);
xmlMutexLock(xsltExtMutex);
XML_CAST_FPTR(ret) = xmlHashLookup2(xsltTopLevelsHash, name, URI);
xmlMutexUnlock(xsltExtMutex);
/* if lookup fails, attempt a dynamic load on supported platforms */
if (NULL == ret) {
if (!xsltExtModuleRegisterDynamic(URI)) {
xmlMutexLock(xsltExtMutex);
XML_CAST_FPTR(ret) = xmlHashLookup2(xsltTopLevelsHash, name, URI);
xmlMutexUnlock(xsltExtMutex);
}
}
return (ret);
}
/**
* xsltUnregisterExtModuleTopLevel:
* @name: the top-level element name
* @URI: the top-level element namespace URI
*
* Unregisters an extension module top-level element
*
* Returns 0 if successful, -1 in case of error.
*/
int
xsltUnregisterExtModuleTopLevel(const xmlChar * name, const xmlChar * URI)
{
int ret;
if ((xsltTopLevelsHash == NULL) || (name == NULL) || (URI == NULL))
return (-1);
xmlMutexLock(xsltExtMutex);
ret = xmlHashRemoveEntry2(xsltTopLevelsHash, name, URI, NULL);
xmlMutexUnlock(xsltExtMutex);
return(ret);
}
/**
* xsltUnregisterAllExtModuleTopLevel:
*
* Unregisters all extension module function
*/
static void
xsltUnregisterAllExtModuleTopLevel(void)
{
xmlMutexLock(xsltExtMutex);
xmlHashFree(xsltTopLevelsHash, NULL);
xsltTopLevelsHash = NULL;
xmlMutexUnlock(xsltExtMutex);
}
/**
* xsltGetExtInfo:
* @style: pointer to a stylesheet
* @URI: the namespace URI desired
*
* looks up URI in extInfos of the stylesheet
*
* returns a pointer to the hash table if found, else NULL
*/
xmlHashTablePtr
xsltGetExtInfo(xsltStylesheetPtr style, const xmlChar * URI)
{
xsltExtDataPtr data;
/*
* TODO: Why do we have a return type of xmlHashTablePtr?
* Is the user-allocated data for extension modules expected
* to be a xmlHashTablePtr only? Or is this intended for
* the EXSLT module only?
*/
if (style != NULL && style->extInfos != NULL) {
data = xmlHashLookup(style->extInfos, URI);
if (data != NULL && data->extData != NULL)
return data->extData;
}
return NULL;
}
/************************************************************************
* *
* Test module http://xmlsoft.org/XSLT/ *
* *
************************************************************************/
/************************************************************************
* *
* Test of the extension module API *
* *
************************************************************************/
static xmlChar *testData = NULL;
static xmlChar *testStyleData = NULL;
/**
* xsltExtFunctionTest:
* @ctxt: the XPath Parser context
* @nargs: the number of arguments
*
* function libxslt:test() for testing the extensions support.
*/
static void
xsltExtFunctionTest(xmlXPathParserContextPtr ctxt,
int nargs ATTRIBUTE_UNUSED)
{
xsltTransformContextPtr tctxt;
void *data = NULL;
tctxt = xsltXPathGetTransformContext(ctxt);
if (testData == NULL) {
xsltGenericDebug(xsltGenericDebugContext,
"xsltExtFunctionTest: not initialized,"
" calling xsltGetExtData\n");
data = xsltGetExtData(tctxt, (const xmlChar *) XSLT_DEFAULT_URL);
if (data == NULL) {
xsltTransformError(tctxt, NULL, NULL,
"xsltExtElementTest: not initialized\n");
return;
}
}
if (tctxt == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"xsltExtFunctionTest: failed to get the transformation context\n");
return;
}
if (data == NULL)
data = xsltGetExtData(tctxt, (const xmlChar *) XSLT_DEFAULT_URL);
if (data == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"xsltExtFunctionTest: failed to get module data\n");
return;
}
if (data != testData) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"xsltExtFunctionTest: got wrong module data\n");
return;
}
#ifdef WITH_XSLT_DEBUG_FUNCTION
xsltGenericDebug(xsltGenericDebugContext,
"libxslt:test() called with %d args\n", nargs);
#endif
}
/**
* xsltExtElementPreCompTest:
* @style: the stylesheet
* @inst: the instruction in the stylesheet
*
* Process a libxslt:test node
*/
static xsltElemPreCompPtr
xsltExtElementPreCompTest(xsltStylesheetPtr style, xmlNodePtr inst,
xsltTransformFunction function)
{
xsltElemPreCompPtr ret;
if (style == NULL) {
xsltTransformError(NULL, NULL, inst,
"xsltExtElementTest: no transformation context\n");
return (NULL);
}
if (testStyleData == NULL) {
xsltGenericDebug(xsltGenericDebugContext,
"xsltExtElementPreCompTest: not initialized,"
" calling xsltStyleGetExtData\n");
xsltStyleGetExtData(style, (const xmlChar *) XSLT_DEFAULT_URL);
if (testStyleData == NULL) {
xsltTransformError(NULL, style, inst,
"xsltExtElementPreCompTest: not initialized\n");
if (style != NULL)
style->errors++;
return (NULL);
}
}
if (inst == NULL) {
xsltTransformError(NULL, style, inst,
"xsltExtElementPreCompTest: no instruction\n");
if (style != NULL)
style->errors++;
return (NULL);
}
ret = xsltNewElemPreComp(style, inst, function);
return (ret);
}
/**
* xsltExtElementTest:
* @ctxt: an XSLT processing context
* @node: The current node
* @inst: the instruction in the stylesheet
* @comp: precomputed informations
*
* Process a libxslt:test node
*/
static void
xsltExtElementTest(xsltTransformContextPtr ctxt, xmlNodePtr node,
xmlNodePtr inst,
xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
{
xmlNodePtr commentNode;
if (testData == NULL) {
xsltGenericDebug(xsltGenericDebugContext,
"xsltExtElementTest: not initialized,"
" calling xsltGetExtData\n");
xsltGetExtData(ctxt, (const xmlChar *) XSLT_DEFAULT_URL);
if (testData == NULL) {
xsltTransformError(ctxt, NULL, inst,
"xsltExtElementTest: not initialized\n");
return;
}
}
if (ctxt == NULL) {
xsltTransformError(ctxt, NULL, inst,
"xsltExtElementTest: no transformation context\n");
return;
}
if (node == NULL) {
xsltTransformError(ctxt, NULL, inst,
"xsltExtElementTest: no current node\n");
return;
}
if (inst == NULL) {
xsltTransformError(ctxt, NULL, inst,
"xsltExtElementTest: no instruction\n");
return;
}
if (ctxt->insert == NULL) {
xsltTransformError(ctxt, NULL, inst,
"xsltExtElementTest: no insertion point\n");
return;
}
commentNode = xmlNewComment((const xmlChar *)
"libxslt:test element test worked");
xmlAddChild(ctxt->insert, commentNode);
}
/**
* xsltExtInitTest:
* @ctxt: an XSLT transformation context
* @URI: the namespace URI for the extension
*
* A function called at initialization time of an XSLT extension module
*
* Returns a pointer to the module specific data for this transformation
*/
static void *
xsltExtInitTest(xsltTransformContextPtr ctxt, const xmlChar * URI)
{
if (testStyleData == NULL) {
xsltGenericDebug(xsltGenericErrorContext,
"xsltExtInitTest: not initialized,"
" calling xsltStyleGetExtData\n");
testStyleData = xsltStyleGetExtData(ctxt->style, URI);
if (testStyleData == NULL) {
xsltTransformError(ctxt, NULL, NULL,
"xsltExtInitTest: not initialized\n");
return (NULL);
}
}
if (testData != NULL) {
xsltTransformError(ctxt, NULL, NULL,
"xsltExtInitTest: already initialized\n");
return (NULL);
}
testData = (void *) "test data";
xsltGenericDebug(xsltGenericDebugContext,
"Registered test module : %s\n", URI);
return (testData);
}
/**
* xsltExtShutdownTest:
* @ctxt: an XSLT transformation context
* @URI: the namespace URI for the extension
* @data: the data associated to this module
*
* A function called at shutdown time of an XSLT extension module
*/
static void
xsltExtShutdownTest(xsltTransformContextPtr ctxt,
const xmlChar * URI, void *data)
{
if (testData == NULL) {
xsltTransformError(ctxt, NULL, NULL,
"xsltExtShutdownTest: not initialized\n");
return;
}
if (data != testData) {
xsltTransformError(ctxt, NULL, NULL,
"xsltExtShutdownTest: wrong data\n");
}
testData = NULL;
xsltGenericDebug(xsltGenericDebugContext,
"Unregistered test module : %s\n", URI);
}
/**
* xsltExtStyleInitTest:
* @style: an XSLT stylesheet
* @URI: the namespace URI for the extension
*
* A function called at initialization time of an XSLT extension module
*
* Returns a pointer to the module specific data for this transformation
*/
static void *
xsltExtStyleInitTest(xsltStylesheetPtr style ATTRIBUTE_UNUSED,
const xmlChar * URI)
{
if (testStyleData != NULL) {
xsltTransformError(NULL, NULL, NULL,
"xsltExtInitTest: already initialized\n");
return (NULL);
}
testStyleData = (void *) "test data";
xsltGenericDebug(xsltGenericDebugContext,
"Registered test module : %s\n", URI);
return (testStyleData);
}
/**
* xsltExtStyleShutdownTest:
* @style: an XSLT stylesheet
* @URI: the namespace URI for the extension
* @data: the data associated to this module
*
* A function called at shutdown time of an XSLT extension module
*/
static void
xsltExtStyleShutdownTest(xsltStylesheetPtr style ATTRIBUTE_UNUSED,
const xmlChar * URI, void *data)
{
if (testStyleData == NULL) {
xsltGenericError(xsltGenericErrorContext,
"xsltExtShutdownTest: not initialized\n");
return;
}
if (data != testStyleData) {
xsltTransformError(NULL, NULL, NULL,
"xsltExtShutdownTest: wrong data\n");
}
testStyleData = NULL;
xsltGenericDebug(xsltGenericDebugContext,
"Unregistered test module : %s\n", URI);
}
/**
* xsltRegisterTestModule:
*
* Registers the test module
*/
void
xsltRegisterTestModule(void)
{
xsltInitGlobals();
xsltRegisterExtModuleFull((const xmlChar *) XSLT_DEFAULT_URL,
xsltExtInitTest, xsltExtShutdownTest,
xsltExtStyleInitTest,
xsltExtStyleShutdownTest);
xsltRegisterExtModuleFunction((const xmlChar *) "test",
(const xmlChar *) XSLT_DEFAULT_URL,
xsltExtFunctionTest);
xsltRegisterExtModuleElement((const xmlChar *) "test",
(const xmlChar *) XSLT_DEFAULT_URL,
xsltExtElementPreCompTest,
xsltExtElementTest);
}
static void
xsltHashScannerModuleFree(void *payload ATTRIBUTE_UNUSED,
void *data ATTRIBUTE_UNUSED,
xmlChar * name ATTRIBUTE_UNUSED)
{
#ifdef WITH_MODULES
xmlModuleClose(payload);
#endif
}
/**
* xsltInitGlobals:
*
* Initialize the global variables for extensions
*/
void
xsltInitGlobals(void)
{
if (xsltExtMutex == NULL) {
xsltExtMutex = xmlNewMutex();
}
}
/**
* xsltCleanupGlobals:
*
* Unregister all global variables set up by the XSLT library
*/
void
xsltCleanupGlobals(void)
{
xsltUnregisterAllExtModules();
xsltUnregisterAllExtModuleFunction();
xsltUnregisterAllExtModuleElement();
xsltUnregisterAllExtModuleTopLevel();
xmlMutexLock(xsltExtMutex);
/* cleanup dynamic module hash */
if (NULL != xsltModuleHash) {
xmlHashScan(xsltModuleHash, xsltHashScannerModuleFree, 0);
xmlHashFree(xsltModuleHash, NULL);
xsltModuleHash = NULL;
}
xmlMutexUnlock(xsltExtMutex);
xmlFreeMutex(xsltExtMutex);
xsltExtMutex = NULL;
xsltFreeLocales();
xsltUninit();
}
static void
xsltDebugDumpExtensionsCallback(void *function ATTRIBUTE_UNUSED,
FILE * output, const xmlChar * name,
const xmlChar * URI,
const xmlChar * not_used ATTRIBUTE_UNUSED)
{
if (!name || !URI)
return;
fprintf(output, "{%s}%s\n", URI, name);
}
static void
xsltDebugDumpExtModulesCallback(void *function ATTRIBUTE_UNUSED,
FILE * output, const xmlChar * URI,
const xmlChar * not_used ATTRIBUTE_UNUSED,
const xmlChar * not_used2 ATTRIBUTE_UNUSED)
{
if (!URI)
return;
fprintf(output, "%s\n", URI);
}
/**
* xsltDebugDumpExtensions:
* @output: the FILE * for the output, if NULL stdout is used
*
* Dumps a list of the registered XSLT extension functions and elements
*/
void
xsltDebugDumpExtensions(FILE * output)
{
if (output == NULL)
output = stdout;
fprintf(output,
"Registered XSLT Extensions\n--------------------------\n");
if (!xsltFunctionsHash)
fprintf(output, "No registered extension functions\n");
else {
fprintf(output, "Registered Extension Functions:\n");
xmlMutexLock(xsltExtMutex);
xmlHashScanFull(xsltFunctionsHash,
(xmlHashScannerFull)
xsltDebugDumpExtensionsCallback, output);
xmlMutexUnlock(xsltExtMutex);
}
if (!xsltElementsHash)
fprintf(output, "\nNo registered extension elements\n");
else {
fprintf(output, "\nRegistered Extension Elements:\n");
xmlMutexLock(xsltExtMutex);
xmlHashScanFull(xsltElementsHash,
(xmlHashScannerFull)
xsltDebugDumpExtensionsCallback, output);
xmlMutexUnlock(xsltExtMutex);
}
if (!xsltExtensionsHash)
fprintf(output, "\nNo registered extension modules\n");
else {
fprintf(output, "\nRegistered Extension Modules:\n");
xmlMutexLock(xsltExtMutex);
xmlHashScanFull(xsltExtensionsHash,
(xmlHashScannerFull)
xsltDebugDumpExtModulesCallback, output);
xmlMutexUnlock(xsltExtMutex);
}
}
Reference in a new issue View git blame Copy permalink