extensions.c File Reference

#include "precomp.h"
#include <libxml/list.h>

Include dependency graph for extensions.c:

Go to the source code of this file.

Classes
struct	_xsltExtDef
struct	_xsltExtModule
struct	_xsltExtData
struct	_xsltExtElement
struct	_xsltInitExtCtxt

Typedefs
typedef struct _xsltExtDef	xsltExtDef
typedef xsltExtDef *	xsltExtDefPtr
typedef struct _xsltExtModule	xsltExtModule
typedef xsltExtModule *	xsltExtModulePtr
typedef struct _xsltExtData	xsltExtData
typedef xsltExtData *	xsltExtDataPtr
typedef struct _xsltExtElement	xsltExtElement
typedef xsltExtElement *	xsltExtElementPtr

Functions
static xsltExtDefPtr	xsltNewExtDef (const xmlChar *prefix, const xmlChar *URI)
static void	xsltFreeExtDef (xsltExtDefPtr extensiond)
static void	xsltFreeExtDefList (xsltExtDefPtr extensiond)
static xsltExtModulePtr	xsltNewExtModule (xsltExtInitFunction initFunc, xsltExtShutdownFunction shutdownFunc, xsltStyleExtInitFunction styleInitFunc, xsltStyleExtShutdownFunction styleShutdownFunc)
static void	xsltFreeExtModule (xsltExtModulePtr ext)
static void	xsltFreeExtModuleEntry (void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
static xsltExtDataPtr	xsltNewExtData (xsltExtModulePtr extModule, void *extData)
static void	xsltFreeExtData (xsltExtDataPtr ext)
static void	xsltFreeExtDataEntry (void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
static xsltExtElementPtr	xsltNewExtElement (xsltPreComputeFunction precomp, xsltTransformFunction transform)
static void	xsltFreeExtElement (xsltExtElementPtr ext)
static void	xsltFreeExtElementEntry (void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
static int	xsltExtModuleRegisterDynamic (const xmlChar *URI ATTRIBUTE_UNUSED)
void	xsltFreeExts (xsltStylesheetPtr style)
int	xsltRegisterExtPrefix (xsltStylesheetPtr style, const xmlChar *prefix, const xmlChar *URI)
: the function name
xsltUnregisterExtModuleFunction: @URI: the function namespace URI Unregisters an extension module function Returns 0 if successful, -1 in case of error.
int	xsltRegisterExtModuleFunction (const xmlChar *name, const xmlChar *URI, xmlXPathFunction function)
xmlXPathFunction	xsltExtModuleFunctionLookup (const xmlChar *name, const xmlChar *URI)
int	xsltUnregisterExtModuleFunction (const xmlChar *name, const xmlChar *URI)
static void	xsltUnregisterAllExtModuleFunction (void)
static void	xsltFreeElemPreComp (xsltElemPreCompPtr comp)
xsltElemPreCompPtr	xsltNewElemPreComp (xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function)
void	xsltInitElemPreComp (xsltElemPreCompPtr comp, xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function, xsltElemPreCompDeallocator freeFunc)
xsltElemPreCompPtr	xsltPreComputeExtModuleElement (xsltStylesheetPtr style, xmlNodePtr inst)
: the element name
xsltUnregisterExtModuleElement: @URI: the element namespace URI Unregisters 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)
xsltTransformFunction	xsltExtElementLookup (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *URI)
xsltTransformFunction	xsltExtModuleElementLookup (const xmlChar *name, const xmlChar *URI)
xsltPreComputeFunction	xsltExtModuleElementPreComputeLookup (const xmlChar *name, const xmlChar *URI)
int	xsltUnregisterExtModuleElement (const xmlChar *name, const xmlChar *URI)
static void	xsltUnregisterAllExtModuleElement (void)

Variables
static xmlHashTablePtr	xsltExtensionsHash = NULL
static xmlHashTablePtr	xsltFunctionsHash = NULL
static xmlHashTablePtr	xsltElementsHash = NULL
static xmlHashTablePtr	xsltTopLevelsHash = NULL
static xmlHashTablePtr	xsltModuleHash = NULL
static xmlMutexPtr	xsltExtMutex = NULL

: the name of the element
xsltRegisterExtElement: @ctxt: an XSLT transformation context @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
typedef struct _xsltInitExtCtxt	xsltInitExtCtxt
int	xsltRegisterExtFunction (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *URI, xmlXPathFunction function)
int	xsltRegisterExtElement (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *URI, xsltTransformFunction function)
void	xsltFreeCtxtExts (xsltTransformContextPtr ctxt)
static xsltExtDataPtr	xsltStyleInitializeStylesheetModule (xsltStylesheetPtr style, const xmlChar *URI)
void *	xsltStyleGetExtData (xsltStylesheetPtr style, const xmlChar *URI)
void *	xsltGetExtData (xsltTransformContextPtr ctxt, const xmlChar *URI)
static void	xsltInitCtxtExt (void *payload, void *data, const xmlChar *URI)
int	xsltInitCtxtExts (xsltTransformContextPtr ctxt)
static void	xsltShutdownCtxtExt (void *payload, void *vctxt, const xmlChar *URI)
void	xsltShutdownCtxtExts (xsltTransformContextPtr ctxt)
static void	xsltShutdownExt (void *payload, void *vctxt, const xmlChar *URI)
void	xsltShutdownExts (xsltStylesheetPtr style)
int	xsltCheckExtPrefix (xsltStylesheetPtr style, const xmlChar *URI)
int	xsltCheckExtURI (xsltStylesheetPtr style, const xmlChar *URI)
int	xsltRegisterExtModuleFull (const xmlChar *URI, xsltExtInitFunction initFunc, xsltExtShutdownFunction shutdownFunc, xsltStyleExtInitFunction styleInitFunc, xsltStyleExtShutdownFunction styleShutdownFunc)
int	xsltRegisterExtModule (const xmlChar *URI, xsltExtInitFunction initFunc, xsltExtShutdownFunction shutdownFunc)
int	xsltUnregisterExtModule (const xmlChar *URI)
static void	xsltUnregisterAllExtModules (void)
xsltTransformContextPtr	xsltXPathGetTransformContext (xmlXPathParserContextPtr ctxt)

: the top-level element name
xsltUnregisterExtModuleTopLevel: @URI: the top-level element namespace URI Unregisters an extension module top-level element Returns 0 if successful, -1 in case of error.
static xmlChar *	testData = NULL
static xmlChar *	testStyleData = NULL
int	xsltRegisterExtModuleTopLevel (const xmlChar *name, const xmlChar *URI, xsltTopLevelFunction function)
xsltTopLevelFunction	xsltExtModuleTopLevelLookup (const xmlChar *name, const xmlChar *URI)
int	xsltUnregisterExtModuleTopLevel (const xmlChar *name, const xmlChar *URI)
static void	xsltUnregisterAllExtModuleTopLevel (void)
xmlHashTablePtr	xsltGetExtInfo (xsltStylesheetPtr style, const xmlChar *URI)
static void	xsltExtFunctionTest (xmlXPathParserContextPtr ctxt, int nargs ATTRIBUTE_UNUSED)
static xsltElemPreCompPtr	xsltExtElementPreCompTest (xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function)
static void	xsltExtElementTest (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
static void *	xsltExtInitTest (xsltTransformContextPtr ctxt, const xmlChar *URI)
static void	xsltExtShutdownTest (xsltTransformContextPtr ctxt, const xmlChar *URI, void *data)
static void *	xsltExtStyleInitTest (xsltStylesheetPtr style ATTRIBUTE_UNUSED, const xmlChar *URI)
static void	xsltExtStyleShutdownTest (xsltStylesheetPtr style ATTRIBUTE_UNUSED, const xmlChar *URI, void *data)
void	xsltRegisterTestModule (void)
static void	xsltHashScannerModuleFree (void *payload ATTRIBUTE_UNUSED, void *data ATTRIBUTE_UNUSED, const xmlChar *name ATTRIBUTE_UNUSED)
void	xsltInitGlobals (void)
void	xsltCleanupGlobals (void)
static void	xsltDebugDumpExtensionsCallback (void *function ATTRIBUTE_UNUSED, void *data, const xmlChar *name, const xmlChar *URI, const xmlChar *not_used ATTRIBUTE_UNUSED)
static void	xsltDebugDumpExtModulesCallback (void *function ATTRIBUTE_UNUSED, void *data, const xmlChar *URI, const xmlChar *not_used ATTRIBUTE_UNUSED, const xmlChar *not_used2 ATTRIBUTE_UNUSED)
void	xsltDebugDumpExtensions (FILE *output)

Typedef Documentation

xsltExtData

typedef struct _xsltExtData xsltExtData

Definition at line 53 of file extensions.c.

xsltExtDataPtr

typedef xsltExtData* xsltExtDataPtr

Definition at line 54 of file extensions.c.

xsltExtDef

typedef struct _xsltExtDef xsltExtDef

Definition at line 35 of file extensions.c.

xsltExtDefPtr

typedef xsltExtDef* xsltExtDefPtr

Definition at line 36 of file extensions.c.

xsltExtElement

typedef struct _xsltExtElement xsltExtElement

Definition at line 60 of file extensions.c.

xsltExtElementPtr

typedef xsltExtElement* xsltExtElementPtr

Definition at line 61 of file extensions.c.

xsltExtModule

typedef struct _xsltExtModule xsltExtModule

Definition at line 44 of file extensions.c.

xsltExtModulePtr

typedef xsltExtModule* xsltExtModulePtr

Definition at line 45 of file extensions.c.

xsltInitExtCtxt

typedef struct _xsltInitExtCtxt xsltInitExtCtxt

Definition at line 922 of file extensions.c.

Function Documentation

xsltCheckExtPrefix()

int xsltCheckExtPrefix	(	xsltStylesheetPtr	style,
		const xmlChar *	URI
	)

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

Definition at line 1158 of file extensions.c.

{
#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);
}

Referenced by xsltGetInheritedNsList(), and xsltParseTemplateContent().

xsltCheckExtURI()

int xsltCheckExtURI	(	xsltStylesheetPtr	style,
		const xmlChar *	URI
	)

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

Definition at line 1218 of file extensions.c.

{
    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);
}

Referenced by xsltPreprocessStylesheet().

xsltCleanupGlobals()

void xsltCleanupGlobals

(

void

)

xsltCleanupGlobals:

Unregister all global variables set up by the XSLT library

Definition at line 2270 of file extensions.c.

{
    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();
}

xsltDebugDumpExtensions()

void xsltDebugDumpExtensions

(

FILE *

output

)

xsltDebugDumpExtensions: @output: the FILE * for the output, if NULL stdout is used

Dumps a list of the registered XSLT extension functions and elements

Definition at line 2323 of file extensions.c.

{
    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, xsltDebugDumpExtensionsCallback,
                        output);
        xmlMutexUnlock(xsltExtMutex);
    }
    if (!xsltElementsHash)
        fprintf(output, "\nNo registered extension elements\n");
    else {
        fprintf(output, "\nRegistered Extension Elements:\n");
        xmlMutexLock(xsltExtMutex);
        xmlHashScanFull(xsltElementsHash, xsltDebugDumpExtensionsCallback,
                        output);
        xmlMutexUnlock(xsltExtMutex);
    }
    if (!xsltExtensionsHash)
        fprintf(output, "\nNo registered extension modules\n");
    else {
        fprintf(output, "\nRegistered Extension Modules:\n");
        xmlMutexLock(xsltExtMutex);
        xmlHashScanFull(xsltExtensionsHash, xsltDebugDumpExtModulesCallback,
                        output);
        xmlMutexUnlock(xsltExtMutex);
    }
 
}

