extensions.h File Reference

#include <libxml/xpath.h>
#include "xsltexports.h"
#include "xsltInternals.h"

Include dependency graph for extensions.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef void *(*	xsltStyleExtInitFunction) (xsltStylesheetPtr style, const xmlChar *URI)
typedef void(*	xsltStyleExtShutdownFunction) (xsltStylesheetPtr style, const xmlChar *URI, void *data)
typedef void *(*	xsltExtInitFunction) (xsltTransformContextPtr ctxt, const xmlChar *URI)
typedef void(*	xsltExtShutdownFunction) (xsltTransformContextPtr ctxt, const xmlChar *URI, void *data)
typedef xsltElemPreCompPtr(*	xsltPreComputeFunction) (xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function)
typedef void(*	xsltTopLevelFunction) (xsltStylesheetPtr style, xmlNodePtr inst)

Functions
XSLTPUBFUN void XSLTCALL	xsltInitGlobals (void)
XSLTPUBFUN int XSLTCALL	xsltRegisterExtModule (const xmlChar *URI, xsltExtInitFunction initFunc, xsltExtShutdownFunction shutdownFunc)
XSLTPUBFUN int XSLTCALL	xsltRegisterExtModuleFull (const xmlChar *URI, xsltExtInitFunction initFunc, xsltExtShutdownFunction shutdownFunc, xsltStyleExtInitFunction styleInitFunc, xsltStyleExtShutdownFunction styleShutdownFunc)
XSLTPUBFUN int XSLTCALL	xsltUnregisterExtModule (const xmlChar *URI)
XSLTPUBFUN void *XSLTCALL	xsltGetExtData (xsltTransformContextPtr ctxt, const xmlChar *URI)
XSLTPUBFUN void *XSLTCALL	xsltStyleGetExtData (xsltStylesheetPtr style, const xmlChar *URI)
XSLTPUBFUN void XSLTCALL	xsltShutdownCtxtExts (xsltTransformContextPtr ctxt)
XSLTPUBFUN void XSLTCALL	xsltShutdownExts (xsltStylesheetPtr style)
XSLTPUBFUN xsltTransformContextPtr XSLTCALL	xsltXPathGetTransformContext (xmlXPathParserContextPtr ctxt)
XSLTPUBFUN int XSLTCALL	xsltRegisterExtModuleFunction (const xmlChar *name, const xmlChar *URI, xmlXPathFunction function)
XSLTPUBFUN xmlXPathFunction XSLTCALL	xsltExtModuleFunctionLookup (const xmlChar *name, const xmlChar *URI)
XSLTPUBFUN int XSLTCALL	xsltUnregisterExtModuleFunction (const xmlChar *name, const xmlChar *URI)
XSLTPUBFUN xsltElemPreCompPtr XSLTCALL	xsltNewElemPreComp (xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function)
XSLTPUBFUN void XSLTCALL	xsltInitElemPreComp (xsltElemPreCompPtr comp, xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function, xsltElemPreCompDeallocator freeFunc)
XSLTPUBFUN int XSLTCALL	xsltRegisterExtModuleElement (const xmlChar *name, const xmlChar *URI, xsltPreComputeFunction precomp, xsltTransformFunction transform)
XSLTPUBFUN xsltTransformFunction XSLTCALL	xsltExtElementLookup (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *URI)
XSLTPUBFUN xsltTransformFunction XSLTCALL	xsltExtModuleElementLookup (const xmlChar *name, const xmlChar *URI)
XSLTPUBFUN xsltPreComputeFunction XSLTCALL	xsltExtModuleElementPreComputeLookup (const xmlChar *name, const xmlChar *URI)
XSLTPUBFUN int XSLTCALL	xsltUnregisterExtModuleElement (const xmlChar *name, const xmlChar *URI)
XSLTPUBFUN int XSLTCALL	xsltRegisterExtModuleTopLevel (const xmlChar *name, const xmlChar *URI, xsltTopLevelFunction function)
XSLTPUBFUN xsltTopLevelFunction XSLTCALL	xsltExtModuleTopLevelLookup (const xmlChar *name, const xmlChar *URI)
XSLTPUBFUN int XSLTCALL	xsltUnregisterExtModuleTopLevel (const xmlChar *name, const xmlChar *URI)
XSLTPUBFUN int XSLTCALL	xsltRegisterExtFunction (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *URI, xmlXPathFunction function)
XSLTPUBFUN int XSLTCALL	xsltRegisterExtElement (xsltTransformContextPtr ctxt, const xmlChar *name, const xmlChar *URI, xsltTransformFunction function)
XSLTPUBFUN int XSLTCALL	xsltRegisterExtPrefix (xsltStylesheetPtr style, const xmlChar *prefix, const xmlChar *URI)
XSLTPUBFUN int XSLTCALL	xsltCheckExtPrefix (xsltStylesheetPtr style, const xmlChar *URI)
XSLTPUBFUN int XSLTCALL	xsltCheckExtURI (xsltStylesheetPtr style, const xmlChar *URI)
XSLTPUBFUN int XSLTCALL	xsltInitCtxtExts (xsltTransformContextPtr ctxt)
XSLTPUBFUN void XSLTCALL	xsltFreeCtxtExts (xsltTransformContextPtr ctxt)
XSLTPUBFUN void XSLTCALL	xsltFreeExts (xsltStylesheetPtr style)
XSLTPUBFUN xsltElemPreCompPtr XSLTCALL	xsltPreComputeExtModuleElement (xsltStylesheetPtr style, xmlNodePtr inst)
XSLTPUBFUN xmlHashTablePtr XSLTCALL	xsltGetExtInfo (xsltStylesheetPtr style, const xmlChar *URI)
XSLTPUBFUN void XSLTCALL	xsltRegisterTestModule (void)
XSLTPUBFUN void XSLTCALL	xsltDebugDumpExtensions (FILE *output)

