interface for the XSLT attribute handling
this module handles the specificities of attribute and attribute groups processing.
Daniel Veillard
interface for the document handling
implements document loading and cache (multiple document() reference for the same resources must be equal.
Daniel Veillard
interface for the extension support
This provide the API needed for simple and module extension support.
Daniel Veillard
interface for the non-standard features
implement some extension outside the XSLT namespace but not EXSLT with is in a different library.
Daniel Veillard
interface for the XSLT functions not from XPath
a set of extra functions coming from XSLT but not in XPath
Daniel Veillard and Bjorn Reese <breese@users.sourceforge.net>
interface for the XSLT import support
macros and fuctions needed to implement and access the import tree
Daniel Veillard
interface for the key matching used in key() and template matches.
implementation of the key mechanims.
Daniel Veillard
interface for the XSLT namespace handling
set of function easing the processing and generation of namespace nodes in XSLT.
Daniel Veillard
Implementation of the XSLT number functions
Implementation of the XSLT number functions
Bjorn Reese <breese@users.sourceforge.net> and Daniel Veillard
interface for the pattern matching used in template matches.
the implementation of the lookup of the right template for a given node must be really fast in order to keep decent performances.
Daniel Veillard
precomputing stylesheets
this is the compilation phase, where most of the stylesheet is "compiled" into faster to use data.
Daniel Veillard
interface for the libxslt security framework
the libxslt security framework allow to restrict the access to new resources (file or URL) from the stylesheet at runtime.
Daniel Veillard
interface for the template processing
This set of routine encapsulates XPath calls and Attribute Value Templates evaluation.
Daniel Veillard
the XSLT engine transformation part.
This module implements the bulk of the actual
Daniel Veillard
interface for the variable matching and lookup.
interface for the variable matching and lookup.
Daniel Veillard
Interfaces, constants and types related to the XSLT engine
Interfaces, constants and types related to the XSLT engine
Daniel Veillard
internal data structures, constants and functions
Internal data structures, constants and functions used by the XSLT engine. They are not part of the API or ABI, i.e. they can change without prior notice, use carefully.
Daniel Veillard
macros for marking symbols as exportable/importable.
macros for marking symbols as exportable/importable.
Igor Zlatkovic <igor@zlatkovic.com>
set of utilities for the XSLT engine
interfaces for the utilities module of the XSLT engine. things like message handling, profiling, and other generally useful routines.
Daniel Veillard
Macro to check if the XSLT processing should be stopped. Will return from the function.
Macro to check if the XSLT processing should be stopped. Will return from the function with a 0 value.
Macro to check if the XSLT processing should be stopped. Will goto the error: label.
quick check for xslt namespace attribute
Checks that the element pertains to XSLT namespace.
quick check whether this is an xslt element
Checks the value of an element in XSLT namespace.
Check that a node is a 'real' one: document, element, text or attribute.
check for bit 15 set
Special value for undefined namespace, internal
Macro to do a casting from an object pointer to a function pointer without encountering a warning from gcc #define XML_CAST_FPTR(fptr) (*(void **)(&fptr)) This macro violated ISO C aliasing rules (gcc4 on s390 broke) so it is disabled now
get pointer to compiler context
The XSLT "vendor" URL for this processor.
The XSLT "vendor" string for this processor.
The default version of XSLT supported.
Internal define to enable usage of xmlXPathCompiledEvalToBoolean() for XSLT "tests"; e.g. in <xsl:if test="/foo/bar">
A macro to import intergers from the stylesheet cascading order.
A macro to import pointers from the stylesheet cascading order.
get pointer to namespace map
check for namespace mapping
internal macro to test tree fragments
check if the argument is a text node
Common fields used for all items.
Fields for API compatibility to the structure _xsltElemPreComp which is used for extension functions. Note that @next is used for storage; it does not reflect a next sibling in the tree. TODO: Evaluate if we really need such a compatibility.
Currently empty. TODO: It is intended to hold navigational fields in the future.
The in-scope namespaces.
This is the libxslt namespace for specific extensions.
internal macro to set up tree fragments
Max number of specified xsl:sort on an element.
The XSLT specification namespace.
This is Norm's namespace for SAXON extensions.
The set of options to pass to an xmlReadxxx when loading files for XSLT consumption.
Specific value for pattern without priority expressed.
Internal define to enable on-demand xsl:key computation.
Internal define to enable the refactored variable part of libxslt
Internal define to enable the optimization of the compilation of XPath expressions.
Registering macro, not general purpose at all but used in different modules.
Registering macro, not general purpose at all but used in different modules.
Macro used to define extra information stored in the context
Macro used to free extra information stored in the context
Macro used to access extra information stored in the context
This is Michael Kay's Saxon processor namespace for extensions.
Macro to flag that a problem was detected internally.
Sampling precision for profiling
Macro to flag unimplemented blocks.
Control the type of xsl debugtrace messages emitted.
This is the Apache project XALAN processor namespace for extensions.
This is James Clark's XT processor namespace for extensions.
Add template "call" to call stack
Drop the topmost item off the call stack
If either cur or node are a breakpoint, or xslDebugStatus in state where debugging must occcur at this time then transfer control to the xslDebugBreak function
add a key definition to a stylesheet
Push an element list onto the stack.
Register the XSLT pattern associated to @cur
Allocate an extra runtime information slot statically while compiling the stylesheet and return its number
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
Apply the xsl:use-attribute-sets. If @attrSets is NULL, then @inst will be used to exctract this value. If both, @attrSets and @inst, are NULL, then this will do nothing.
Process the XSLT apply-imports element.
Processes a sequence constructor on the current node in the source tree. @params are the already computed variable stack items; this function pushes them on the variable stack, and pops them before exiting; it's left to the caller to free or reuse @params afterwards. The initial states of the variable stack will always be restored before this function exits. NOTE that this does *not* initiate a new distinct variable scope; i.e. variables already on the stack are visible to the process. The caller's side needs to start a new variable scope if needed (e.g. in exsl:function). @templ is obsolete and not used anymore (e.g. <exslt:function> does not provide a @templ); a non-NULL @templ might raise an error in the future. BIG NOTE: This function is not intended to process the content of an xsl:template; it does not expect xsl:param instructions in @list and will report errors if found. Called by: - xsltEvalVariable() (variables.c) - exsltFuncFunctionFunction() (libexsl/functions.c)
Strip the unwanted ignorable spaces from the input tree
Apply the stylesheet to the document NOTE: This may lead to a non-wellformed output XML wise !
Apply the stylesheet to the document and allow the user to provide its own transformation context.
Processes the XSLT 'apply-templates' instruction on the current node.
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).
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).
Process the given node and return the new string value.
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.
Process the xslt attribute node on the source node
Used for to correct the calibration for xsltTimestamp()
Processes the XSLT call-template instruction on the source node.
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)
Check if the resource is allowed to be read
Check if the resource is allowed to be written, if necessary makes some preliminary work like creating directories
Processes the xsl:choose instruction on the source node.
Unregister all global variables set up by the XSLT library
Cleanup the state of the templates used by the stylesheet and the ones it imports.
Process the xslt comment node on the source node
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.
Compile the XSLT pattern and generates a list of precompiled form suitable for fast matching. [1] Pattern ::= LocationPathPattern | Pattern '|' LocationPathPattern
reorder the current node list accordingly to the set of sorting requirement provided by the array of nodes.
Execute the XSLT-copy instruction on the source node.
Copies a namespace node (declaration). If @elem is not NULL, then the new namespace will be declared on @elem.
Do a copy of an namespace list. If @node is non-NULL 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.
Process the XSLT copy-of instruction.
Adds @string to a newly created or an existent text node child of @target.
Creates a Result Value Tree (the XSLT 1.0 term for this is "Result Tree Fragment")
Process an debug node
Dumps a list of the registered XSLT extension functions and elements
Get the current default debug tracing level mask
Set the default debug tracing level mask
Find decimal-format by name
reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes.
reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes. This is a wrapper function, the actual function used is specified using xsltSetCtxtSortFunc() to set the context specific sort function, or xsltSetSortFunc() to set the global sort function. If a sort function is set on the context, this will get called. Otherwise the global sort function is called.
An xsltDocLoaderFunc is a signature for a function which can be registered to load document not provided by the compilation or transformation API themselve, for example when an xsl:import, xsl:include is found at compilation time or when a document() call is made at runtime.
Pre process an XSLT-1.1 document element
Process an EXSLT/XSLT-1.1 document element
Implement the document() XSLT function node-set document(object, node-set?)
reorder the current node list @list accordingly to the document order This function is slow, obsolete and should not be used anymore.
Deallocates an #xsltElemPreComp structure.
Process the xslt element node on the source node
Implement the element-available() XSLT function boolean element-available(string)
Process the given AVT, and return the new string value.
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.
Evaluates all global variables and parameters of a stylesheet. For internal use only. This is called at start of a transformation.
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.
Check if an attribute value template has a static value, i.e. the attribute value does not contain expressions contained in curly braces ({})
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.
Evaluate the global variables of a stylesheet. This needs to be done on parsed stylesheets before starting to apply transformations. Each of the parameters is evaluated as an XPath expression and stored in the global variables/parameter hash table. If you want your parameter used literally, use xsltQuoteUserParams.
Process the expression using XPath and evaluate the result as an XPath predicate
Process the expression using XPath and get a string
Process the expression using XPath, allowing to pass a namespace mapping context and get a string
Looks up an extension element. @ctxt can be NULL to search only in module elements.
A function called at initialization time of an XSLT extension module.
Looks up an extension module element
Looks up an extension module element pre-computation function
Looks up an extension module function
Looks up an extension module top-level element
A function called at shutdown time of an XSLT extension module.
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.
Marks the result of a value-returning extension instruction in order to avoid it being garbage collected before the extension instruction exits. Note that one still has to additionally register any newly created tree fragments (via xsltCreateRVT()) with xsltRegisterLocalRVT().
Try to find a document within the XSLT transformation context. This will not find document infos for temporary Result Tree Fragments.
Find strip-space or preserve-space informations for an element respect the import precedence or the wildcards
Finds the named template, apply import precedence rule. REVISIT TODO: We'll change the nameURI fields of templates to be in the string dict, so if the specified @nameURI is in the same dict, then use pointer comparison. Check if this can be done in a sane way. Maybe this function is not needed internally at transformation-time if we hard-wire the called templates to the caller.
Process the xslt for-each node on the source node
format-number() uses the JDK 1.1 DecimalFormat class: http://java.sun.com/products/jdk/1.1/docs/api/java.text.DecimalFormat.html Structure: pattern := subpattern{;subpattern} subpattern := {prefix}integer{.fraction}{suffix} prefix := '\\u0000'..'\\uFFFD' - specialCharacters suffix := '\\u0000'..'\\uFFFD' - specialCharacters integer := '#'* '0'* '0' fraction := '0'* '#'* Notation: X* 0 or more instances of X (X | Y) either X or Y. X..Y any character from X up to Y, inclusive. S - T characters in S, except those in T Special Characters: Symbol Meaning 0 a digit # a digit, zero shows as absent . placeholder for decimal separator , placeholder for grouping separator. ; separates formats. - default negative prefix. % multiply by 100 and show as percentage ? multiply by 1000 and show as per mille X any other characters can be used in the prefix or suffix ' used to quote special characters in a prefix or suffix.
Implement the format-number() XSLT function string format-number(number, string, string?)
Free up the memory associated to the attribute value templates
Free up the memory used by attribute sets
Free up the memory allocated by all the elements of @comp
Free the XSLT extension data
Free the keys associated to a document
Free up all the space used by the loaded documents
Free up the memory used by XSLT extensions in a stylesheet
Free up the data associated to the global variables its value.
Free up the memory used by XSLT keys in a stylesheet
Free up the memory used by namespaces aliases
Frees all registered result value trees (Result Tree Fragments) of the transformation. Internal function; should not be called by user-code.
Free up a security preference block
Free up the memory allocated by @elem
Frees the node-trees (and xsltDocument structures) of all stylesheet-modules of the stylesheet-level represented by the given @style.
Free up the memory allocated by all precomputed blocks
Free up the memory allocated by @style
Free up the memory used by xsltAddTemplate/xsltGetTemplate mechanism
Free up the memory allocated by @ctxt
Implement the function-available() XSLT function boolean function-available(string)
Implement the node-set() XSLT function node-set node-set(result-tree) This function is available in libxslt, saxon or xt namespace.
Implement the generate-id() XSLT function string generate-id(node-set?)
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.
Get xslDebugStatus.
Get the default security preference application-wide
Retrieve the data associated to the extension module in this given transformation.
looks up URI in extInfos of the stylesheet
Looks up a key of the in current source doc (the document info on @ctxt->document). Computes the key if not already done for the current source doc.
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)
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.
Obsolete. *Not* called by any Libxslt/Libexslt function. Exaclty the same as xsltGetNamespace().
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()
This function analyzes @name, if the name contains a prefix, the function seaches the associated namespace in scope for it. It will also replace @name value with the NCName, the old value being freed. Errors in the prefix lookup are signalled by setting @name to NULL. NOTE: the namespace returned is a pointer to the place where it is defined and hence has the same lifespan as the document holding it.
This function is similar to xsltGetQNameURI, but is used when @name is a dictionary entry.
Lookup the security option to get the callback checking function
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 NULL, then this will try to "undeclare" a default namespace by declaring an xmlns="".
Finds the template applying to this node, if @style is non-NULL it means one needs to look for the next imported template in scope.
Read one UTF8 Char from @utf Function copied from libxml2 xmlGetUTF8Char() ... to discard ultimately and use the original API
Provides the default state for XInclude processing
Processes the xsl:if instruction on the source node.
Initializes the processor (e.g. registers built-in extensions, etc.)
Initialize the set of modules with registered stylesheet data
Computes the key tables this key and for the current input document.
Computes all the keys tables for the current input document. Should be done before global varibales are initialized. NOTE: Not used anymore in the refactored code.
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.
Check if a string is ignorable
Implement the key() XSLT function node-set key(string, object)
Try to load a document (not a stylesheet) within the XSLT transformation context
Try to load a stylesheet document within the XSLT transformation context
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.
Pops all variable values at the given @depth from the stack.
Places the variable onto the local variable stack
Process and xsl:message construct
Read the stylesheet-prefix and result-prefix attributes, register them as well as the corresponding namespace.
Checks whether that stylesheet requires white-space stripping
Register a new document, apply key computations
Creates and initializes an #xsltElemPreComp
Create a new security preference block
Register a new document, apply key computations
Create a new XSLT Stylesheet
Create a new XSLT TransformContext
Find the next stylesheet in import precedence.
This is a hashtable scanner function to normalize the compiled steps of an imported stylesheet.
Process the xslt number node on the source node
Convert one number.
Parses, validates the content models and compiles XSLT instructions.
parse an XSLT transformation param declaration and record its value.
Parses a global XSLT 'variable' declaration at compilation time and registers it
Parses a "template" content (or "sequence constructor" in XSLT 2.0 terms). This will additionally remove xsl:text elements from the tree.
parse an XSLT stylesheet attribute-set element
Processes an xsl:with-param instruction at transformation time. The value is compute, but not recorded. NOTE that this is also called with an *xsl:param* element from exsltFuncFunctionFunction().
parse an XSLT stylesheet building the associated structures
Load and parse an XSLT stylesheet
parse an XSLT stylesheet import element
parse an XSLT stylesheet building the associated structures except the processing not needed for imported documents.
parse an XSLT stylesheet include element
parse an XSLT stylesheet output element and record information related to the stylesheet output
Registers a local XSLT 'param' declaration at transformation time and evaluates its value.
Registers a local XSLT 'variable' instruction at transformation time and evaluates its value.
parse a template content-model Clean-up the template content from unwanted ignorable blank nodes and process xslt:text
Adds an item to the list.
Resets the list, but does not free the allocated array and does not free the content of the list.
Creates an xsltPointerList structure.
Frees the xsltPointerList structure. This does not free the content of the list.
Precomputes an extension module element
Display the context of an error.
Process the xslt processing-instruction node on the source node
Apply the stylesheet to the document and dump the profiling to the given output.
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.
Similar to xsltEvalUserParams, but the values are treated literally and are * *not* evaluated as XPath expressions. This should be done on parsed stylesheets before starting to apply transformations.
Registers all default XSLT elements in this context
Registers the built-in extensions
Registers all default XSLT functions in this context
Registers an extension element
Registers an extension function
Register an XSLT extension module to the library.
Registers an extension module element.
Register an XSLT extension module to the library.
Registers an extension module function.
Registers an extension module top-level element.
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)
Registers the built-in extensions. This function is deprecated, use xsltRegisterAllExtras instead.
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.
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.
Registers the test module
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.
Either frees the RVT (which is an xmlDoc) or stores it in the context's cache for later reuse.
resolve the references between attribute sets.
Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf. NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8
Apply the stylesheet to the document and generate the output according to @output @SAX and @IObuf. It's an error to specify both @SAX and @IObuf. NOTE: This may lead to a non-wellformed output XML wise ! NOTE: This may also result in multiple files being generated NOTE: using IObuf, the result encoding used will be the one used for creating the output buffer, use the following macro to read it from the stylesheet XSLT_GET_IMPORT_PTR(encoding, style, encoding) NOTE: using SAX, any encoding specified in the stylesheet will be lost since the interface uses only UTF8
Save the profiling informations on @output
Save the result @result obtained by applying the @style stylesheet to an I/O output channel @buf
Save the result @result obtained by applying the @style stylesheet to an open file descriptor This does not close the descriptor.
Save the result @result obtained by applying the @style stylesheet to an open FILE * I/O. This does not close the FILE @file
Save the result @result obtained by applying the @style stylesheet to a file or @URL
Save the result @result obtained by applying the @style stylesheet to a new allocated string.
Function used to always allow an operation
User provided function to check the value of a string like a file path or an URL ...
Function used to always forbid an operation
Change the default parser option passed by the XSLT engine to the parser when using document() loading.
Set the security preference for a specific transformation
Function to set the handler for XSLT sorting for the specified context. If the handler is NULL, then the global sort function will be called
This function allow to plug a debugger into the XSLT library @block points to a block of memory containing the address of @no callback routines.
This function sets the value of xslDebugStatus.
Set the default security preference application-wide
Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing or validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL.
Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing nor validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL.
Set the new function to load document, if NULL it resets it to the default function.
Update the security option to use the new callback checking function
Function to reset the global handler for XSLT sorting. If the handler is NULL, the default sort function will be used.
Function to reset the handler and the error context for out of context error messages specific to a given XSLT transromation. This simply means that @handler will be called for subsequent error messages while running the transformation.
Set whether XInclude should be processed on document being loaded by default
Shutdown the set of modules loaded
Shutdown the set of modules loaded
function attached to xsl:sort nodes, but this should not be called directly
Signature of the function to use during sorting
Split QNames into prefix and local names, both allocated from a dictionary.
A function called at initialization time of an XSLT extension module.
A function called at shutdown time of an XSLT extension module.
Retrieve the data associated to the extension module in this given stylesheet. Called by: xsltRegisterExtPrefix(), ( xsltExtElementPreCompTest(), xsltExtInitTest )
Precompute an XSLT stylesheet element
Retrieve the data associated to the extension module in this given stylesheet.
Implement the system-property() XSLT function object system-property(string)
Obsolete. Don't use it.
Test whether the node matches one of the patterns in the list
Process the xslt text node on the source node
Used for gathering profiling data
Display and format an error messages, gives file, line, position and extra parameters, will use the specific transformation context if available
Signature of the function associated to elements part of the stylesheet language like xsl:if or xsl:apply-templates.
Uninitializes the processor.
Implement the unparsed-entity-uri() XSLT function string unparsed-entity-uri(string)
Unregister an XSLT extension module from the library.
Unregisters an extension module element
Unregisters an extension module function
Unregisters an extension module top-level element
Process the xslt value-of node on the source node
Search in the Variable array of the context for the given variable value.
Compile an XPath expression
This is the entry point when a function is needed by the XPath interpretor.
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.
This is the entry point when a varibale is needed by the XPath interpretor.