xsltDebugDumpExtensionsCallback()

static void xsltDebugDumpExtensionsCallback ( void *function  ATTRIBUTE_UNUSED, void *  data, const xmlChar *  name, const xmlChar *  URI, const xmlChar *not_used  ATTRIBUTE_UNUSED  )

static

Definition at line 2293 of file extensions.c.

{
    FILE *output = (FILE *) data;
    if (!name || !URI)
        return;
    fprintf(output, "{%s}%s\n", URI, name);
}

Referenced by xsltDebugDumpExtensions().

xsltDebugDumpExtModulesCallback()

static void xsltDebugDumpExtModulesCallback ( void *function  ATTRIBUTE_UNUSED, void *  data, const xmlChar *  URI, const xmlChar *not_used  ATTRIBUTE_UNUSED, const xmlChar *not_used2  ATTRIBUTE_UNUSED  )

static

Definition at line 2305 of file extensions.c.

{
    FILE *output = (FILE *) data;
    if (!URI)
        return;
    fprintf(output, "%s\n", URI);
}

Referenced by xsltDebugDumpExtensions().

xsltExtElementLookup()

xsltTransformFunction xsltExtElementLookup	(	xsltTransformContextPtr	ctxt,
		const xmlChar *	name,
		const xmlChar *	URI
	)

