ReactOS 0.4.15-dev-8344-g0574987
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 1158 of file extensions.c.

1159{
1160#ifdef XSLT_REFACTORED
1161 if ((style == NULL) || (style->compCtxt == NULL) ||
1162 (XSLT_CCTXT(style)->inode == NULL) ||
1163 (XSLT_CCTXT(style)->inode->extElemNs == NULL))
1164 return (0);
1165 /*
1166 * Lookup the extension namespaces registered
1167 * at the current node in the stylesheet's tree.
1168 */
1169 if (XSLT_CCTXT(style)->inode->extElemNs != NULL) {
1170 int i;
1171 xsltPointerListPtr list = XSLT_CCTXT(style)->inode->extElemNs;
1172
1173 for (i = 0; i < list->number; i++) {
1174 if (xmlStrEqual((const xmlChar *) list->items[i],
1175 URI))
1176 {
1177 return(1);
1178 }
1179 }
1180 }
1181#else
1183
1184 if ((style == NULL) || (style->nsDefs == NULL))
1185 return (0);
1186 if (URI == NULL)
1187 URI = BAD_CAST "#default";
1188 cur = (xsltExtDefPtr) style->nsDefs;
1189 while (cur != NULL) {
1190 /*
1191 * NOTE: This was change to work on namespace names rather
1192 * than namespace prefixes. This fixes bug #339583.
1193 * TODO: Consider renaming the field "prefix" of xsltExtDef
1194 * to "href".
1195 */
1196 if (xmlStrEqual(URI, cur->prefix))
1197 return (1);
1198 cur = cur->next;
1199 }
1200#endif
1201 return (0);
1202}
xsltExtDef * xsltExtDefPtr
Definition: extensions.c:36
Arabic default style
Definition: afstyles.h:94
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
Definition: list.h:37
#define NULL
Definition: types.h:112
FxCollectionEntry * cur
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Definition: fs.h:78
#define BAD_CAST
Definition: xmlstring.h:35
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
unsigned char xmlChar
Definition: xmlstring.h:28

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

1219{
1221
1222 if ((style == NULL) || (style->nsDefs == NULL))
1223 return (0);
1224 if (URI == NULL)
1225 return (0);
1226 cur = (xsltExtDefPtr) style->nsDefs;
1227 while (cur != NULL) {
1228 if (xmlStrEqual(URI, cur->URI))
1229 return (1);
1230 cur = cur->next;
1231 }
1232 return (0);
1233}

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

2324{
2325 if (output == NULL)
2326 output = stdout;
2327 fprintf(output,
2328 "Registered XSLT Extensions\n--------------------------\n");
2329 if (!xsltFunctionsHash)
2330 fprintf(output, "No registered extension functions\n");
2331 else {
2332 fprintf(output, "Registered Extension Functions:\n");
2335 output);
2337 }
2338 if (!xsltElementsHash)
2339 fprintf(output, "\nNo registered extension elements\n");
2340 else {
2341 fprintf(output, "\nRegistered Extension Elements:\n");
2344 output);
2346 }
2347 if (!xsltExtensionsHash)
2348 fprintf(output, "\nNo registered extension modules\n");
2349 else {
2350 fprintf(output, "\nRegistered Extension Modules:\n");
2353 output);
2355 }
2356
2357}
static xmlMutexPtr xsltExtMutex
Definition: extensions.c:72
static void xsltDebugDumpExtModulesCallback(void *function ATTRIBUTE_UNUSED, void *data, const xmlChar *URI, const xmlChar *not_used ATTRIBUTE_UNUSED, const xmlChar *not_used2 ATTRIBUTE_UNUSED)
Definition: extensions.c:2305
static xmlHashTablePtr xsltFunctionsHash
Definition: extensions.c:68
static xmlHashTablePtr xsltElementsHash
Definition: extensions.c:69
static xmlHashTablePtr xsltExtensionsHash
Definition: extensions.c:67
static void xsltDebugDumpExtensionsCallback(void *function ATTRIBUTE_UNUSED, void *data, const xmlChar *name, const xmlChar *URI, const xmlChar *not_used ATTRIBUTE_UNUSED)
Definition: extensions.c:2293
#define stdout
Definition: stdio.h:99
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
XMLPUBFUN void XMLCALL xmlHashScanFull(xmlHashTablePtr table, xmlHashScannerFull f, void *data)
Definition: hash.c:875
XMLPUBFUN void XMLCALL xmlMutexUnlock(xmlMutexPtr tok)
Definition: threads.c:248
XMLPUBFUN void XMLCALL xmlMutexLock(xmlMutexPtr tok)
Definition: threads.c:220

