extensions.c File Reference

#include "libxslt.h"
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/hash.h>
#include <libxml/xmlerror.h>
#include <libxml/parserInternals.h>
#include <libxml/xpathInternals.h>
#include <libxml/list.h>
#include <libxml/xmlIO.h>
#include <libxml/threads.h>
#include "xslt.h"
#include "xsltInternals.h"
#include "xsltlocale.h"
#include "xsltutils.h"
#include "imports.h"
#include "extensions.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

Macros
#define	IN_LIBXSLT

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)

Macro Definition Documentation

IN_LIBXSLT

#define IN_LIBXSLT

Definition at line 12 of file extensions.c.

Typedef Documentation

xsltExtData

typedef struct _xsltExtData xsltExtData

Definition at line 73 of file extensions.c.

xsltExtDataPtr

typedef xsltExtData* xsltExtDataPtr

Definition at line 74 of file extensions.c.

xsltExtDef

typedef struct _xsltExtDef xsltExtDef

Definition at line 55 of file extensions.c.

xsltExtDefPtr

typedef xsltExtDef* xsltExtDefPtr

Definition at line 56 of file extensions.c.

xsltExtElement

typedef struct _xsltExtElement xsltExtElement

Definition at line 80 of file extensions.c.

xsltExtElementPtr

typedef xsltExtElement* xsltExtElementPtr

Definition at line 81 of file extensions.c.

xsltExtModule

typedef struct _xsltExtModule xsltExtModule

Definition at line 64 of file extensions.c.

xsltExtModulePtr

typedef xsltExtModule* xsltExtModulePtr

Definition at line 65 of file extensions.c.

xsltInitExtCtxt

typedef struct _xsltInitExtCtxt xsltInitExtCtxt

Definition at line 942 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 1183 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 1243 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 2295 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();
}

Referenced by DllMain().

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 2348 of file extensions.c.

{
    if (output == NULL)
        output = stdout;
    fprintf(output,
            "Registered XSLT Extensions\n--------------------------\n");
    xmlMutexLock(xsltExtMutex);
    if (!xsltFunctionsHash) {
        fprintf(output, "No registered extension functions\n");
    } else {
        fprintf(output, "Registered extension functions:\n");
        xmlHashScanFull(xsltFunctionsHash, xsltDebugDumpExtensionsCallback,
                        output);
    }
    if (!xsltTopLevelsHash) {
        fprintf(output, "\nNo registered top-level extension elements\n");
    } else {
        fprintf(output, "\nRegistered top-level extension elements:\n");
        xmlHashScanFull(xsltTopLevelsHash, xsltDebugDumpExtensionsCallback,
                        output);
    }
    if (!xsltElementsHash) {
        fprintf(output, "\nNo registered instruction extension elements\n");
    } else {
        fprintf(output, "\nRegistered instruction extension elements:\n");
        xmlHashScanFull(xsltElementsHash, xsltDebugDumpExtensionsCallback,
                        output);
    }
    if (!xsltExtensionsHash) {
        fprintf(output, "\nNo registered extension modules\n");
    } else {
        fprintf(output, "\nRegistered extension modules:\n");
        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 2318 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 2330 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 1693 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 2046 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 2090 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 1996 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 2142 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 1723 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 1766 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 1441 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 481 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 1881 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 2176 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 2203 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 2227 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 664 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 1513 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 249 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 257 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 135 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 153 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 298 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 306 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 203 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 211 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 501 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 883 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) ||
                (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 1960 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 2267 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 957 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) {
        if (module->shutdownFunc)
            module->shutdownFunc(ctxt->ctxt, URI, extData);
        ctxt->ret = -1;
        return;
    }
 
    if (ctxt->ctxt->extInfos == NULL)
        ctxt->ctxt->extInfos = xmlHashCreate(10);
    if (ctxt->ctxt->extInfos == NULL) {
        if (module->shutdownFunc)
            module->shutdownFunc(ctxt->ctxt, URI, extData);
        xsltFreeExtData(ctxtData);
        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 1041 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 1560 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 2282 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 1528 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 225 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 110 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 272 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 176 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 1583 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 643 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 609 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 1325 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 1648 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 1273 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 1410 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 init_libxslt(), xsltRegisterAllExtras(), and xsltRegisterTestModule().

xsltRegisterExtModuleTopLevel()

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

Definition at line 1850 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 525 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 2250 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 1080 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 1106 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 1126 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 1158 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 781 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;
    if (tmpStyle->extInfos != NULL) {
        dataContainer =
            (xsltExtDataPtr) xmlHashLookup(tmpStyle->extInfos, URI);
        if (dataContainer != NULL) {
            return(dataContainer->extData);
        }
    }
#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 685 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) {
    if (module->styleShutdownFunc)
        module->styleShutdownFunc(style, URI, userData);
    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 1829 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 1501 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 1366 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 1940 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 1342 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 1806 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 1479 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 1918 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 1392 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 1985 of file extensions.c.

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

testStyleData

xmlChar* testStyleData = NULL

static

Definition at line 1986 of file extensions.c.

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

xsltElementsHash

xmlHashTablePtr xsltElementsHash = NULL

static

Definition at line 89 of file extensions.c.

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

xsltExtensionsHash

xmlHashTablePtr xsltExtensionsHash = NULL

static

Definition at line 87 of file extensions.c.

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

xsltExtMutex

xmlMutexPtr xsltExtMutex = NULL

static

Definition at line 92 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 88 of file extensions.c.

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

xsltModuleHash

xmlHashTablePtr xsltModuleHash = NULL

static

Definition at line 91 of file extensions.c.

Referenced by xsltCleanupGlobals().

xsltTopLevelsHash

xmlHashTablePtr xsltTopLevelsHash = NULL

static

Definition at line 90 of file extensions.c.

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