Definition at line 1668 of file extensions.c.

{
    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);
}

Referenced by xsltApplySequenceConstructor(), and xsltElementAvailableFunction().

xsltExtElementPreCompTest()

static xsltElemPreCompPtr xsltExtElementPreCompTest ( xsltStylesheetPtr  style, xmlNodePtr  inst, xsltTransformFunction  function  )

static

xsltExtElementPreCompTest: @style: the stylesheet @inst: the instruction in the stylesheet

Process a libxslt:test node

Definition at line 2021 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterTestModule().

xsltExtElementTest()

static void xsltExtElementTest ( xsltTransformContextPtr  ctxt, xmlNodePtr  node, xmlNodePtr  inst, xsltElemPreCompPtr comp  ATTRIBUTE_UNUSED  )

static

xsltExtElementTest: @ctxt: an XSLT processing context @node: The current node @inst: the instruction in the stylesheet @comp: precomputed information

Process a libxslt:test node

Definition at line 2065 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterTestModule().

xsltExtFunctionTest()

static void xsltExtFunctionTest ( xmlXPathParserContextPtr  ctxt, int nargs  ATTRIBUTE_UNUSED  )

static

xsltExtFunctionTest: @ctxt: the XPath Parser context @nargs: the number of arguments

function libxslt:test() for testing the extensions support.

Definition at line 1971 of file extensions.c.

{
    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
}

Referenced by xsltRegisterTestModule().

xsltExtInitTest()

static void * xsltExtInitTest ( xsltTransformContextPtr  ctxt, const xmlChar *  URI  )

static

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

Definition at line 2117 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterTestModule().

xsltExtModuleElementLookup()

xsltTransformFunction xsltExtModuleElementLookup	(	const xmlChar *	name,
		const xmlChar *	URI
	)

Definition at line 1698 of file extensions.c.

{
    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);
}

Referenced by xsltExtElementLookup().

xsltExtModuleElementPreComputeLookup()

xsltPreComputeFunction xsltExtModuleElementPreComputeLookup	(	const xmlChar *	name,
		const xmlChar *	URI
	)

Definition at line 1741 of file extensions.c.

{
    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);
}

xsltExtModuleFunctionLookup()

xmlXPathFunction xsltExtModuleFunctionLookup	(	const xmlChar *	name,
		const xmlChar *	URI
	)

Definition at line 1416 of file extensions.c.

{
    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;
}