◆ xsltExtElementLookup()

XSLTPUBFUN xsltTransformFunction XSLTCALL xsltExtElementLookup ( xsltTransformContextPtr  ctxt,
const xmlChar name,
const xmlChar URI 
)

Definition at line 1668 of file extensions.c.

1670{
1672
1673 if ((name == NULL) || (URI == NULL))
1674 return (NULL);
1675
1676 if ((ctxt != NULL) && (ctxt->extElements != NULL)) {
1678 if (ret != NULL) {
1679 return(ret);
1680 }
1681 }
1682
1684
1685 return (ret);
1686}
xsltTransformFunction xsltExtModuleElementLookup(const xmlChar *name, const xmlChar *URI)
Definition: extensions.c:1698
#define XML_CAST_FPTR(fptr)
Definition: hash.h:56
XMLPUBFUN void *XMLCALL xmlHashLookup2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2)
Definition: hash.c:476
xmlHashTablePtr extElements
Definition: name.c:39
int ret
void(* xsltTransformFunction)(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp)

Referenced by xsltApplySequenceConstructor(), and xsltElementAvailableFunction().

◆ xsltExtModuleElementLookup()

XSLTPUBFUN xsltTransformFunction XSLTCALL xsltExtModuleElementLookup ( const xmlChar name,
const xmlChar URI 
)

Definition at line 1698 of file extensions.c.

1699{
1701
1702 if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
1703 return (NULL);
1704
1706
1708
1710
1711 /*
1712 * if function lookup fails, attempt a dynamic load on
1713 * supported platforms
1714 */
1715 if (NULL == ext) {
1716 if (!xsltExtModuleRegisterDynamic(URI)) {
1718
1721
1723 }
1724 }
1725
1726 if (ext == NULL)
1727 return (NULL);
1728 return (ext->transform);
1729}
static int xsltExtModuleRegisterDynamic(const xmlChar *URI ATTRIBUTE_UNUSED)
Definition: extensions.c:459
xsltExtElement * xsltExtElementPtr
Definition: extensions.c:61
static const WCHAR *const ext[]
Definition: module.c:53

Referenced by xsltExtElementLookup().

◆ xsltExtModuleElementPreComputeLookup()

XSLTPUBFUN xsltPreComputeFunction XSLTCALL xsltExtModuleElementPreComputeLookup ( const xmlChar name,
const xmlChar URI 
)

Definition at line 1741 of file extensions.c.

1743{
1745
1746 if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
1747 return (NULL);
1748
1750
1752
1754
1755 if (ext == NULL) {
1756 if (!xsltExtModuleRegisterDynamic(URI)) {
1758
1761
1763 }
1764 }
1765
1766 if (ext == NULL)
1767 return (NULL);
1768 return (ext->precomp);
1769}

◆ xsltExtModuleFunctionLookup()

XSLTPUBFUN xmlXPathFunction XSLTCALL xsltExtModuleFunctionLookup ( const xmlChar name,
const xmlChar URI 
)

Definition at line 1416 of file extensions.c.

1417{
1418 xmlXPathFunction ret;
1419
1420 if ((xsltFunctionsHash == NULL) || (name == NULL) || (URI == NULL))
1421 return (NULL);
1422
1424
1426
1428
1429 /* if lookup fails, attempt a dynamic load on supported platforms */
1430 if (NULL == ret) {
1431 if (!xsltExtModuleRegisterDynamic(URI)) {
1433
1436
1438 }
1439 }
1440
1441 return ret;
1442}

