summaryrefslogtreecommitdiff
path: root/lib/python2.7/site-packages/libxslt.py
diff options
context:
space:
mode:
Diffstat (limited to 'lib/python2.7/site-packages/libxslt.py')
-rw-r--r--lib/python2.7/site-packages/libxslt.py1369
1 files changed, 1369 insertions, 0 deletions
diff --git a/lib/python2.7/site-packages/libxslt.py b/lib/python2.7/site-packages/libxslt.py
new file mode 100644
index 0000000..a5a0188
--- /dev/null
+++ b/lib/python2.7/site-packages/libxslt.py
@@ -0,0 +1,1369 @@
+#
+# Both libxml2mod and libxsltmod have a dependancy on libxml2.so
+# and they should share the same module, try to convince the python
+# loader to work in that mode if feasible
+#
+import sys
+if not hasattr(sys,'getdlopenflags'):
+ import libxml2mod
+ import libxsltmod
+ import libxml2
+else:
+ try:
+ from dl import RTLD_GLOBAL, RTLD_NOW
+ except ImportError:
+ RTLD_GLOBAL = -1
+ RTLD_NOW = -1
+ try:
+ import os
+ osname = os.uname()[0]
+ if osname == 'Linux' or osname == 'SunOS':
+ RTLD_GLOBAL = 0x00100
+ RTLD_NOW = 0x00002
+ elif osname == 'Darwin':
+ RTLD_GLOBAL = 0x8
+ RTLD_NOW = 0x2
+ #
+ # is there a better method ?
+ #
+# else:
+# print "libxslt could not guess RTLD_GLOBAL and RTLD_NOW " + \
+# "on this platform: %s" % (osname)
+ except:
+ pass
+# print "libxslt could not guess RTLD_GLOBAL and RTLD_NOW " + \
+# "on this platform: %s" % (osname)
+ except:
+ RTLD_GLOBAL = -1
+ RTLD_NOW = -1
+
+ if RTLD_GLOBAL != -1 and RTLD_NOW != -1:
+ try:
+ flags = sys.getdlopenflags()
+ sys.setdlopenflags(RTLD_GLOBAL | RTLD_NOW)
+ try:
+ import libxml2mod
+ import libxsltmod
+ import libxml2
+ finally:
+ sys.setdlopenflags(flags)
+ except:
+ import libxml2mod
+ import libxsltmod
+ import libxml2
+ else:
+ import libxml2mod
+ import libxsltmod
+ import libxml2
+
+
+class transformCtxtBase:
+ def __init__(self, _obj=None):
+ if _obj != None:
+ self._o = _obj;
+ return
+ self._o = None
+ def __hash__(self):
+ v = libxsltmod.xsltGetTransformContextHashCode(self._o)
+ return v
+ def __eq__(self, other):
+ if other == None:
+ return 0
+ v = libxsltmod.xsltCompareTransformContextsEqual(self._o, other._o)
+ return v
+
+class stylesheetBase:
+ def __init__(self, _obj=None):
+ if _obj != None:
+ self._o = _obj;
+ return
+ self._o = None
+ def __hash__(self):
+ v = libxsltmod.xsltGetStylesheetHashCode(self._o)
+ return v
+ def __eq__(self, other):
+ if other == None:
+ return 0
+ v = libxsltmod.xsltCompareStylesheetsEqual(self._o, other._o)
+ return v
+
+class extensionModule:
+ def _styleInit(self, style, URI):
+ return self.styleInit(stylesheet(_obj=style), URI)
+
+ def _styleShutdown(self, style, URI, data):
+ return self.styleShutdown(stylesheet(_obj=style), URI, data)
+
+ def _ctxtInit(self, ctxt, URI):
+ return self.ctxtInit(transformCtxt(_obj=ctxt), URI)
+
+ def _ctxtShutdown(self, ctxt, URI, data):
+ return self.ctxtShutdown(transformCtxt(_obj=ctxt), URI, data)
+
+ def styleInit(self, style, URI):
+ """Callback function when used in a newly compiled stylesheet,
+ the return value is passed in subsequent calls"""
+ pass
+
+ def styleShutdown(self, style, URI, data):
+ """Callback function when a stylesheet using it is destroyed"""
+ pass
+
+ def ctxtInit(self, ctxt, URI):
+ """Callback function when used in a new transformation process,
+ the return value is passed in subsequent calls"""
+ pass
+
+ def ctxtShutdown(self, ctxt, URI, data):
+ """Callback function when a transformation using it finishes"""
+ pass
+
+def cleanup():
+ """Cleanup all libxslt and libxml2 memory allocated"""
+ libxsltmod.xsltPythonCleanup()
+ libxml2.cleanupParser()
+
+#
+# Everything below this point is automatically generated
+#
+
+#
+# Functions from module extensions
+#
+
+def debugDumpExtensions(output):
+ """Dumps a list of the registered XSLT extension functions and
+ elements"""
+ libxsltmod.xsltDebugDumpExtensions(output)
+
+def initGlobals():
+ """Initialize the global variables for extensions"""
+ libxsltmod.xsltInitGlobals()
+
+def registerTestModule():
+ """Registers the test module"""
+ libxsltmod.xsltRegisterTestModule()
+
+def unregisterExtModule(URI):
+ """Unregister an XSLT extension module from the library."""
+ ret = libxsltmod.xsltUnregisterExtModule(URI)
+ return ret
+
+def unregisterExtModuleElement(name, URI):
+ """Unregisters an extension module element"""
+ ret = libxsltmod.xsltUnregisterExtModuleElement(name, URI)
+ return ret
+
+def unregisterExtModuleFunction(name, URI):
+ """Unregisters an extension module function"""
+ ret = libxsltmod.xsltUnregisterExtModuleFunction(name, URI)
+ return ret
+
+def unregisterExtModuleTopLevel(name, URI):
+ """Unregisters an extension module top-level element"""
+ ret = libxsltmod.xsltUnregisterExtModuleTopLevel(name, URI)
+ return ret
+
+#
+# Functions from module extra
+#
+
+def registerAllExtras():
+ """Registers the built-in extensions"""
+ libxsltmod.xsltRegisterAllExtras()
+
+#
+# Functions from module python
+#
+
+def pythonCleanup():
+ """Cleanup just libxslt (not libxml2) memory allocated"""
+ libxsltmod.xsltPythonCleanup()
+
+def registerErrorHandler(f, ctx):
+ """Register a Python written function to for error reporting.
+ The function is called back as f(ctx, error)."""
+ ret = libxsltmod.xsltRegisterErrorHandler(f, ctx)
+ return ret
+
+def registerExtModuleElement(name, URI, precompile, transform):
+ """Register a Python written element to the XSLT engine"""
+ ret = libxsltmod.xsltRegisterExtModuleElement(name, URI, precompile, transform)
+ return ret
+
+def registerExtModuleFunction(name, URI, f):
+ """Register a Python written function to the XSLT engine"""
+ ret = libxsltmod.xsltRegisterExtModuleFunction(name, URI, f)
+ return ret
+
+def registerExtensionClass(URI, c):
+ """Register a Python written extension class to the XSLT engine"""
+ ret = libxsltmod.xsltRegisterExtensionClass(URI, c)
+ return ret
+
+def setLoaderFunc(loader):
+ """Set the function for controlling document loading"""
+ ret = libxsltmod.xsltSetLoaderFunc(loader)
+ return ret
+
+#
+# Functions from module xslt
+#
+
+def cleanupGlobals():
+ """Unregister all global variables set up by the XSLT library"""
+ libxsltmod.xsltCleanupGlobals()
+
+def init():
+ """Initializes the processor (e.g. registers built-in
+ extensions, etc.)"""
+ libxsltmod.xsltInit()
+
+#
+# Functions from module xsltInternals
+#
+
+def isBlank(str):
+ """Check if a string is ignorable"""
+ ret = libxsltmod.xsltIsBlank(str)
+ return ret
+
+def loadStylesheetPI(doc):
+ """This function tries to locate the stylesheet PI in the
+ given document If found, and if contained within the
+ document, it will extract that subtree to build the
+ stylesheet to process @doc (doc itself will be modified).
+ If found but referencing an external document it will
+ attempt to load it and generate a stylesheet from it. In
+ both cases, the resulting stylesheet and the document need
+ to be freed once the transformation is done."""
+ if doc == None: doc__o = None
+ else: doc__o = doc._o
+ ret = libxsltmod.xsltLoadStylesheetPI(doc__o)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+def newStylesheet():
+ """Create a new XSLT Stylesheet"""
+ ret = libxsltmod.xsltNewStylesheet()
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+def parseStylesheetDoc(doc):
+ """parse an XSLT stylesheet, building the associated
+ structures. doc is kept as a reference within the returned
+ stylesheet, so changes to doc after the parsing will be
+ reflected when the stylesheet is applied, and the doc is
+ automatically freed when the stylesheet is closed."""
+ if doc == None: doc__o = None
+ else: doc__o = doc._o
+ ret = libxsltmod.xsltParseStylesheetDoc(doc__o)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+def parseStylesheetFile(filename):
+ """Load and parse an XSLT stylesheet"""
+ ret = libxsltmod.xsltParseStylesheetFile(filename)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+def uninit():
+ """Uninitializes the processor."""
+ libxsltmod.xsltUninit()
+
+#
+# Functions from module xsltlocale
+#
+
+def freeLocales():
+ """Cleanup function for the locale support on shutdown"""
+ libxsltmod.xsltFreeLocales()
+
+#
+# Functions from module xsltutils
+#
+
+def calibrateAdjust(delta):
+ """Used for to correct the calibration for xsltTimestamp()"""
+ libxsltmod.xsltCalibrateAdjust(delta)
+
+def debuggerStatus():
+ """Get xslDebugStatus."""
+ ret = libxsltmod.xsltGetDebuggerStatus()
+ return ret
+
+def nsProp(node, name, nameSpace):
+ """Similar to xmlGetNsProp() but with a slightly different
+ semantic Search and get the value of an attribute
+ associated to a node This attribute has to be anchored in
+ the namespace specified, or has no namespace and the
+ element is in that namespace. This does the entity
+ substitution. This function looks in DTD attribute
+ declaration for #FIXED or default declaration values unless
+ DTD use has been turned off."""
+ if node == None: node__o = None
+ else: node__o = node._o
+ ret = libxsltmod.xsltGetNsProp(node__o, name, nameSpace)
+ return ret
+
+def setDebuggerStatus(value):
+ """This function sets the value of xslDebugStatus."""
+ libxsltmod.xsltSetDebuggerStatus(value)
+
+def timestamp():
+ """Used for gathering profiling data"""
+ ret = libxsltmod.xsltTimestamp()
+ return ret
+
+def xslDropCall():
+ """Drop the topmost item off the call stack"""
+ libxsltmod.xslDropCall()
+
+class xpathParserContext(libxml2.xpathParserContext):
+ def __init__(self, _obj=None):
+ self._o = None
+ libxml2.xpathParserContext.__init__(self, _obj=_obj)
+
+ # accessors for xpathParserContext
+ def context(self):
+ """Get the xpathContext from an xpathParserContext"""
+ ret = libxsltmod.xsltXPathParserGetContext(self._o)
+ if ret == None: return None
+ return xpathContext(_obj=ret)
+
+ #
+ # xpathParserContext functions from module extra
+ #
+
+ def functionNodeSet(self, nargs):
+ """Implement the node-set() XSLT function node-set
+ node-set(result-tree) This function is available in
+ libxslt, saxon or xt namespace."""
+ libxsltmod.xsltFunctionNodeSet(self._o, nargs)
+
+ #
+ # xpathParserContext functions from module functions
+ #
+
+ def documentFunction(self, nargs):
+ """Implement the document() XSLT function node-set
+ document(object, node-set?)"""
+ libxsltmod.xsltDocumentFunction(self._o, nargs)
+
+ def elementAvailableFunction(self, nargs):
+ """Implement the element-available() XSLT function boolean
+ element-available(string)"""
+ libxsltmod.xsltElementAvailableFunction(self._o, nargs)
+
+ def formatNumberFunction(self, nargs):
+ """Implement the format-number() XSLT function string
+ format-number(number, string, string?)"""
+ libxsltmod.xsltFormatNumberFunction(self._o, nargs)
+
+ def functionAvailableFunction(self, nargs):
+ """Implement the function-available() XSLT function boolean
+ function-available(string)"""
+ libxsltmod.xsltFunctionAvailableFunction(self._o, nargs)
+
+ def generateIdFunction(self, nargs):
+ """Implement the generate-id() XSLT function string
+ generate-id(node-set?)"""
+ libxsltmod.xsltGenerateIdFunction(self._o, nargs)
+
+ def keyFunction(self, nargs):
+ """Implement the key() XSLT function node-set key(string,
+ object)"""
+ libxsltmod.xsltKeyFunction(self._o, nargs)
+
+ def systemPropertyFunction(self, nargs):
+ """Implement the system-property() XSLT function object
+ system-property(string)"""
+ libxsltmod.xsltSystemPropertyFunction(self._o, nargs)
+
+ def unparsedEntityURIFunction(self, nargs):
+ """Implement the unparsed-entity-uri() XSLT function string
+ unparsed-entity-uri(string)"""
+ libxsltmod.xsltUnparsedEntityURIFunction(self._o, nargs)
+
+class xpathContext(libxml2.xpathContext):
+ def __init__(self, _obj=None):
+ self._o = None
+ libxml2.xpathContext.__init__(self, _obj=_obj)
+
+ def __del__(self):
+ pass
+ # accessors for xpathContext
+ def transformContext(self):
+ """Get the transformation context from an xpathContext"""
+ ret = libxsltmod.xsltXPathGetTransformContext(self._o)
+ if ret == None: return None
+ return transformCtxt(_obj=ret)
+
+ #
+ # xpathContext functions from module functions
+ #
+
+ def registerAllFunctions(self):
+ """Registers all default XSLT functions in this context"""
+ libxsltmod.xsltRegisterAllFunctions(self._o)
+
+class transformCtxt(transformCtxtBase):
+ def __init__(self, _obj=None):
+ self._o = None
+ transformCtxtBase.__init__(self, _obj=_obj)
+
+ # accessors for transformCtxt
+ def context(self):
+ """Get the XPath context of a transformation"""
+ ret = libxsltmod.xsltTransformGetContext(self._o)
+ if ret == None: return None
+ return xpathContext(_obj=ret)
+
+ def current(self):
+ """Get the current() node of a transformation"""
+ ret = libxsltmod.xsltTransformGetCurrent(self._o)
+ if ret == None: return None
+ return libxml2.xmlNode(_obj=ret)
+
+ def insertNode(self):
+ """Get the insertion node in the output document"""
+ ret = libxsltmod.xsltTransformGetInsertNode(self._o)
+ if ret == None: return None
+ return libxml2.xmlNode(_obj=ret)
+
+ def instruction(self):
+ """Get the instruction node in the stylesheet"""
+ ret = libxsltmod.xsltTransformGetInstruction(self._o)
+ if ret == None: return None
+ return libxml2.xmlNode(_obj=ret)
+
+ def mode(self):
+ """Get the mode of a transformation"""
+ ret = libxsltmod.xsltTransformGetMode(self._o)
+ return ret
+
+ def modeURI(self):
+ """Get the mode URI of a transformation"""
+ ret = libxsltmod.xsltTransformGetModeURI(self._o)
+ return ret
+
+ def outputDoc(self):
+ """Get the output document of a transformation"""
+ ret = libxsltmod.xsltTransformGetOutputDoc(self._o)
+ if ret == None: return None
+ return libxml2.xmlDoc(_obj=ret)
+
+ def outputURI(self):
+ """Get the output URI of a transformation if known"""
+ ret = libxsltmod.xsltTransformGetOutputURI(self._o)
+ return ret
+
+ def style(self):
+ """Get the stylesheet from a transformation"""
+ ret = libxsltmod.xsltTransformGetStyle(self._o)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+ #
+ # transformCtxt functions from module attributes
+ #
+
+ def applyAttributeSet(self, node, inst, attrSets):
+ """Apply the xsl:use-attribute-sets. If @attrSets is None,
+ then @inst will be used to exctract this value. If both,
+ @attrSets and @inst, are None, then this will do nothing."""
+ if node == None: node__o = None
+ else: node__o = node._o
+ if inst == None: inst__o = None
+ else: inst__o = inst._o
+ libxsltmod.xsltApplyAttributeSet(self._o, node__o, inst__o, attrSets)
+
+ #
+ # transformCtxt functions from module documents
+ #
+
+ def freeDocuments(self):
+ """Free up all the space used by the loaded documents"""
+ libxsltmod.xsltFreeDocuments(self._o)
+
+ #
+ # transformCtxt functions from module extensions
+ #
+
+ def freeCtxtExts(self):
+ """Free the XSLT extension data"""
+ libxsltmod.xsltFreeCtxtExts(self._o)
+
+ def initCtxtExts(self):
+ """Initialize the set of modules with registered stylesheet
+ data"""
+ ret = libxsltmod.xsltInitCtxtExts(self._o)
+ return ret
+
+ def shutdownCtxtExts(self):
+ """Shutdown the set of modules loaded"""
+ libxsltmod.xsltShutdownCtxtExts(self._o)
+
+ #
+ # transformCtxt functions from module extra
+ #
+
+ def debug(self, node, inst, comp):
+ """Process an debug node"""
+ if node == None: node__o = None
+ else: node__o = node._o
+ if inst == None: inst__o = None
+ else: inst__o = inst._o
+ libxsltmod.xsltDebug(self._o, node__o, inst__o, comp)
+
+ def registerExtras(self):
+ """Registers the built-in extensions. This function is
+ deprecated, use xsltRegisterAllExtras instead."""
+ libxsltmod.xsltRegisterExtras(self._o)
+
+ #
+ # transformCtxt functions from module imports
+ #
+
+ def findElemSpaceHandling(self, node):
+ """Find strip-space or preserve-space informations for an
+ element respect the import precedence or the wildcards"""
+ if node == None: node__o = None
+ else: node__o = node._o
+ ret = libxsltmod.xsltFindElemSpaceHandling(self._o, node__o)
+ return ret
+
+ def needElemSpaceHandling(self):
+ """Checks whether that stylesheet requires white-space
+ stripping"""
+ ret = libxsltmod.xsltNeedElemSpaceHandling(self._o)
+ return ret
+
+ #
+ # transformCtxt functions from module namespaces
+ #
+
+ def copyNamespace(self, elem, ns):
+ """Copies a namespace node (declaration). If @elem is not
+ None, then the new namespace will be declared on @elem."""
+ if elem == None: elem__o = None
+ else: elem__o = elem._o
+ if ns == None: ns__o = None
+ else: ns__o = ns._o
+ ret = libxsltmod.xsltCopyNamespace(self._o, elem__o, ns__o)
+ if ret == None: return None
+ return libxml2.xmlNs(_obj=ret)
+
+ def copyNamespaceList(self, node, cur):
+ """Do a copy of an namespace list. If @node is non-None the
+ new namespaces are added automatically. This handles
+ namespaces aliases. This function is intended only for
+ *internal* use at transformation-time for copying
+ ns-declarations of Literal Result Elements. Called by:
+ xsltCopyTreeInternal() (transform.c) xsltShallowCopyElem()
+ (transform.c) REVISIT: This function won't be used in the
+ refactored code."""
+ if node == None: node__o = None
+ else: node__o = node._o
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ ret = libxsltmod.xsltCopyNamespaceList(self._o, node__o, cur__o)
+ if ret == None: return None
+ return libxml2.xmlNs(_obj=ret)
+
+ def namespace(self, cur, ns, out):
+ """Find a matching (prefix and ns-name) ns-declaration for the
+ requested @ns->prefix and @ns->href in the result tree. If
+ none is found then a new ns-declaration will be added to
+ @resultElem. If, in this case, the given prefix is already
+ in use, then a ns-declaration with a modified ns-prefix be
+ we created. Called by: - xsltCopyPropList() (*not*
+ anymore) - xsltShallowCopyElement() -
+ xsltCopyTreeInternal() (*not* anymore) -
+ xsltApplySequenceConstructor() (*not* in the refactored
+ code), - xsltElement() (*not* anymore)"""
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ if ns == None: ns__o = None
+ else: ns__o = ns._o
+ if out == None: out__o = None
+ else: out__o = out._o
+ ret = libxsltmod.xsltGetNamespace(self._o, cur__o, ns__o, out__o)
+ if ret == None: return None
+ return libxml2.xmlNs(_obj=ret)
+
+ def plainNamespace(self, cur, ns, out):
+ """Obsolete. *Not* called by any Libxslt/Libexslt function.
+ Exaclty the same as xsltGetNamespace()."""
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ if ns == None: ns__o = None
+ else: ns__o = ns._o
+ if out == None: out__o = None
+ else: out__o = out._o
+ ret = libxsltmod.xsltGetPlainNamespace(self._o, cur__o, ns__o, out__o)
+ if ret == None: return None
+ return libxml2.xmlNs(_obj=ret)
+
+ def specialNamespace(self, invocNode, nsName, nsPrefix, target):
+ """Find a matching (prefix and ns-name) ns-declaration for the
+ requested @nsName and @nsPrefix in the result tree. If none
+ is found then a new ns-declaration will be added to
+ @resultElem. If, in this case, the given prefix is already
+ in use, then a ns-declaration with a modified ns-prefix be
+ we created. Note that this function's priority is to
+ preserve ns-prefixes; it will only change a prefix if
+ there's a namespace clash. If both @nsName and @nsPrefix
+ are None, then this will try to "undeclare" a default
+ namespace by declaring an xmlns=""."""
+ if invocNode == None: invocNode__o = None
+ else: invocNode__o = invocNode._o
+ if target == None: target__o = None
+ else: target__o = target._o
+ ret = libxsltmod.xsltGetSpecialNamespace(self._o, invocNode__o, nsName, nsPrefix, target__o)
+ if ret == None: return None
+ return libxml2.xmlNs(_obj=ret)
+
+ #
+ # transformCtxt functions from module python
+ #
+
+ def compareTransformContextsEqual(self, other):
+ """Compare one transformCtxt with another"""
+ if other == None: other__o = None
+ else: other__o = other._o
+ ret = libxsltmod.xsltCompareTransformContextsEqual(self._o, other__o)
+ return ret
+
+ def freeTransformContext(self):
+ """Free up an existing XSLT TransformContext"""
+ libxsltmod.xsltFreeTransformContext(self._o)
+
+ def transformContextHashCode(self):
+ """Get the hash code of the transformContext"""
+ ret = libxsltmod.xsltGetTransformContextHashCode(self._o)
+ return ret
+
+ #
+ # transformCtxt functions from module templates
+ #
+
+ def attrListTemplateProcess(self, target, attrs):
+ """Processes all attributes of a Literal Result Element.
+ Attribute references are applied via xsl:use-attribute-set
+ attributes. Copies all non XSLT-attributes over to the
+ @target element and evaluates Attribute Value Templates.
+ Called by xsltApplySequenceConstructor() (transform.c)."""
+ if target == None: target__o = None
+ else: target__o = target._o
+ if attrs == None: attrs__o = None
+ else: attrs__o = attrs._o
+ ret = libxsltmod.xsltAttrListTemplateProcess(self._o, target__o, attrs__o)
+ if ret == None: return None
+ return libxml2.xmlAttr(_obj=ret)
+
+ def attrTemplateProcess(self, target, attr):
+ """Process one attribute of a Literal Result Element (in the
+ stylesheet). Evaluates Attribute Value Templates and copies
+ the attribute over to the result element. This does *not*
+ process attribute sets (xsl:use-attribute-set)."""
+ if target == None: target__o = None
+ else: target__o = target._o
+ if attr == None: attr__o = None
+ else: attr__o = attr._o
+ ret = libxsltmod.xsltAttrTemplateProcess(self._o, target__o, attr__o)
+ if ret == None: return None
+ return libxml2.xmlAttr(_obj=ret)
+
+ def attrTemplateValueProcess(self, str):
+ """Process the given node and return the new string value."""
+ ret = libxsltmod.xsltAttrTemplateValueProcess(self._o, str)
+ return ret
+
+ def attrTemplateValueProcessNode(self, str, inst):
+ """Process the given string, allowing to pass a namespace
+ mapping context and return the new string value. Called
+ by: - xsltAttrTemplateValueProcess() (templates.c) -
+ xsltEvalAttrValueTemplate() (templates.c) QUESTION: Why is
+ this function public? It is not used outside of templates.c."""
+ if inst == None: inst__o = None
+ else: inst__o = inst._o
+ ret = libxsltmod.xsltAttrTemplateValueProcessNode(self._o, str, inst__o)
+ return ret
+
+ def evalAttrValueTemplate(self, inst, name, ns):
+ """Evaluate a attribute value template, i.e. the attribute
+ value can contain expressions contained in curly braces
+ ({}) and those are substituted by they computed value."""
+ if inst == None: inst__o = None
+ else: inst__o = inst._o
+ ret = libxsltmod.xsltEvalAttrValueTemplate(self._o, inst__o, name, ns)
+ return ret
+
+ def evalTemplateString(self, contextNode, inst):
+ """Processes the sequence constructor of the given instruction
+ on @contextNode and converts the resulting tree to a
+ string. This is needed by e.g. xsl:comment and
+ xsl:processing-instruction."""
+ if contextNode == None: contextNode__o = None
+ else: contextNode__o = contextNode._o
+ if inst == None: inst__o = None
+ else: inst__o = inst._o
+ ret = libxsltmod.xsltEvalTemplateString(self._o, contextNode__o, inst__o)
+ return ret
+
+ #
+ # transformCtxt functions from module variables
+ #
+
+ def evalGlobalVariables(self):
+ """Evaluates all global variables and parameters of a
+ stylesheet. For internal use only. This is called at start
+ of a transformation."""
+ ret = libxsltmod.xsltEvalGlobalVariables(self._o)
+ return ret
+
+ def evalOneUserParam(self, name, value):
+ """This is normally called from xsltEvalUserParams to process
+ a single parameter from a list of parameters. The @value
+ is evaluated as an XPath expression and the result is
+ stored in the context's global variable/parameter hash
+ table. To have a parameter treated literally (not as an
+ XPath expression) use xsltQuoteUserParams (or
+ xsltQuoteOneUserParam). For more details see description
+ of xsltProcessOneUserParamInternal."""
+ ret = libxsltmod.xsltEvalOneUserParam(self._o, name, value)
+ return ret
+
+ def freeGlobalVariables(self):
+ """Free up the data associated to the global variables its
+ value."""
+ libxsltmod.xsltFreeGlobalVariables(self._o)
+
+ def parseStylesheetParam(self, cur):
+ """Registers a local XSLT 'param' declaration at
+ transformation time and evaluates its value."""
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ libxsltmod.xsltParseStylesheetParam(self._o, cur__o)
+
+ def parseStylesheetVariable(self, inst):
+ """Registers a local XSLT 'variable' instruction at
+ transformation time and evaluates its value."""
+ if inst == None: inst__o = None
+ else: inst__o = inst._o
+ libxsltmod.xsltParseStylesheetVariable(self._o, inst__o)
+
+ def quoteOneUserParam(self, name, value):
+ """This is normally called from xsltQuoteUserParams to process
+ a single parameter from a list of parameters. The @value
+ is stored in the context's global variable/parameter hash
+ table."""
+ ret = libxsltmod.xsltQuoteOneUserParam(self._o, name, value)
+ return ret
+
+ def variableLookup(self, name, ns_uri):
+ """Search in the Variable array of the context for the given
+ variable value."""
+ ret = libxsltmod.xsltVariableLookup(self._o, name, ns_uri)
+ if ret == None: return None
+ return libxml2.xpathObjectRet(ret)
+
+ #
+ # transformCtxt functions from module xsltInternals
+ #
+
+ def allocateExtraCtxt(self):
+ """Allocate an extra runtime information slot at run-time and
+ return its number This make sure there is a slot ready in
+ the transformation context"""
+ ret = libxsltmod.xsltAllocateExtraCtxt(self._o)
+ return ret
+
+ def createRVT(self):
+ """Creates a Result Value Tree (the XSLT 1.0 term for this is
+ "Result Tree Fragment")"""
+ ret = libxsltmod.xsltCreateRVT(self._o)
+ if ret == None: return None
+ return libxml2.xmlDoc(_obj=ret)
+
+ def extensionInstructionResultFinalize(self):
+ """Finalizes the data (e.g. result tree fragments) created
+ within a value-returning process (e.g. EXSLT's function).
+ Tree fragments marked as being returned by a function are
+ set to normal state, which means that the fragment garbage
+ collector will free them after the function-calling process
+ exits."""
+ ret = libxsltmod.xsltExtensionInstructionResultFinalize(self._o)
+ return ret
+
+ def freeRVTs(self):
+ """Frees all registered result value trees (Result Tree
+ Fragments) of the transformation. Internal function; should
+ not be called by user-code."""
+ libxsltmod.xsltFreeRVTs(self._o)
+
+ def initAllDocKeys(self):
+ """INTERNAL ROUTINE ONLY Check if any keys on the current
+ document need to be computed"""
+ ret = libxsltmod.xsltInitAllDocKeys(self._o)
+ return ret
+
+ def registerLocalRVT(self, RVT):
+ """Registers a result value tree (XSLT 1.0 term: Result Tree
+ Fragment) in the RVT garbage collector. The fragment will
+ be freed when the instruction which created the fragment
+ exits."""
+ if RVT == None: RVT__o = None
+ else: RVT__o = RVT._o
+ ret = libxsltmod.xsltRegisterLocalRVT(self._o, RVT__o)
+ return ret
+
+ def registerPersistRVT(self, RVT):
+ """Register the result value tree (XSLT 1.0 term: Result Tree
+ Fragment) in the fragment garbage collector. The fragment
+ will be freed when the transformation context is freed."""
+ if RVT == None: RVT__o = None
+ else: RVT__o = RVT._o
+ ret = libxsltmod.xsltRegisterPersistRVT(self._o, RVT__o)
+ return ret
+
+ def registerTmpRVT(self, RVT):
+ """Registers the result value tree (XSLT 1.0 term: Result Tree
+ Fragment) in the garbage collector. The fragment will be
+ freed at the exit of the currently instantiated
+ xsl:template. Obsolete; this function might produce massive
+ memory overhead, since the fragment is only freed when the
+ current xsl:template exits. Use xsltRegisterLocalRVT()
+ instead."""
+ if RVT == None: RVT__o = None
+ else: RVT__o = RVT._o
+ ret = libxsltmod.xsltRegisterTmpRVT(self._o, RVT__o)
+ return ret
+
+ def releaseRVT(self, RVT):
+ """Either frees the RVT (which is an xmlDoc) or stores it in
+ the context's cache for later reuse."""
+ if RVT == None: RVT__o = None
+ else: RVT__o = RVT._o
+ libxsltmod.xsltReleaseRVT(self._o, RVT__o)
+
+ #
+ # transformCtxt functions from module xsltutils
+ #
+
+ def message(self, node, inst):
+ """Process and xsl:message construct"""
+ if node == None: node__o = None
+ else: node__o = node._o
+ if inst == None: inst__o = None
+ else: inst__o = inst._o
+ libxsltmod.xsltMessage(self._o, node__o, inst__o)
+
+ def printErrorContext(self, style, node):
+ """Display the context of an error."""
+ if style == None: style__o = None
+ else: style__o = style._o
+ if node == None: node__o = None
+ else: node__o = node._o
+ libxsltmod.xsltPrintErrorContext(self._o, style__o, node__o)
+
+ def profileInformation(self):
+ """This function should be called after the transformation
+ completed to extract template processing profiling
+ informations if availble. The informations are returned as
+ an XML document tree like <?xml version="1.0"?> <profile>
+ <template rank="1" match="*" name="" mode="" calls="6"
+ time="48" average="8"/> <template rank="2"
+ match="item2|item3" name="" mode="" calls="10" time="30"
+ average="3"/> <template rank="3" match="item1" name=""
+ mode="" calls="5" time="17" average="3"/> </profile> The
+ caller will need to free up the returned tree with
+ xmlFreeDoc()"""
+ ret = libxsltmod.xsltGetProfileInformation(self._o)
+ if ret == None: return None
+ return libxml2.xmlDoc(_obj=ret)
+
+ def saveProfiling(self, output):
+ """Save the profiling informations on @output"""
+ libxsltmod.xsltSaveProfiling(self._o, output)
+
+ def setCtxtParseOptions(self, options):
+ """Change the default parser option passed by the XSLT engine
+ to the parser when using document() loading."""
+ ret = libxsltmod.xsltSetCtxtParseOptions(self._o, options)
+ return ret
+
+class stylesheet(stylesheetBase):
+ def __init__(self, _obj=None):
+ self._o = None
+ stylesheetBase.__init__(self, _obj=_obj)
+
+ # accessors for stylesheet
+ def doc(self):
+ """Get the document of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetDoc(self._o)
+ if ret == None: return None
+ return libxml2.xmlDoc(_obj=ret)
+
+ def doctypePublic(self):
+ """Get the output PUBLIC of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetDoctypePublic(self._o)
+ return ret
+
+ def doctypeSystem(self):
+ """Get the output SYSTEM of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetDoctypeSystem(self._o)
+ return ret
+
+ def encoding(self):
+ """Get the output encoding of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetEncoding(self._o)
+ return ret
+
+ def imports(self):
+ """Get the imports of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetImports(self._o)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+ def method(self):
+ """Get the output method of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetMethod(self._o)
+ return ret
+
+ def methodURI(self):
+ """Get the output method URI of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetMethodURI(self._o)
+ return ret
+
+ def next(self):
+ """Get the next sibling of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetNext(self._o)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+ def parent(self):
+ """Get the parent of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetParent(self._o)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+ def version(self):
+ """Get the output version of a stylesheet"""
+ ret = libxsltmod.xsltStylesheetGetVersion(self._o)
+ return ret
+
+ #
+ # stylesheet functions from module attributes
+ #
+
+ def freeAttributeSetsHashes(self):
+ """Free up the memory used by attribute sets"""
+ libxsltmod.xsltFreeAttributeSetsHashes(self._o)
+
+ def parseStylesheetAttributeSet(self, cur):
+ """parse an XSLT stylesheet attribute-set element"""
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ libxsltmod.xsltParseStylesheetAttributeSet(self._o, cur__o)
+
+ def resolveStylesheetAttributeSet(self):
+ """resolve the references between attribute sets."""
+ libxsltmod.xsltResolveStylesheetAttributeSet(self._o)
+
+ #
+ # stylesheet functions from module documents
+ #
+
+ def freeStyleDocuments(self):
+ """Frees the node-trees (and xsltDocument structures) of all
+ stylesheet-modules of the stylesheet-level represented by
+ the given @style."""
+ libxsltmod.xsltFreeStyleDocuments(self._o)
+
+ #
+ # stylesheet functions from module extensions
+ #
+
+ def checkExtPrefix(self, URI):
+ """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)"""
+ ret = libxsltmod.xsltCheckExtPrefix(self._o, URI)
+ return ret
+
+ def checkExtURI(self, URI):
+ """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)"""
+ ret = libxsltmod.xsltCheckExtURI(self._o, URI)
+ return ret
+
+ def freeExts(self):
+ """Free up the memory used by XSLT extensions in a stylesheet"""
+ libxsltmod.xsltFreeExts(self._o)
+
+ def registerExtPrefix(self, prefix, URI):
+ """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)"""
+ ret = libxsltmod.xsltRegisterExtPrefix(self._o, prefix, URI)
+ return ret
+
+ def shutdownExts(self):
+ """Shutdown the set of modules loaded"""
+ libxsltmod.xsltShutdownExts(self._o)
+
+ #
+ # stylesheet functions from module imports
+ #
+
+ def nextImport(self):
+ """Find the next stylesheet in import precedence."""
+ ret = libxsltmod.xsltNextImport(self._o)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+ def parseStylesheetImport(self, cur):
+ """parse an XSLT stylesheet import element"""
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ ret = libxsltmod.xsltParseStylesheetImport(self._o, cur__o)
+ return ret
+
+ def parseStylesheetInclude(self, cur):
+ """parse an XSLT stylesheet include element"""
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ ret = libxsltmod.xsltParseStylesheetInclude(self._o, cur__o)
+ return ret
+
+ #
+ # stylesheet functions from module keys
+ #
+
+ def addKey(self, name, nameURI, match, use, inst):
+ """add a key definition to a stylesheet"""
+ if inst == None: inst__o = None
+ else: inst__o = inst._o
+ ret = libxsltmod.xsltAddKey(self._o, name, nameURI, match, use, inst__o)
+ return ret
+
+ def freeKeys(self):
+ """Free up the memory used by XSLT keys in a stylesheet"""
+ libxsltmod.xsltFreeKeys(self._o)
+
+ #
+ # stylesheet functions from module namespaces
+ #
+
+ def freeNamespaceAliasHashes(self):
+ """Free up the memory used by namespaces aliases"""
+ libxsltmod.xsltFreeNamespaceAliasHashes(self._o)
+
+ def namespaceAlias(self, node):
+ """Read the stylesheet-prefix and result-prefix attributes,
+ register them as well as the corresponding namespace."""
+ if node == None: node__o = None
+ else: node__o = node._o
+ libxsltmod.xsltNamespaceAlias(self._o, node__o)
+
+ #
+ # stylesheet functions from module pattern
+ #
+
+ def cleanupTemplates(self):
+ """Cleanup the state of the templates used by the stylesheet
+ and the ones it imports."""
+ libxsltmod.xsltCleanupTemplates(self._o)
+
+ def freeTemplateHashes(self):
+ """Free up the memory used by xsltAddTemplate/xsltGetTemplate
+ mechanism"""
+ libxsltmod.xsltFreeTemplateHashes(self._o)
+
+ #
+ # stylesheet functions from module preproc
+ #
+
+ def freeStylePreComps(self):
+ """Free up the memory allocated by all precomputed blocks"""
+ libxsltmod.xsltFreeStylePreComps(self._o)
+
+ def stylePreCompute(self, inst):
+ """Precompute an XSLT stylesheet element"""
+ if inst == None: inst__o = None
+ else: inst__o = inst._o
+ libxsltmod.xsltStylePreCompute(self._o, inst__o)
+
+ #
+ # stylesheet functions from module python
+ #
+
+ def applyStylesheet(self, doc, params):
+ """Apply the stylesheet to the document"""
+ if doc == None: doc__o = None
+ else: doc__o = doc._o
+ ret = libxsltmod.xsltApplyStylesheet(self._o, doc__o, params)
+ if ret == None: return None
+ return libxml2.xmlDoc(_obj=ret)
+
+ def applyStylesheetUser(self, doc, params, transformCtxt):
+ """Apply the stylesheet to the document"""
+ if doc == None: doc__o = None
+ else: doc__o = doc._o
+ if transformCtxt == None: transformCtxt__o = None
+ else: transformCtxt__o = transformCtxt._o
+ ret = libxsltmod.xsltApplyStylesheetUser(self._o, doc__o, params, transformCtxt__o)
+ if ret == None: return None
+ return libxml2.xmlDoc(_obj=ret)
+
+ def compareStylesheetsEqual(self, other):
+ """Compare one stylesheet with another"""
+ if other == None: other__o = None
+ else: other__o = other._o
+ ret = libxsltmod.xsltCompareStylesheetsEqual(self._o, other__o)
+ return ret
+
+ def newTransformContext(self, doc):
+ """Create a new XSLT TransformContext"""
+ if doc == None: doc__o = None
+ else: doc__o = doc._o
+ ret = libxsltmod.xsltNewTransformContext(self._o, doc__o)
+ if ret == None: return None
+ return transformCtxt(_obj=ret)
+
+ def saveResultToString(self, result):
+ """Have the stylesheet serialize the result of a
+ transformation to a python string"""
+ if result == None: result__o = None
+ else: result__o = result._o
+ ret = libxsltmod.xsltSaveResultToString(self._o, result__o)
+ return ret
+
+ def stylesheetHashCode(self):
+ """Get the hash code of the stylesheet"""
+ ret = libxsltmod.xsltGetStylesheetHashCode(self._o)
+ return ret
+
+ #
+ # stylesheet functions from module variables
+ #
+
+ def parseGlobalParam(self, cur):
+ """parse an XSLT transformation param declaration and record
+ its value."""
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ libxsltmod.xsltParseGlobalParam(self._o, cur__o)
+
+ def parseGlobalVariable(self, cur):
+ """Parses a global XSLT 'variable' declaration at compilation
+ time and registers it"""
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ libxsltmod.xsltParseGlobalVariable(self._o, cur__o)
+
+ #
+ # stylesheet functions from module xsltInternals
+ #
+
+ def allocateExtra(self):
+ """Allocate an extra runtime information slot statically while
+ compiling the stylesheet and return its number"""
+ ret = libxsltmod.xsltAllocateExtra(self._o)
+ return ret
+
+ def compileAttr(self, attr):
+ """Precompile an attribute in a stylesheet, basically it
+ checks if it is an attrubute value template, and if yes
+ establish some structures needed to process it at
+ transformation time."""
+ if attr == None: attr__o = None
+ else: attr__o = attr._o
+ libxsltmod.xsltCompileAttr(self._o, attr__o)
+
+ def freeStylesheet(self):
+ """Free up the memory allocated by @style"""
+ libxsltmod.xsltFreeStylesheet(self._o)
+
+ def parseStylesheetImportedDoc(self, doc):
+ """parse an XSLT stylesheet building the associated structures
+ except the processing not needed for imported documents."""
+ if doc == None: doc__o = None
+ else: doc__o = doc._o
+ ret = libxsltmod.xsltParseStylesheetImportedDoc(doc__o, self._o)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+ def parseStylesheetOutput(self, cur):
+ """parse an XSLT stylesheet output element and record
+ information related to the stylesheet output"""
+ if cur == None: cur__o = None
+ else: cur__o = cur._o
+ libxsltmod.xsltParseStylesheetOutput(self._o, cur__o)
+
+ def parseStylesheetProcess(self, doc):
+ """Parses an XSLT stylesheet, adding the associated
+ structures. Called by: xsltParseStylesheetImportedDoc()
+ (xslt.c) xsltParseStylesheetInclude() (imports.c)"""
+ if doc == None: doc__o = None
+ else: doc__o = doc._o
+ ret = libxsltmod.xsltParseStylesheetProcess(self._o, doc__o)
+ if ret == None: return None
+ return stylesheet(_obj=ret)
+
+ def parseTemplateContent(self, templ):
+ """parse a template content-model Clean-up the template
+ content from unwanted ignorable blank nodes and process
+ xslt:text"""
+ if templ == None: templ__o = None
+ else: templ__o = templ._o
+ libxsltmod.xsltParseTemplateContent(self._o, templ__o)
+
+ #
+ # stylesheet functions from module xsltutils
+ #
+
+ def cNsProp(self, node, name, nameSpace):
+ """Similar to xmlGetNsProp() but with a slightly different
+ semantic Search and get the value of an attribute
+ associated to a node This attribute has to be anchored in
+ the namespace specified, or has no namespace and the
+ element is in that namespace. This does the entity
+ substitution. This function looks in DTD attribute
+ declaration for #FIXED or default declaration values unless
+ DTD use has been turned off."""
+ if node == None: node__o = None
+ else: node__o = node._o
+ ret = libxsltmod.xsltGetCNsProp(self._o, node__o, name, nameSpace)
+ return ret
+
+ def printErrorContext(self, ctxt, node):
+ """Display the context of an error."""
+ if ctxt == None: ctxt__o = None
+ else: ctxt__o = ctxt._o
+ if node == None: node__o = None
+ else: node__o = node._o
+ libxsltmod.xsltPrintErrorContext(ctxt__o, self._o, node__o)
+
+ def saveResultToFd(self, fd, result):
+ """Save the result @result obtained by applying the @style
+ stylesheet to an open file descriptor This does not close
+ the descriptor."""
+ if result == None: result__o = None
+ else: result__o = result._o
+ ret = libxsltmod.xsltSaveResultToFd(fd, result__o, self._o)
+ return ret
+
+ def saveResultToFile(self, file, result):
+ """Save the result @result obtained by applying the @style
+ stylesheet to an open FILE * I/O. This does not close the
+ FILE @file"""
+ if result == None: result__o = None
+ else: result__o = result._o
+ ret = libxsltmod.xsltSaveResultToFile(file, result__o, self._o)
+ return ret
+
+ def saveResultToFilename(self, URL, result, compression):
+ """Save the result @result obtained by applying the @style
+ stylesheet to a file or @URL"""
+ if result == None: result__o = None
+ else: result__o = result._o
+ ret = libxsltmod.xsltSaveResultToFilename(URL, result__o, self._o, compression)
+ return ret
+
+# xsltTransformState
+XSLT_STATE_OK = 0
+XSLT_STATE_ERROR = 1
+XSLT_STATE_STOPPED = 2
+
+# xsltDebugStatusCodes
+XSLT_DEBUG_NONE = 0
+XSLT_DEBUG_INIT = 1
+XSLT_DEBUG_STEP = 2
+XSLT_DEBUG_STEPOUT = 3
+XSLT_DEBUG_NEXT = 4
+XSLT_DEBUG_STOP = 5
+XSLT_DEBUG_CONT = 6
+XSLT_DEBUG_RUN = 7
+XSLT_DEBUG_RUN_RESTART = 8
+XSLT_DEBUG_QUIT = 9
+
+# xsltOutputType
+XSLT_OUTPUT_XML = 0
+XSLT_OUTPUT_HTML = 1
+XSLT_OUTPUT_TEXT = 2
+
+# xsltErrorSeverityType
+XSLT_ERROR_SEVERITY_ERROR = 0
+XSLT_ERROR_SEVERITY_WARNING = 1
+
+# xsltStyleType
+XSLT_FUNC_COPY = 1
+XSLT_FUNC_SORT = 2
+XSLT_FUNC_TEXT = 3
+XSLT_FUNC_ELEMENT = 4
+XSLT_FUNC_ATTRIBUTE = 5
+XSLT_FUNC_COMMENT = 6
+XSLT_FUNC_PI = 7
+XSLT_FUNC_COPYOF = 8
+XSLT_FUNC_VALUEOF = 9
+XSLT_FUNC_NUMBER = 10
+XSLT_FUNC_APPLYIMPORTS = 11
+XSLT_FUNC_CALLTEMPLATE = 12
+XSLT_FUNC_APPLYTEMPLATES = 13
+XSLT_FUNC_CHOOSE = 14
+XSLT_FUNC_IF = 15
+XSLT_FUNC_FOREACH = 16
+XSLT_FUNC_DOCUMENT = 17
+XSLT_FUNC_WITHPARAM = 18
+XSLT_FUNC_PARAM = 19
+XSLT_FUNC_VARIABLE = 20
+XSLT_FUNC_WHEN = 21
+XSLT_FUNC_EXTENSION = 22
+XSLT_FUNC_OTHERWISE = 23
+XSLT_FUNC_FALLBACK = 24
+XSLT_FUNC_MESSAGE = 25
+XSLT_FUNC_INCLUDE = 26
+XSLT_FUNC_ATTRSET = 27
+XSLT_FUNC_LITERAL_RESULT_ELEMENT = 28
+XSLT_FUNC_UNKOWN_FORWARDS_COMPAT = 29
+
+# xsltLoadType
+XSLT_LOAD_START = 0
+XSLT_LOAD_STYLESHEET = 1
+XSLT_LOAD_DOCUMENT = 2
+
+# xsltSecurityOption
+XSLT_SECPREF_READ_FILE = 1
+XSLT_SECPREF_WRITE_FILE = 2
+XSLT_SECPREF_CREATE_DIRECTORY = 3
+XSLT_SECPREF_READ_NETWORK = 4
+XSLT_SECPREF_WRITE_NETWORK = 5
+
+# xsltDebugTraceCodes
+XSLT_TRACE_ALL = -1
+XSLT_TRACE_NONE = 0
+XSLT_TRACE_COPY_TEXT = 1
+XSLT_TRACE_PROCESS_NODE = 2
+XSLT_TRACE_APPLY_TEMPLATE = 4
+XSLT_TRACE_COPY = 8
+XSLT_TRACE_COMMENT = 16
+XSLT_TRACE_PI = 32
+XSLT_TRACE_COPY_OF = 64
+XSLT_TRACE_VALUE_OF = 128
+XSLT_TRACE_CALL_TEMPLATE = 256
+XSLT_TRACE_APPLY_TEMPLATES = 512
+XSLT_TRACE_CHOOSE = 1024
+XSLT_TRACE_IF = 2048
+XSLT_TRACE_FOR_EACH = 4096
+XSLT_TRACE_STRIP_SPACES = 8192
+XSLT_TRACE_TEMPLATES = 16384
+XSLT_TRACE_KEYS = 32768
+XSLT_TRACE_VARIABLES = 65536
+
generated by cgit (git 2.34.1) at 2024-12-20 18:05:05 +0000