Referenced by xsltXPathFunctionLookup().

xsltExtModuleRegisterDynamic()

static int xsltExtModuleRegisterDynamic ( const xmlChar *URI  ATTRIBUTE_UNUSED )

static

Definition at line 459 of file extensions.c.

{
  return -1;
}

Referenced by xsltExtModuleElementLookup(), xsltExtModuleElementPreComputeLookup(), xsltExtModuleFunctionLookup(), xsltExtModuleTopLevelLookup(), and xsltRegisterExtPrefix().

xsltExtModuleTopLevelLookup()

xsltTopLevelFunction xsltExtModuleTopLevelLookup	(	const xmlChar *	name,
		const xmlChar *	URI
	)

Definition at line 1856 of file extensions.c.

{
    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);
}

Referenced by xsltParseStylesheetTop().

xsltExtShutdownTest()

static void xsltExtShutdownTest ( xsltTransformContextPtr  ctxt, const xmlChar *  URI, void *  data  )

static

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

Definition at line 2151 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterTestModule().

xsltExtStyleInitTest()

static void * xsltExtStyleInitTest ( xsltStylesheetPtr style  ATTRIBUTE_UNUSED, const xmlChar *  URI  )

static

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

Definition at line 2178 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterTestModule().

xsltExtStyleShutdownTest()

static void xsltExtStyleShutdownTest ( xsltStylesheetPtr style  ATTRIBUTE_UNUSED, const xmlChar *  URI, void *  data  )

static

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

Definition at line 2202 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterTestModule().

xsltFreeCtxtExts()

void xsltFreeCtxtExts

(

xsltTransformContextPtr

ctxt

)

xsltFreeCtxtExts: @ctxt: an XSLT transformation context

Free the XSLT extension data

Definition at line 642 of file extensions.c.

{
    if (ctxt->extElements != NULL)
        xmlHashFree(ctxt->extElements, NULL);
    if (ctxt->extFunctions != NULL)
        xmlHashFree(ctxt->extFunctions, NULL);
}

Referenced by xsltFreeTransformContext().

xsltFreeElemPreComp()

static void xsltFreeElemPreComp ( xsltElemPreCompPtr  comp )

static

Definition at line 1488 of file extensions.c.

                                             {
    xmlFree(comp);
}

Referenced by xsltNewElemPreComp().

xsltFreeExtData()

static void xsltFreeExtData ( xsltExtDataPtr  ext )

static

xsltFreeExtData: @ext: an XSLT extension module data wrapper

Free up the memory allocated by @ext

Definition at line 229 of file extensions.c.

{
    if (ext == NULL)
        return;
    xmlFree(ext);
}

Referenced by xsltFreeExtDataEntry(), xsltGetExtData(), xsltInitCtxtExt(), and xsltStyleInitializeStylesheetModule().

xsltFreeExtDataEntry()