Referenced by xsltXPathFunctionLookup().

◆ xsltExtModuleTopLevelLookup()

XSLTPUBFUN xsltTopLevelFunction XSLTCALL xsltExtModuleTopLevelLookup ( const xmlChar name,
const xmlChar URI 
)

Definition at line 1856 of file extensions.c.

1857{
1859
1860 if ((xsltTopLevelsHash == NULL) || (name == NULL) || (URI == NULL))
1861 return (NULL);
1862
1864
1866
1868
1869 /* if lookup fails, attempt a dynamic load on supported platforms */
1870 if (NULL == ret) {
1871 if (!xsltExtModuleRegisterDynamic(URI)) {
1873
1875
1877 }
1878 }
1879
1880 return (ret);
1881}
static xmlHashTablePtr xsltTopLevelsHash
Definition: extensions.c:70
void(* xsltTopLevelFunction)(xsltStylesheetPtr style, xmlNodePtr inst)
Definition: extensions.h:183

Referenced by xsltParseStylesheetTop().

◆ xsltFreeCtxtExts()

XSLTPUBFUN void XSLTCALL xsltFreeCtxtExts ( xsltTransformContextPtr  ctxt)

xsltFreeCtxtExts: @ctxt: an XSLT transformation context

Free the XSLT extension data

Definition at line 642 of file extensions.c.

643{
644 if (ctxt->extElements != NULL)
646 if (ctxt->extFunctions != NULL)
648}
XMLPUBFUN void XMLCALL xmlHashFree(xmlHashTablePtr table, xmlHashDeallocator f)
Definition: hash.c:322
xmlHashTablePtr extFunctions

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

480{
481 if (style->nsDefs != NULL)
483}
static void xsltFreeExtDefList(xsltExtDefPtr extensiond)
Definition: extensions.c:133

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

863{
865
866 if ((ctxt == NULL) || (URI == NULL))
867 return (NULL);
868 if (ctxt->extInfos == NULL) {
869 ctxt->extInfos = xmlHashCreate(10);
870 if (ctxt->extInfos == NULL)
871 return (NULL);
872 data = NULL;
873 } else {
875 }
876 if (data == NULL) {
877 void *extData;
879
881
883
885
886 if (module == NULL) {
887#ifdef WITH_XSLT_DEBUG_EXTENSIONS
889 "Not registered extension module: %s\n", URI);
890#endif
891 return (NULL);
892 } else {
893 if (module->initFunc == NULL)
894 return (NULL);
895
896#ifdef WITH_XSLT_DEBUG_EXTENSIONS
898 "Initializing module: %s\n", URI);
899#endif
900
901 extData = module->initFunc(ctxt, URI);
902 if (extData == NULL)
903 return (NULL);
904
905 data = xsltNewExtData(module, extData);
906 if (data == NULL)
907 return (NULL);
908 if (xmlHashAddEntry(ctxt->extInfos, URI, (void *) data) < 0) {
910 "Failed to register module data: %s\n",
911 URI);
912 if (module->shutdownFunc)
913 module->shutdownFunc(ctxt, URI, extData);
915 return (NULL);
916 }
917 }
918 }
919 return (data->extData);
920}
static void xsltFreeExtData(xsltExtDataPtr ext)
Definition: extensions.c:229
static xsltExtDataPtr xsltNewExtData(xsltExtModulePtr extModule, void *extData)
Definition: extensions.c:205
xsltExtData * xsltExtDataPtr
Definition: extensions.c:54
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
XMLPUBFUN void *XMLCALL xmlHashLookup(xmlHashTablePtr table, const xmlChar *name)
Definition: hash.c:461
XMLPUBFUN xmlHashTablePtr XMLCALL xmlHashCreate(int size)
Definition: hash.c:176
XMLPUBFUN int XMLCALL xmlHashAddEntry(xmlHashTablePtr table, const xmlChar *name, void *userdata)
Definition: hash.c:389
xmlHashTablePtr extInfos
void xsltTransformError(xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)
Definition: xsltutils.c:678
xmlGenericErrorFunc xsltGenericDebug
Definition: xsltutils.c:548
void * xsltGenericDebugContext
Definition: xsltutils.c:549

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