Typedef Documentation

xsltExtInitFunction

typedef void *(* xsltExtInitFunction) (xsltTransformContextPtr ctxt, const xmlChar *URI)

xsltExtInitFunction: @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 69 of file extensions.h.

xsltExtShutdownFunction

typedef void(* xsltExtShutdownFunction) (xsltTransformContextPtr ctxt, const xmlChar *URI, void *data)

xsltExtShutdownFunction: @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 80 of file extensions.h.

xsltPreComputeFunction

typedef xsltElemPreCompPtr(* xsltPreComputeFunction) (xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function)

Definition at line 141 of file extensions.h.

xsltStyleExtInitFunction

typedef void *(* xsltStyleExtInitFunction) (xsltStylesheetPtr style, const xmlChar *URI)

xsltStyleExtInitFunction: @ctxt: 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 45 of file extensions.h.

xsltStyleExtShutdownFunction

typedef void(* xsltStyleExtShutdownFunction) (xsltStylesheetPtr style, const xmlChar *URI, void *data)

xsltStyleExtShutdownFunction: @ctxt: 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 56 of file extensions.h.

xsltTopLevelFunction

typedef void(* xsltTopLevelFunction) (xsltStylesheetPtr style, xmlNodePtr inst)

Definition at line 183 of file extensions.h.

Function Documentation

xsltCheckExtPrefix()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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().

xsltDebugDumpExtensions()

XSLTPUBFUN void XSLTCALL 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);
}

xsltExtElementLookup()

XSLTPUBFUN xsltTransformFunction XSLTCALL 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().

xsltExtModuleElementLookup()

XSLTPUBFUN xsltTransformFunction XSLTCALL 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()

XSLTPUBFUN xsltPreComputeFunction XSLTCALL 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()

XSLTPUBFUN xmlXPathFunction XSLTCALL 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().

xsltExtModuleTopLevelLookup()

XSLTPUBFUN xsltTopLevelFunction XSLTCALL 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().

xsltFreeCtxtExts()

XSLTPUBFUN void XSLTCALL 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().

xsltFreeExts()

XSLTPUBFUN void XSLTCALL 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()

XSLTPUBFUN void *XSLTCALL 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()

XSLTPUBFUN xmlHashTablePtr XSLTCALL 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;
}

xsltInitCtxtExts()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN void XSLTCALL 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()

XSLTPUBFUN void XSLTCALL xsltInitGlobals

(

void

)

Extension Modules API. xsltInitGlobals:

Initialize the global variables for extensions

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()

XSLTPUBFUN xsltElemPreCompPtr XSLTCALL 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().

xsltPreComputeExtModuleElement()

XSLTPUBFUN xsltElemPreCompPtr XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN void XSLTCALL xsltRegisterTestModule

(

void

)

Test of the extension module API

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

xsltShutdownCtxtExts()

XSLTPUBFUN void XSLTCALL 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().

xsltShutdownExts()

XSLTPUBFUN void XSLTCALL 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()

XSLTPUBFUN void *XSLTCALL 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().

xsltUnregisterExtModule()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN int XSLTCALL 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()

XSLTPUBFUN xsltTransformContextPtr XSLTCALL 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().