static void xsltFreeExtDataEntry ( void *  payload, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 237 of file extensions.c.

                                                                          {
    xsltFreeExtData((xsltExtDataPtr) payload);
}

Referenced by xsltShutdownCtxtExts(), and xsltShutdownExts().

xsltFreeExtDef()

static void xsltFreeExtDef ( xsltExtDefPtr  extensiond )

static

xsltFreeExtDef: @extensiond: an XSLT extension definition

Free up the memory allocated by @extensiond

Definition at line 115 of file extensions.c.

{
    if (extensiond == NULL)
        return;
    if (extensiond->prefix != NULL)
        xmlFree(extensiond->prefix);
    if (extensiond->URI != NULL)
        xmlFree(extensiond->URI);
    xmlFree(extensiond);
}

Referenced by xsltFreeExtDefList().

xsltFreeExtDefList()

static void xsltFreeExtDefList ( xsltExtDefPtr  extensiond )

static

xsltFreeExtDefList: @extensiond: an XSLT extension definition list

Free up the memory allocated by all the elements of @extensiond

Definition at line 133 of file extensions.c.

{
    xsltExtDefPtr cur;
 
    while (extensiond != NULL) {
        cur = extensiond;
        extensiond = extensiond->next;
        xsltFreeExtDef(cur);
    }
}

Referenced by xsltFreeExts().

xsltFreeExtElement()

static void xsltFreeExtElement ( xsltExtElementPtr  ext )

static

xsltFreeExtElement: @ext: an XSLT extension element

Frees up the memory allocated by @ext

Definition at line 278 of file extensions.c.

{
    if (ext == NULL)
        return;
    xmlFree(ext);
}

Referenced by xsltFreeExtElementEntry().

xsltFreeExtElementEntry()

static void xsltFreeExtElementEntry ( void *  payload, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 286 of file extensions.c.

                                                                             {
    xsltFreeExtElement((xsltExtElementPtr) payload);
}

Referenced by xsltRegisterExtModuleElement(), xsltUnregisterAllExtModuleElement(), and xsltUnregisterExtModuleElement().

xsltFreeExtModule()

static void xsltFreeExtModule ( xsltExtModulePtr  ext )

static

xsltFreeExtModule: @ext: an XSLT extension module

Free up the memory allocated by @ext

Definition at line 183 of file extensions.c.

{
    if (ext == NULL)
        return;
    xmlFree(ext);
}

Referenced by xsltFreeExtModuleEntry().

xsltFreeExtModuleEntry()

static void xsltFreeExtModuleEntry ( void *  payload, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 191 of file extensions.c.

                                                                            {
    xsltFreeExtModule((xsltExtModulePtr) payload);
}

Referenced by xsltUnregisterAllExtModules(), and xsltUnregisterExtModule().

xsltFreeExts()

void xsltFreeExts

(

xsltStylesheetPtr

style

)

xsltFreeExts: @style: an XSLT stylesheet

Free up the memory used by XSLT extensions in a stylesheet

Definition at line 479 of file extensions.c.

{
    if (style->nsDefs != NULL)
        xsltFreeExtDefList((xsltExtDefPtr) style->nsDefs);
}

Referenced by xsltFreeStylesheet().

xsltGetExtData()

void * xsltGetExtData	(	xsltTransformContextPtr	ctxt,
		const xmlChar *	URI
	)

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

Definition at line 862 of file extensions.c.

{
    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);
}

Referenced by xsltExtElementTest(), and xsltExtFunctionTest().

xsltGetExtInfo()

xmlHashTablePtr xsltGetExtInfo	(	xsltStylesheetPtr	style,
		const xmlChar *	URI
	)

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

Definition at line 1935 of file extensions.c.

{
    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;
}

xsltHashScannerModuleFree()

static void xsltHashScannerModuleFree ( void *payload  ATTRIBUTE_UNUSED, void *data  ATTRIBUTE_UNUSED, const xmlChar *name  ATTRIBUTE_UNUSED  )

static

Definition at line 2242 of file extensions.c.

{
#ifdef WITH_MODULES
    xmlModuleClose(payload);
#endif
}

Referenced by xsltCleanupGlobals().

xsltInitCtxtExt()

static void xsltInitCtxtExt ( void *  payload, void *  data, const xmlChar *  URI  )

static

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

Definition at line 937 of file extensions.c.

{
    xsltExtDataPtr styleData = (xsltExtDataPtr) payload;
    xsltInitExtCtxt *ctxt = (xsltInitExtCtxt *) data;
    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++;
}

Referenced by xsltInitCtxtExts().

xsltInitCtxtExts()

int xsltInitCtxtExts

(

xsltTransformContextPtr

ctxt

)

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

Definition at line 1016 of file extensions.c.

{
    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, 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);
}

Referenced by xsltNewTransformContext().

xsltInitElemPreComp()

void xsltInitElemPreComp	(	xsltElemPreCompPtr	comp,
		xsltStylesheetPtr	style,
		xmlNodePtr	inst,
		xsltTransformFunction	function,
		xsltElemPreCompDeallocator	freeFunc
	)

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.

Definition at line 1535 of file extensions.c.

{
    comp->type = XSLT_FUNC_EXTENSION;
    comp->func = function;
    comp->inst = inst;
    comp->free = freeFunc;
 
    comp->next = style->preComps;
    style->preComps = comp;
}

Referenced by xsltNewElemPreComp().

xsltInitGlobals()

void xsltInitGlobals

(

void

)

xsltInitGlobals:

Initialize the global variables for extensions

Definition at line 2257 of file extensions.c.

{
    if (xsltExtMutex == NULL) {
        xsltExtMutex = xmlNewMutex();
    }
}

Referenced by xsltApplyStylesheetInternal(), xsltLoadStylesheetPI(), xsltNewSecurityPrefs(), xsltNewTransformContext(), xsltParseStylesheetDoc(), xsltParseStylesheetFile(), xsltParseStylesheetProcess(), xsltRegisterTestModule(), and xsltSetSecurityPrefs().

xsltNewElemPreComp()

xsltElemPreCompPtr xsltNewElemPreComp	(	xsltStylesheetPtr	style,
		xmlNodePtr	inst,
		xsltTransformFunction	function
	)

xsltNewElemPreComp: @style: the XSLT stylesheet @inst: the element node @function: the transform function

Creates and initializes an xsltElemPreComp

Returns the new and initialized xsltElemPreComp

Definition at line 1503 of file extensions.c.

{
    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, xsltFreeElemPreComp);
 
    return (cur);
}

Referenced by xsltExtElementPreCompTest(), and xsltPreComputeExtModuleElement().

xsltNewExtData()

static xsltExtDataPtr xsltNewExtData ( xsltExtModulePtr  extModule, void *  extData  )

static

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

Definition at line 205 of file extensions.c.

{
    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);
}

Referenced by xsltGetExtData(), xsltInitCtxtExt(), and xsltStyleInitializeStylesheetModule().

xsltNewExtDef()

static xsltExtDefPtr xsltNewExtDef ( const xmlChar *  prefix, const xmlChar *  URI  )

static

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

Definition at line 90 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterExtPrefix().

xsltNewExtElement()

static xsltExtElementPtr xsltNewExtElement ( xsltPreComputeFunction  precomp, xsltTransformFunction  transform  )

static

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

Definition at line 252 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterExtModuleElement().

xsltNewExtModule()