1936{
1938
1939 /*
1940 * TODO: Why do we have a return type of xmlHashTablePtr?
1941 * Is the user-allocated data for extension modules expected
1942 * to be a xmlHashTablePtr only? Or is this intended for
1943 * the EXSLT module only?
1944 */
1945
1946 if (style != NULL && style->extInfos != NULL) {
1947 data = xmlHashLookup(style->extInfos, URI);
1948 if (data != NULL && data->extData != NULL)
1949 return data->extData;
1950 }
1951 return NULL;
1952}

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

1017{
1020
1021 if (ctxt == NULL)
1022 return (-1);
1023
1024 style = ctxt->style;
1025 if (style == NULL)
1026 return (-1);
1027
1028 ctx.ctxt = ctxt;
1029 ctx.ret = 0;
1030
1031 while (style != NULL) {
1032 if (style->extInfos != NULL) {
1033 xmlHashScan(style->extInfos, xsltInitCtxtExt, &ctx);
1034 if (ctx.ret == -1)
1035 return (-1);
1036 }
1038 }
1039#ifdef WITH_XSLT_DEBUG_EXTENSIONS
1040 xsltGenericDebug(xsltGenericDebugContext, "Registered %d modules\n",
1041 ctx.ret);
1042#endif
1043 return (ctx.ret);
1044}
static void xsltInitCtxtExt(void *payload, void *data, const xmlChar *URI)
Definition: extensions.c:937
xsltStylesheetPtr xsltNextImport(xsltStylesheetPtr cur)
Definition: imports.c:251
XMLPUBFUN void XMLCALL xmlHashScan(xmlHashTablePtr table, xmlHashScanner f, void *data)
Definition: hash.c:859
xsltStylesheetPtr style

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

1538{
1539 comp->type = XSLT_FUNC_EXTENSION;
1540 comp->func = function;
1541 comp->inst = inst;
1542 comp->free = freeFunc;
1543
1544 comp->next = style->preComps;
1545 style->preComps = comp;
1546}
xsltElemPreCompDeallocator free
xsltElemPreCompPtr next
xsltStyleType type
xsltTransformFunction func
@ XSLT_FUNC_EXTENSION

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

2258{
2259 if (xsltExtMutex == NULL) {
2261 }
2262}
XMLPUBFUN xmlMutexPtr XMLCALL xmlNewMutex(void)
Definition: threads.c:168

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

1505{
1507
1509 if (cur == NULL) {
1511 "xsltNewExtElement : malloc failed\n");
1512 return (NULL);
1513 }
1514 memset(cur, 0, sizeof(xsltElemPreComp));
1515
1517
1518 return (cur);
1519}
static void xsltFreeElemPreComp(xsltElemPreCompPtr comp)
Definition: extensions.c:1488
void xsltInitElemPreComp(xsltElemPreCompPtr comp, xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function, xsltElemPreCompDeallocator freeFunc)
Definition: extensions.c:1535
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:248
#define memset(x, y, z)
Definition: compat.h:39
xsltElemPreComp * xsltElemPreCompPtr

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