static xsltExtModulePtr xsltNewExtModule ( xsltExtInitFunction  initFunc, xsltExtShutdownFunction  shutdownFunc, xsltStyleExtInitFunction  styleInitFunc, xsltStyleExtShutdownFunction  styleShutdownFunc  )

static

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

Definition at line 156 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterExtModuleFull().

xsltPreComputeExtModuleElement()

xsltElemPreCompPtr xsltPreComputeExtModuleElement	(	xsltStylesheetPtr	style,
		xmlNodePtr	inst
	)

xsltPreComputeExtModuleElement: @style: the stylesheet @inst: the element node

Precomputes an extension module element

Returns the precomputed data

Definition at line 1558 of file extensions.c.

{
    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);
}

Referenced by xsltStylePreCompute().

xsltRegisterExtElement()

int xsltRegisterExtElement	(	xsltTransformContextPtr	ctxt,
		const xmlChar *	name,
		const xmlChar *	URI,
		xsltTransformFunction	function
	)

Definition at line 621 of file extensions.c.

{
    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)));
}

Referenced by xsltRegisterAllElement().

xsltRegisterExtFunction()

int xsltRegisterExtFunction	(	xsltTransformContextPtr	ctxt,
		const xmlChar *	name,
		const xmlChar *	URI,
		xmlXPathFunction	function
	)

Definition at line 587 of file extensions.c.

{
    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);
}

xsltRegisterExtModule()

int xsltRegisterExtModule	(	const xmlChar *	URI,
		xsltExtInitFunction	initFunc,
		xsltExtShutdownFunction	shutdownFunc
	)

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

Definition at line 1300 of file extensions.c.

{
    return xsltRegisterExtModuleFull(URI, initFunc, shutdownFunc,
                                     NULL, NULL);
}

xsltRegisterExtModuleElement()

int xsltRegisterExtModuleElement	(	const xmlChar *	name,
		const xmlChar *	URI,
		xsltPreComputeFunction	precomp,
		xsltTransformFunction	transform
	)

Definition at line 1623 of file extensions.c.

{
    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,
                        xsltFreeExtElementEntry);
 
done:
    xmlMutexUnlock(xsltExtMutex);
 
    return (ret);
}

Referenced by xsltRegisterAllExtras(), and xsltRegisterTestModule().

xsltRegisterExtModuleFull()

int xsltRegisterExtModuleFull	(	const xmlChar *	URI,
		xsltExtInitFunction	initFunc,
		xsltExtShutdownFunction	shutdownFunc,
		xsltStyleExtInitFunction	styleInitFunc,
		xsltStyleExtShutdownFunction	styleShutdownFunc
	)

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

Definition at line 1248 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterExtModule(), and xsltRegisterTestModule().

xsltRegisterExtModuleFunction()

int xsltRegisterExtModuleFunction	(	const xmlChar *	name,
		const xmlChar *	URI,
		xmlXPathFunction	function
	)

Definition at line 1385 of file extensions.c.

{
    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);
}

Referenced by xsltRegisterAllExtras(), and xsltRegisterTestModule().

xsltRegisterExtModuleTopLevel()

int xsltRegisterExtModuleTopLevel	(	const xmlChar *	name,
		const xmlChar *	URI,
		xsltTopLevelFunction	function
	)

Definition at line 1825 of file extensions.c.

{
    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);
}

xsltRegisterExtPrefix()

int xsltRegisterExtPrefix	(	xsltStylesheetPtr	style,
		const xmlChar *	prefix,
		const xmlChar *	URI
	)

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

Definition at line 503 of file extensions.c.

{
    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);
}

Referenced by xsltParseStylesheetExtPrefix().

xsltRegisterTestModule()

void xsltRegisterTestModule

(

void

)

xsltRegisterTestModule:

Registers the test module

Definition at line 2225 of file extensions.c.

{
    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);
}

xsltShutdownCtxtExt()

static void xsltShutdownCtxtExt ( void *  payload, void *  vctxt, const xmlChar *  URI  )

static

xsltShutdownCtxtExt: @data: the registered data for the module @ctxt: the XSLT transformation context @URI: the extension URI

Shutdown an extension module loaded

Definition at line 1055 of file extensions.c.

{
    xsltExtDataPtr data = (xsltExtDataPtr) payload;
    xsltTransformContextPtr ctxt = (xsltTransformContextPtr) vctxt;
    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);
}

Referenced by xsltShutdownCtxtExts().

xsltShutdownCtxtExts()

void xsltShutdownCtxtExts

(

xsltTransformContextPtr

ctxt

)

xsltShutdownCtxtExts: @ctxt: an XSLT transformation context

Shutdown the set of modules loaded

Definition at line 1081 of file extensions.c.

{
    if (ctxt == NULL)
        return;
    if (ctxt->extInfos == NULL)
        return;
    xmlHashScan(ctxt->extInfos, xsltShutdownCtxtExt, ctxt);
    xmlHashFree(ctxt->extInfos, xsltFreeExtDataEntry);
    ctxt->extInfos = NULL;
}

Referenced by xsltApplyStylesheetInternal(), and xsltFreeTransformContext().

xsltShutdownExt()

static void xsltShutdownExt ( void *  payload, void *  vctxt, const xmlChar *  URI  )

static

xsltShutdownExt: @data: the registered data for the module @ctxt: the XSLT stylesheet @URI: the extension URI

Shutdown an extension module loaded

Definition at line 1101 of file extensions.c.

{
    xsltExtDataPtr data = (xsltExtDataPtr) payload;
    xsltStylesheetPtr style = (xsltStylesheetPtr) vctxt;
    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, xsltFreeExtDataEntry);
    */
}

Referenced by xsltShutdownExts().

xsltShutdownExts()

void xsltShutdownExts

(

xsltStylesheetPtr

style

)

xsltShutdownExts: @style: an XSLT stylesheet

Shutdown the set of modules loaded

Definition at line 1133 of file extensions.c.

{
    if (style == NULL)
        return;
    if (style->extInfos == NULL)
        return;
    xmlHashScan(style->extInfos, xsltShutdownExt, style);
    xmlHashFree(style->extInfos, xsltFreeExtDataEntry);
    style->extInfos = NULL;
}

Referenced by xsltFreeStylesheet().

xsltStyleGetExtData()

void * xsltStyleGetExtData	(	xsltStylesheetPtr	style,
		const xmlChar *	URI
	)

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

Definition at line 756 of file extensions.c.

{
    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);
}

Referenced by xsltExtElementPreCompTest(), xsltExtInitTest(), and xsltRegisterExtPrefix().

xsltStyleInitializeStylesheetModule()

static xsltExtDataPtr xsltStyleInitializeStylesheetModule ( xsltStylesheetPtr  style, const xmlChar *  URI  )

static

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.

Definition at line 663 of file extensions.c.

{
    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);
}

Referenced by xsltStyleGetExtData().

xsltUnregisterAllExtModuleElement()

static void xsltUnregisterAllExtModuleElement ( void  )

static

xsltUnregisterAllExtModuleElement:

Unregisters all extension module element

Definition at line 1804 of file extensions.c.

{
    xmlMutexLock(xsltExtMutex);
 
    xmlHashFree(xsltElementsHash, xsltFreeExtElementEntry);
    xsltElementsHash = NULL;
 
    xmlMutexUnlock(xsltExtMutex);
}

Referenced by xsltCleanupGlobals().

xsltUnregisterAllExtModuleFunction()

static void xsltUnregisterAllExtModuleFunction ( void  )

static

xsltUnregisterAllExtModuleFunction:

Unregisters all extension module function

Definition at line 1476 of file extensions.c.

{
    xmlMutexLock(xsltExtMutex);
 
    xmlHashFree(xsltFunctionsHash, NULL);
    xsltFunctionsHash = NULL;
 
    xmlMutexUnlock(xsltExtMutex);
}

Referenced by xsltCleanupGlobals().

xsltUnregisterAllExtModules()

static void xsltUnregisterAllExtModules ( void  )

static

xsltUnregisterAllExtModules:

Unregister all the XSLT extension module from the library.

Definition at line 1341 of file extensions.c.

{
    if (xsltExtensionsHash == NULL)
        return;
 
    xmlMutexLock(xsltExtMutex);
 
    xmlHashFree(xsltExtensionsHash, xsltFreeExtModuleEntry);
    xsltExtensionsHash = NULL;
 
    xmlMutexUnlock(xsltExtMutex);
}

Referenced by xsltCleanupGlobals().

xsltUnregisterAllExtModuleTopLevel()

static void xsltUnregisterAllExtModuleTopLevel ( void  )

static

xsltUnregisterAllExtModuleTopLevel:

Unregisters all extension module function

Definition at line 1915 of file extensions.c.

{
    xmlMutexLock(xsltExtMutex);
 
    xmlHashFree(xsltTopLevelsHash, NULL);
    xsltTopLevelsHash = NULL;
 
    xmlMutexUnlock(xsltExtMutex);
}

Referenced by xsltCleanupGlobals().

xsltUnregisterExtModule()

int xsltUnregisterExtModule

(

const xmlChar *

URI

)

xsltUnregisterExtModule: @URI: URI associated to this module

Unregister an XSLT extension module from the library.

Returns 0 if sucessful, -1 in case of error

Definition at line 1317 of file extensions.c.

{
    int ret;
 
    if (URI == NULL)
        return (-1);
    if (xsltExtensionsHash == NULL)
        return (-1);
 
    xmlMutexLock(xsltExtMutex);
 
    ret = xmlHashRemoveEntry(xsltExtensionsHash, URI, xsltFreeExtModuleEntry);
 
    xmlMutexUnlock(xsltExtMutex);
 
    return (ret);
}

xsltUnregisterExtModuleElement()

int xsltUnregisterExtModuleElement	(	const xmlChar *	name,
		const xmlChar *	URI
	)

Definition at line 1781 of file extensions.c.

{
    int ret;
 
    if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
        return (-1);
 
    xmlMutexLock(xsltExtMutex);
 
    ret = xmlHashRemoveEntry2(xsltElementsHash, name, URI,
                              xsltFreeExtElementEntry);
 
    xmlMutexUnlock(xsltExtMutex);
 
    return(ret);
}

xsltUnregisterExtModuleFunction()

int xsltUnregisterExtModuleFunction	(	const xmlChar *	name,
		const xmlChar *	URI
	)