1559{
1561 xsltElemPreCompPtr comp = NULL;
1562
1563 if ((style == NULL) || (inst == NULL) ||
1564 (inst->type != XML_ELEMENT_NODE) || (inst->ns == NULL))
1565 return (NULL);
1566
1568
1570 xmlHashLookup2(xsltElementsHash, inst->name, inst->ns->href);
1571
1573
1574 /*
1575 * EXT TODO: Now what?
1576 */
1577 if (ext == NULL)
1578 return (NULL);
1579
1580 if (ext->precomp != NULL) {
1581 /*
1582 * REVISIT TODO: Check if the text below is correct.
1583 * This will return a xsltElemPreComp structure or NULL.
1584 * 1) If the the author of the extension needs a
1585 * custom structure to hold the specific values of
1586 * this extension, he will derive a structure based on
1587 * xsltElemPreComp; thus we obviously *cannot* refactor
1588 * the xsltElemPreComp structure, since all already derived
1589 * user-defined strucures will break.
1590 * Example: For the extension xsl:document,
1591 * in xsltDocumentComp() (preproc.c), the structure
1592 * xsltStyleItemDocument is allocated, filled with
1593 * specific values and returned.
1594 * 2) If the author needs no values to be stored in
1595 * this structure, then he'll return NULL;
1596 */
1597 comp = ext->precomp(style, inst, ext->transform);
1598 }
1599 if (comp == NULL) {
1600 /*
1601 * Default creation of a xsltElemPreComp structure, if
1602 * the author of this extension did not create a custom
1603 * structure.
1604 */
1605 comp = xsltNewElemPreComp(style, inst, ext->transform);
1606 }
1607
1608 return (comp);
1609}
xsltElemPreCompPtr xsltNewElemPreComp(xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function)
Definition: extensions.c:1503
@ XML_ELEMENT_NODE
Definition: tree.h:160
const xmlChar * name
Definition: tree.h:492
xmlElementType type
Definition: tree.h:491
xmlNs * ns
Definition: tree.h:501
const xmlChar * href
Definition: tree.h:392

Referenced by xsltStylePreCompute().

◆ xsltRegisterExtElement()

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

Definition at line 621 of file extensions.c.

623{
624 if ((ctxt == NULL) || (name == NULL) ||
625 (URI == NULL) || (function == NULL))
626 return (-1);
627 if (ctxt->extElements == NULL)
628 ctxt->extElements = xmlHashCreate(10);
629 if (ctxt->extElements == NULL)
630 return (-1);
631 return (xmlHashAddEntry2
632 (ctxt->extElements, name, URI, XML_CAST_FPTR(function)));
633}
XMLPUBFUN int XMLCALL xmlHashAddEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata)
Definition: hash.c:406

Referenced by xsltRegisterAllElement().

◆ xsltRegisterExtFunction()

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

Definition at line 587 of file extensions.c.

589{
590 int ret;
591
592 if ((ctxt == NULL) || (name == NULL) ||
593 (URI == NULL) || (function == NULL))
594 return (-1);
595 if (ctxt->xpathCtxt != NULL) {
596 xmlXPathRegisterFuncNS(ctxt->xpathCtxt, name, URI, function);
597 }
598 if (ctxt->extFunctions == NULL)
599 ctxt->extFunctions = xmlHashCreate(10);
600 if (ctxt->extFunctions == NULL)
601 return (-1);
602
604 XML_CAST_FPTR(function));
605
606 return(ret);
607}
xmlXPathContextPtr xpathCtxt

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

1303{
1304 return xsltRegisterExtModuleFull(URI, initFunc, shutdownFunc,
1305 NULL, NULL);
1306}
int xsltRegisterExtModuleFull(const xmlChar *URI, xsltExtInitFunction initFunc, xsltExtShutdownFunction shutdownFunc, xsltStyleExtInitFunction styleInitFunc, xsltStyleExtShutdownFunction styleShutdownFunc)
Definition: extensions.c:1248

◆ xsltRegisterExtModuleElement()

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

Definition at line 1623 of file extensions.c.

1626{
1627 int ret = 0;
1628
1630
1631 if ((name == NULL) || (URI == NULL) || (transform == NULL))
1632 return (-1);
1633
1634 if (xsltElementsHash == NULL)
1636 if (xsltElementsHash == NULL)
1637 return (-1);
1638
1640
1641 ext = xsltNewExtElement(precomp, transform);
1642 if (ext == NULL) {
1643 ret = -1;
1644 goto done;
1645 }
1646
1649
1650done:
1652
1653 return (ret);
1654}
static xsltExtElementPtr xsltNewExtElement(xsltPreComputeFunction precomp, xsltTransformFunction transform)
Definition: extensions.c:252
static void xsltFreeExtElementEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: extensions.c:286
GLuint GLenum GLenum transform
Definition: glext.h:9407
XMLPUBFUN int XMLCALL xmlHashUpdateEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, void *userdata, xmlHashDeallocator f)
Definition: hash.c:445

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