Definition at line 1454 of file extensions.c.

{
    int ret;
 
    if ((xsltFunctionsHash == NULL) || (name == NULL) || (URI == NULL))
        return (-1);
 
    xmlMutexLock(xsltExtMutex);
 
    ret = xmlHashRemoveEntry2(xsltFunctionsHash, name, URI, NULL);
 
    xmlMutexUnlock(xsltExtMutex);
 
    return(ret);
}

xsltUnregisterExtModuleTopLevel()

int xsltUnregisterExtModuleTopLevel	(	const xmlChar *	name,
		const xmlChar *	URI
	)

Definition at line 1893 of file extensions.c.

{
    int ret;
 
    if ((xsltTopLevelsHash == NULL) || (name == NULL) || (URI == NULL))
        return (-1);
 
    xmlMutexLock(xsltExtMutex);
 
    ret = xmlHashRemoveEntry2(xsltTopLevelsHash, name, URI, NULL);
 
    xmlMutexUnlock(xsltExtMutex);
 
    return(ret);
}

xsltXPathGetTransformContext()

xsltTransformContextPtr xsltXPathGetTransformContext

(

xmlXPathParserContextPtr

ctxt

)

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.

Definition at line 1367 of file extensions.c.

{
    if ((ctxt == NULL) || (ctxt->context == NULL))
        return (NULL);
    return (ctxt->context->extra);
}

Referenced by xsltCurrentFunction(), xsltDocumentFunction(), xsltDocumentFunctionLoadDocument(), xsltElementAvailableFunction(), xsltExtFunctionTest(), xsltFormatNumberFunction(), xsltFunctionAvailableFunction(), xsltFunctionNodeSet(), xsltGenerateIdFunction(), xsltKeyFunction(), and xsltSystemPropertyFunction().

Variable Documentation

testData

xmlChar* testData = NULL

static

Definition at line 1960 of file extensions.c.

Referenced by xsltExtElementTest(), xsltExtFunctionTest(), xsltExtInitTest(), and xsltExtShutdownTest().

testStyleData

xmlChar* testStyleData = NULL

static

Definition at line 1961 of file extensions.c.

Referenced by xsltExtElementPreCompTest(), xsltExtInitTest(), xsltExtStyleInitTest(), and xsltExtStyleShutdownTest().

xsltElementsHash

xmlHashTablePtr xsltElementsHash = NULL

static

Definition at line 69 of file extensions.c.

Referenced by xsltDebugDumpExtensions(), xsltExtModuleElementLookup(), xsltExtModuleElementPreComputeLookup(), xsltPreComputeExtModuleElement(), xsltRegisterExtModuleElement(), xsltUnregisterAllExtModuleElement(), and xsltUnregisterExtModuleElement().

xsltExtensionsHash

xmlHashTablePtr xsltExtensionsHash = NULL

static

Definition at line 67 of file extensions.c.

Referenced by xsltDebugDumpExtensions(), xsltGetExtData(), xsltRegisterExtModuleFull(), xsltRegisterExtPrefix(), xsltStyleGetExtData(), xsltStyleInitializeStylesheetModule(), xsltUnregisterAllExtModules(), and xsltUnregisterExtModule().

xsltExtMutex

xmlMutexPtr xsltExtMutex = NULL

static

Definition at line 72 of file extensions.c.

Referenced by xsltCleanupGlobals(), xsltDebugDumpExtensions(), xsltExtModuleElementLookup(), xsltExtModuleElementPreComputeLookup(), xsltExtModuleFunctionLookup(), xsltExtModuleTopLevelLookup(), xsltGetExtData(), xsltInitGlobals(), xsltPreComputeExtModuleElement(), xsltRegisterExtModuleElement(), xsltRegisterExtModuleFull(), xsltRegisterExtModuleFunction(), xsltRegisterExtModuleTopLevel(), xsltRegisterExtPrefix(), xsltStyleInitializeStylesheetModule(), xsltUnregisterAllExtModuleElement(), xsltUnregisterAllExtModuleFunction(), xsltUnregisterAllExtModules(), xsltUnregisterAllExtModuleTopLevel(), xsltUnregisterExtModule(), xsltUnregisterExtModuleElement(), xsltUnregisterExtModuleFunction(), and xsltUnregisterExtModuleTopLevel().

xsltFunctionsHash

xmlHashTablePtr xsltFunctionsHash = NULL

static

Definition at line 68 of file extensions.c.

Referenced by xsltDebugDumpExtensions(), xsltExtModuleFunctionLookup(), xsltRegisterExtModuleFunction(), xsltUnregisterAllExtModuleFunction(), and xsltUnregisterExtModuleFunction().

xsltModuleHash

xmlHashTablePtr xsltModuleHash = NULL

static

Definition at line 71 of file extensions.c.

Referenced by xsltCleanupGlobals().

xsltTopLevelsHash

xmlHashTablePtr xsltTopLevelsHash = NULL

static

Definition at line 70 of file extensions.c.

Referenced by xsltExtModuleTopLevelLookup(), xsltRegisterExtModuleTopLevel(), xsltUnregisterAllExtModuleTopLevel(), and xsltUnregisterExtModuleTopLevel().