1253{
1254 int ret;
1256
1257 if ((URI == NULL) || (initFunc == NULL))
1258 return (-1);
1259 if (xsltExtensionsHash == NULL)
1261
1262 if (xsltExtensionsHash == NULL)
1263 return (-1);
1264
1266
1268 if (module != NULL) {
1269 if ((module->initFunc == initFunc) &&
1270 (module->shutdownFunc == shutdownFunc))
1271 ret = 0;
1272 else
1273 ret = -1;
1274 goto done;
1275 }
1276 module = xsltNewExtModule(initFunc, shutdownFunc,
1277 styleInitFunc, styleShutdownFunc);
1278 if (module == NULL) {
1279 ret = -1;
1280 goto done;
1281 }
1282 ret = xmlHashAddEntry(xsltExtensionsHash, URI, (void *) module);
1283
1284done:
1286 return (ret);
1287}
static xsltExtModulePtr xsltNewExtModule(xsltExtInitFunction initFunc, xsltExtShutdownFunction shutdownFunc, xsltStyleExtInitFunction styleInitFunc, xsltStyleExtShutdownFunction styleShutdownFunc)
Definition: extensions.c:156

Referenced by xsltRegisterExtModule(), and xsltRegisterTestModule().

◆ xsltRegisterExtModuleFunction()

XSLTPUBFUN int XSLTCALL xsltRegisterExtModuleFunction ( const xmlChar name,
const xmlChar URI,
xmlXPathFunction  function 
)

Definition at line 1385 of file extensions.c.

1387{
1388 if ((name == NULL) || (URI == NULL) || (function == NULL))
1389 return (-1);
1390
1391 if (xsltFunctionsHash == NULL)
1393 if (xsltFunctionsHash == NULL)
1394 return (-1);
1395
1397
1399 XML_CAST_FPTR(function), NULL);
1400
1402
1403 return (0);
1404}

Referenced by xsltRegisterAllExtras(), and xsltRegisterTestModule().

◆ xsltRegisterExtModuleTopLevel()

XSLTPUBFUN int XSLTCALL xsltRegisterExtModuleTopLevel ( const xmlChar name,
const xmlChar URI,
xsltTopLevelFunction  function 
)

Definition at line 1825 of file extensions.c.

1827{
1828 if ((name == NULL) || (URI == NULL) || (function == NULL))
1829 return (-1);
1830
1831 if (xsltTopLevelsHash == NULL)
1833 if (xsltTopLevelsHash == NULL)
1834 return (-1);
1835
1837
1839 XML_CAST_FPTR(function), NULL);
1840
1842
1843 return (0);
1844}

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

505{
506 xsltExtDefPtr def, ret;
507
508 if ((style == NULL) || (URI == NULL))
509 return (-1);
510
511#ifdef WITH_XSLT_DEBUG_EXTENSIONS
513 "Registering extension namespace '%s'.\n", URI);
514#endif
515 def = (xsltExtDefPtr) style->nsDefs;
516#ifdef XSLT_REFACTORED
517 /*
518 * The extension is associated with a namespace name.
519 */
520 while (def != NULL) {
521 if (xmlStrEqual(URI, def->URI))
522 return (1);
523 def = def->next;
524 }
525#else
526 while (def != NULL) {
527 if (xmlStrEqual(prefix, def->prefix))
528 return (-1);
529 def = def->next;
530 }
531#endif
532 ret = xsltNewExtDef(prefix, URI);
533 if (ret == NULL)
534 return (-1);
535 ret->next = (xsltExtDefPtr) style->nsDefs;
536 style->nsDefs = ret;
537
538 /*
539 * check whether there is an extension module with a stylesheet
540 * initialization function.
541 */
542#ifdef XSLT_REFACTORED
543 /*
544 * Don't initialize modules based on specified namespaces via
545 * the attribute "[xsl:]extension-element-prefixes".
546 */
547#else
550
554 if (NULL == module) {
559 }
560 }
561 if (module != NULL) {
563 }
564 }
565#endif
566 return (0);
567}
static xsltExtDefPtr xsltNewExtDef(const xmlChar *prefix, const xmlChar *URI)
Definition: extensions.c:90
void * xsltStyleGetExtData(xsltStylesheetPtr style, const xmlChar *URI)
Definition: extensions.c:756
if(dx< 0)
Definition: linetemp.h:194
xmlChar * URI
Definition: extensions.c:40
struct _xsltExtDef * next
Definition: extensions.c:38
xmlChar * prefix
Definition: extensions.c:39

Referenced by xsltParseStylesheetExtPrefix().

◆ xsltRegisterTestModule()

XSLTPUBFUN void XSLTCALL xsltRegisterTestModule ( void  )

Test of the extension module API

xsltRegisterTestModule:

Registers the test module

Definition at line 2225 of file extensions.c.

2226{
2232 xsltRegisterExtModuleFunction((const xmlChar *) "test",
2233 (const xmlChar *) XSLT_DEFAULT_URL,
2235 xsltRegisterExtModuleElement((const xmlChar *) "test",
2236 (const xmlChar *) XSLT_DEFAULT_URL,
2239}
static void xsltExtStyleShutdownTest(xsltStylesheetPtr style ATTRIBUTE_UNUSED, const xmlChar *URI, void *data)
Definition: extensions.c:2202
static void xsltExtFunctionTest(xmlXPathParserContextPtr ctxt, int nargs ATTRIBUTE_UNUSED)
Definition: extensions.c:1971
static void * xsltExtInitTest(xsltTransformContextPtr ctxt, const xmlChar *URI)
Definition: extensions.c:2117
static void * xsltExtStyleInitTest(xsltStylesheetPtr style ATTRIBUTE_UNUSED, const xmlChar *URI)
Definition: extensions.c:2178
int xsltRegisterExtModuleElement(const xmlChar *name, const xmlChar *URI, xsltPreComputeFunction precomp, xsltTransformFunction transform)
Definition: extensions.c:1623
static xsltElemPreCompPtr xsltExtElementPreCompTest(xsltStylesheetPtr style, xmlNodePtr inst, xsltTransformFunction function)
Definition: extensions.c:2021
static void xsltExtElementTest(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, xsltElemPreCompPtr comp ATTRIBUTE_UNUSED)
Definition: extensions.c:2065
static void xsltExtShutdownTest(xsltTransformContextPtr ctxt, const xmlChar *URI, void *data)
Definition: extensions.c:2151
void xsltInitGlobals(void)
Definition: extensions.c:2257
int xsltRegisterExtModuleFunction(const xmlChar *name, const xmlChar *URI, xmlXPathFunction function)
Definition: extensions.c:1385
#define XSLT_DEFAULT_URL
Definition: xslt.h:39

◆ xsltShutdownCtxtExts()

XSLTPUBFUN void XSLTCALL xsltShutdownCtxtExts ( xsltTransformContextPtr  ctxt)

xsltShutdownCtxtExts: @ctxt: an XSLT transformation context

Shutdown the set of modules loaded

Definition at line 1081 of file extensions.c.

1082{
1083 if (ctxt == NULL)
1084 return;
1085 if (ctxt->extInfos == NULL)
1086 return;
1089 ctxt->extInfos = NULL;
1090}
static void xsltShutdownCtxtExt(void *payload, void *vctxt, const xmlChar *URI)
Definition: extensions.c:1055
static void xsltFreeExtDataEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: extensions.c:237

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

1134{
1135 if (style == NULL)
1136 return;
1137 if (style->extInfos == NULL)
1138 return;
1141 style->extInfos = NULL;
1142}
static void xsltShutdownExt(void *payload, void *vctxt, const xmlChar *URI)
Definition: extensions.c:1101

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

757{
758 xsltExtDataPtr dataContainer = NULL;
759 xsltStylesheetPtr tmpStyle;
760
761 if ((style == NULL) || (URI == NULL) ||
763 return (NULL);
764
765
766#ifdef XSLT_REFACTORED
767 /*
768 * This is intended for global storage, so only the main
769 * stylesheet will hold the data.
770 */
771 tmpStyle = style;
772 while (tmpStyle->parent != NULL)
773 tmpStyle = tmpStyle->parent;
774 if (tmpStyle->extInfos != NULL) {
775 dataContainer =
776 (xsltExtDataPtr) xmlHashLookup(tmpStyle->extInfos, URI);
777 if (dataContainer != NULL) {
778 /*
779 * The module was already initialized in the context
780 * of this stylesheet; just return the user-data that
781 * comes with it.
782 */
783 return(dataContainer->extData);
784 }
785 }
786#else
787 /*
788 * Old behaviour.
789 */
790 tmpStyle = style;
791 while (tmpStyle != NULL) {
792 if (tmpStyle->extInfos != NULL) {
793 dataContainer =
794 (xsltExtDataPtr) xmlHashLookup(tmpStyle->extInfos, URI);
795 if (dataContainer != NULL) {
796 return(dataContainer->extData);
797 }
798 }
799 tmpStyle = xsltNextImport(tmpStyle);
800 }
801 tmpStyle = style;
802#endif
803
804 dataContainer =
806 if (dataContainer != NULL)
807 return (dataContainer->extData);
808 return(NULL);
809}
static xsltExtDataPtr xsltStyleInitializeStylesheetModule(xsltStylesheetPtr style, const xmlChar *URI)
Definition: extensions.c:663
void * extData
Definition: extensions.c:57
struct _xsltStylesheet * parent
xmlHashTablePtr extInfos

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

1318{
1319 int ret;
1320
1321 if (URI == NULL)
1322 return (-1);
1323 if (xsltExtensionsHash == NULL)
1324 return (-1);
1325
1327
1329
1331
1332 return (ret);
1333}
static void xsltFreeExtModuleEntry(void *payload, const xmlChar *name ATTRIBUTE_UNUSED)
Definition: extensions.c:191
XMLPUBFUN int XMLCALL xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name, xmlHashDeallocator f)
Definition: hash.c:1052

◆ xsltUnregisterExtModuleElement()

XSLTPUBFUN int XSLTCALL xsltUnregisterExtModuleElement ( const xmlChar name,
const xmlChar URI 
)

Definition at line 1781 of file extensions.c.

1782{
1783 int ret;
1784
1785 if ((xsltElementsHash == NULL) || (name == NULL) || (URI == NULL))
1786 return (-1);
1787
1789
1792
1794
1795 return(ret);
1796}
XMLPUBFUN int XMLCALL xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name, const xmlChar *name2, xmlHashDeallocator f)
Definition: hash.c:1071

◆ xsltUnregisterExtModuleFunction()

XSLTPUBFUN int XSLTCALL xsltUnregisterExtModuleFunction ( const xmlChar name,
const xmlChar URI 
)

Definition at line 1454 of file extensions.c.

1455{
1456 int ret;
1457
1458 if ((xsltFunctionsHash == NULL) || (name == NULL) || (URI == NULL))
1459 return (-1);
1460
1462
1464
1466
1467 return(ret);
1468}

◆ xsltUnregisterExtModuleTopLevel()

XSLTPUBFUN int XSLTCALL xsltUnregisterExtModuleTopLevel ( const xmlChar name,
const xmlChar URI 
)

Definition at line 1893 of file extensions.c.

1894{
1895 int ret;
1896
1897 if ((xsltTopLevelsHash == NULL) || (name == NULL) || (URI == NULL))
1898 return (-1);
1899
1901
1903
1905
1906 return(ret);
1907}

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

1368{
1369 if ((ctxt == NULL) || (ctxt->context == NULL))
1370 return (NULL);
1371 return (ctxt->context->extra);
1372}

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